Ignore built executable files

[atscap.git] / atscap.c

#define NAME "atscap"
#define AUTHOR "inkling"
#define EMAIL "inkling@users.sourceforge.net"
#define WEBPAGE "http://atscap.sourceforge.net"
#define COPYRIGHT "(C) 2004-2008"
#define LICENSE "GNU General Public License V2"
#define LASTEDIT "20080103"
#define LASTTIME __TIME__
#define LASTDATE __DATE__
#define VERSION "1.1"
#define VER "1.1"

/*****************************************************************************
 *
 * atscap.c    (c) Copyright 2004-2008 by inkling@users.sourceforge.net
 *           ATSC Transport Stream Capture Application Program
 *
 * atscap is free software; you may only redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2, or later,
 * as published by the Free Software Foundation.
 *
 * atscap source code is distributed to you in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY OR SUPPORT; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  Please see the
 * GNU General Public License Version 3 for more details.
 *
 * You should have received a copy of the GNU General Public License Version 2
 * along with this program; if not, write me or the Free Software Foundation,
 * Inc., at 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 *****************************************************************************/

/*
                           ATSCap.c version 1.1.0
                              January 1, 2008
                        ATSC Capture Application Program
            Copyright (c) 2004-2008 by inkling@users.sourceforge.net
*/


/* COPYRIGHT FAIR USE INTENT DISCLAIMER ***************************************
 *                                                                            *
 * IN LIGHT OF RECENT COURT DECISIONS THAT FOCUS ON INTENT, THE FOLLOWING     *
 * IS REQUIRED TO STATE UNEQUIVOCALLY WHAT IS THE INTENT OF THIS PROGRAM:     *
 *                                                                            *
 *  THIS PROGRAM IS SOLELY FOR YOU TO EXERCISE YOUR FAIR USE RIGHTS. IT IS    *
 *  NOT MEANT, NOR SHOULD IT BE USED BY YOU, TO ENGAGE IN ANY INFRINGEMENT    *
 *  OF ANY OF THE COPYRIGHTS OF ANY COMPANIES, CORPORATIONS OR INDIVIDUALS.   *
 *                                                                            *
 *  YOU MAY NOW PROCEED TO EXERCISE YOUR FAIR USE RIGHTS TO TIME-SHIFT        *
 *  AS AFFIRMED IN THE FOLLOWING UNITED STATES SUPREME COURT DECISION:        *
 *                                                                            *
 *              SONY CORP. V. UNIVERSAL CITY STUDIOS                          *
 *        464 U.S. 417, 104 S. Ct 774, 78L. Ed 2d 574 (1984)                  *
 *                                                                            *
 *****************************************************************************/


#warning using ... lines are PLATFORM SPECIFIC!

/* COMPILE OPTIONS *********************************************************/
/* You can override the Makefile defaults here */

/* This define enables use of coloration for the console. If you don't
 * want any colors other than bright normal and grey on your console,
 * then you should comment the following define.
 *   The Makefile sets this by default.
 */
/* #define USE_ECMA48 */

/* This define enables use of translation to ASCII 7-bit for all events.
 * This will provide some consistency in naming, for non-English events,
 * for the capture file names and compares used to generate the EPG.
 * This keeps the file name easy to type when capturing Mexican TV.
 */
#define USE_ASCII_XLATE

/* This define enables echo of current capture over UDP multicast address.
 * It is disabled by default. No one wants useless traffic on local net.
 * Only those who actually want to use this feature should uncomment it.
 * The Makefile will enable this.
 */
/* #define USE_MCAST */


/* This define enables rebuilding of PAT+PMT on single Program captures.
 *  This is mostly to try to overcome limitations in xine audio selection.
 *  It would be better to fix xine audio select than try to do it here.
 *
 *  You have to PICK the secondary audio from [v] VCT display, and be
 *  careful that you don't leave it set that way for regular programs.
 *  Secondary audio is supposed to be SAP, but very few stations use it.
 *
 *  This doesn't work if your station sends 2 packet PMTs, like KQED-HD.
 *  It tries to change MPEG PAT + PMT to point to single program/audio,
 *  but it only processes one packet at a timeso 2 packet PMTs confuse it.
 *  You can verify if the output is correct with atscut -m3 file.ts
 *  This is very experimental and it probably will not work.
 *  Define it in the Makefile if you want to try it, not here.
 */
/* #define USE_MPEG_REBUILD */

/* This define controls POSIX memory locking. Define this to use
 *  mlockall()/munlockall() if you run with a swapfile. This will prevent
 * the delays caused by EPG or FIFO memory being swapped out and reloading.
 * The latest changes for dynamic allocation may have broken this.
 */
/* #define USE_MMAN */

/* Enable multi-threaded http server for default or -p capture directory
 * Most people will want to use the web browser UI because it's simpler.
 * The console UI is still available even if you define USE_WWW.
 * This is currently experimental but it will be the preferred UI.
 * The web pages will still be built, even with this undefined.
 * Makefile sets this by default, but will need -w option to enable it.
 */
/* #define USE_WWW */

/* Enable GNU backtrace for automatic segfault bug-report generation. */
/* USE_GNU_BACKTRACE_SCRIPT creates /dtv/atscap-pid.sh to get line info, */
/* otherwise it creates atscap-pid.bt to inspect with atscap-bt.sh */
/* #define USE_GNU_BACKTRACE */
/* #define USE_GNU_BACKTRACE_SCRIPT */

/* This sets the format of the server list at the top of the web interface.
 * If you have multiple ATSC devices connected to one machine, leave this
 * uncommented and put an entry for "dtv" in /etc/hosts. If you have multiple
 * machines with one ATSC device connected to each machine, you will need
 * to add /etc/hosts entries for "dtv0" "dtv1" "dtv2" "dtv3". Only 4 hosts
 * are currently supported but you can add more by editing the source.
 * See also WWW_DVBS for the number of servers to list. The inactive server
 * highlighting in the HTML works only for multi-card/one-machine setup.
 * TESTME:
 * Multi-card will break if one device is cable and another is broadcast?
*/
#define USE_MULTI_CARD

#define USE_AUTO_TSID

/* These defines should be in Makefile. Set some defaults if they are not. */
/* server defaults: # of servers, hostname, base port, server threads */
#ifndef WWW_DVBS
#define WWW_DVBS        1
#endif

#ifndef WWW_HOST
#define WWW_HOST        "dtv"
#endif

#ifndef WWW_PORT
#define WWW_PORT        1380
#endif

#ifndef WWW_THREADS
#define WWW_THREADS     3
#endif

/* page colors, background, foreground, link, visited link, active link */
#define WWW_BG          "#000000"
#define WWW_FG          "#FFFFFF"
#define WWW_HLINK       "#00FF00"
#define WWW_VLINK       "#FF4040"
#define WWW_ALINK       "#00FFBF"

/* Kern font pixel sizes for mozilla san-serif for CSS EPG tiles */
#define CSS_KERN_TLARGE  16
#define CSS_KERN_DLARGE  16

#define CSS_KERN_TSMALL  14
#define CSS_KERN_DSMALL  14

#define CSS_KERN_TTINY   13

/* tupari requested these to handle issues with dvico driver:
    minimum signal strength for AOS and loop count to meet the
    minimum delay for channel change, in milliseconds.

    You may need to increase AOS_*_DELAY to 500 if driver doesn't
    already wait 250ms. 8VSB sometimes get lock faster than QAM.
*/
#define AOS_MIN_STRENGTH 45
#define AOS_MIN_LOOPS 5
#define AOS_MAX_LOOPS 3

#define AOS_QAM_DELAY 500
#define AOS_VSB_DELAY 250

#ifdef USE_POWERDOWN
#warning using POWERDOWN delay 300s
#define USE_POWERDELAY 300
#endif

/* CSS tiled EPG puts a small divider at this point */
#define PRIMETIME_HOUR 18

/* Use XHTML 1.0 vs HTML 4.01. XHTML is only for validator testing */
// #define USE_XHTML
/* only define this if layout can't be achieved through proper means */
// #define USE_BADML

/******************************************************* COMPILE OPTIONS END */


/******************* standard definitions and includes  **********************/

/* __FUNCTION__ compiler debug macro gives type warnings on gcc 3.4.4 */
#define WHO (char *) __FUNCTION__
#define WHERE (int) __LINE__
#define WHOAMI dvrlog( LOG_INFO, "%s:%d", WHO, WHERE)
/* seem to be some differences in gcc representation of __FUNCTION__.
   gcc 3.4.4 probably using unsigned char, and 3.3.5 signed char,

   gcc 2.96 is unsigned char. Remove the labels with #define WHO ""
*/

#define itlower(a) if ((a>='A')&&(a<='Z')) a |= 0x20

/* 5 minutes max in signal scan */
#define SIGNAL_SCAN_TIMEOUT 300
/* console timeout before autoguide starts, 60 for distro 5 for debug */
#define PROGRAM_GUIDE_TIMEOUT 60

/* try to find screen on path and execute it for window manager */
#define SCREEN

/* set these before includes to trigger different methods */
/* PORTING: */
#define GNULINUX
#ifdef GNULINUX
#define _GNU_SOURCE
/* fseeko ftello */
/* #define _LARGEFILE_SOURCE */
/* fseeko64 ftello64 */
/* #define _LARGEFILE64_SOURCE */
/* which one to use by default */
#define _FILE_OFFSET_BITS 64
#endif

/* linuxthreads docs say #define _REENTRANT for thread-safe glibc functions. */
#define _REENTRANT
#include <sys/select.h>
#include <pthread.h>

#include <ctype.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>

#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <getopt.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <time.h>
#include <utime.h>
#include <sys/time.h>
#include <sched.h>
#include <sys/mount.h>

/* kb blinkies ioctl vals */
#include <linux/kd.h>

/* will need for signal actions, sigterm mostly */
#define USE_SIGNALS
#ifdef USE_SIGNALS
#warning using POSIX signals
#include <signal.h>
#endif

/* statfs to get free space */
// #include <sys/vfs.h>
#include <sys/statfs.h>
#include <math.h>

/* openlog syslog closelog syslog(3) */
#include <syslog.h>

#warning using Linux DVB
#include <linux/dvb/frontend.h>
#include <linux/dvb/dmx.h>

/* make atscap-udp */
#ifdef USE_WWW
#warning using TCP for HTTP
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <netdb.h>

#endif

#ifdef USE_GNU_BACKTRACE
#warning Using GNU backtrace()
#include <execinfo.h>
#ifndef __USE_GNU
#define __USE_GNU
#endif
#include <ucontext.h>
#define BTZ 32
#endif


/* non-break space, won't split on this */
#define NBSP "&nbsp;"

#ifdef USE_PNG
#warning using PNG for signal chart
#include <png.h>
#endif

#define SIG_PNG_W 50
#define SIG_PNG_H 50
#define SIG_PNG_B 4
#define SIG_PNG_COMP Z_BEST_COMPRESSION
/* #define SIG_PNG_COMP Z_NO_COMPRESSION */

#define WWW_HOST_MAX 256

/* INADDR_ANY is default */
#define WWW_IP "0.0.0.0"
/* Trying three threads to see what happens, seems OK. */
/* Class c is default netmask if not bound to INADDR_ANY. */
#define WWW_MASK 0xFFFFFF00
/* default directory. should be long enough */
#define WWW_ROOT "/dtv"
#define WWW_ROOT_MAX 256

/* use this for jumbo frames */
/* #define WWW_TCP_MAX 7000 */
/* but most people will use this. may cause weirdo problems */
#define WWW_TCP_MAX 1500

#include <glob.h>

#ifdef USE_MCAST
#warning using UDP for MULTICAST
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif


/* POSIX unistd.h sets _POSIX_MEMLOCK, unistd.h is above */
#ifdef _POSIX_MEMLOCK
#ifdef USE_MMAN
#include <sys/mman.h>
#warning using POSIX mlockall()/munlockall()
#endif
#endif

/****************************** END OF INCLUDES ******************************/


/* DEFINITIONS BEGIN ******************************************************/

#define ATSC_MGT        0xC7
#define ATSC_TVCT       0xC8
#define ATSC_CVCT       0xC9
#define ATSC_RRT        0xCA
#define ATSC_EIT        0xCB
#define ATSC_ETT        0xCC
#define ATSC_STT        0xCD

#define MPEG_PAT        0x00
#define MPEG_CAT        0x01
#define MPEG_PMT        0x02

/* this one is broken for KRIV FOX local station. enable for testing */
/* #define ENABLE_VN_ETT */

#define CAP_INFO 3
#define CAP_TIME 2
#define CAP_USER 1
#define CAP_NONE 0

/* O_STREAMING does nothing if not defined. it's for 2.4.x with RML patch.
   fix compile problem when O_STREAMING (2.4 RML patch) not in fcntl.h
*/
#ifndef O_STREAMING
#define O_STREAMING 0
#endif
/* defaults for file access via open() */
#define FILE_ROMODE O_RDONLY
#define FILE_RMODE O_RDWR
#define FILE_WMODE O_RDWR | O_CREAT | O_TRUNC | O_STREAMING
/* umask 022 makes this 0644 */
#define FILE_PERMS 0644

/* transport stream packet size */
#define TSPZ 188

/* transport stream sync byte */
#define TSYNC 0x47

/* transport stream packets per block */
#define TSPPB 21

/* 21 packets, just under 4k */
#define TSBUFZ (TSPZ * TSPPB)
/* Average packet rate, octet rate and bit rates for transport stream.
 * 12898 comes from most frequently observed rate with better timing measure.
 * It should also be enough for cable, since cable sends HD at similar rate.
 * Nothing should depend on TSPRATE. TSORATE is used to calculate how much
 * space the current timers on the list might use, but it is only a very
 * rough estimate and way too high for SD content.
 */
 
#define TSPRATE 12898
#define TSORATE (TSPRATE * TSPZ)
#define TSBRATE (TSORATE * 8)

/* use the larger define if filesystem is ext2 or ext3 or heavy XFS loading */
#define FIFOZ_CAP (TSPZ * TSPRATE * 4)
#define FIFOZ_EPG (TSPZ * 6450)

/* standard seconds in a standard day */
#define SECDAY 86400
/* standard hour */
#define SECHR 3600
#define SEC3HR 10800
/* standard minute */
#define SECMIN 60
#define SECDT 5


/* This program does not use curses, it uses macros for VT codes.
 * The reason for this is that curses is a PITA and is not needed.
 * Everyone should have xterm, and these codes work fine with it:
 *      man console_codes
 */

/* see keys.c for a way to print out your edit pad keycodes */

/* console scan esc uses
 kb remap of special esc keys to single byte values
 move these around to anything above 127 to suit yourself
 vt102 1980 standard stuff? maybe

 KR_ is raw return byte string from read(0,...)

 KB_ is cooked to something simpler for console_scan()

*/

/* ESC [ A */
#define KR_UP 0x1B5B41
#define KB_UP 0xF1
/* ESC [ B */
#define KR_DN 0x1B5B42
#define KB_DN 0xF2
/* ESC [ C */
#define KR_RT 0x1B5B43
#define KB_RT 0xF3
/* ESC [ D */
#define KR_LF 0x1B5B44
#define KB_LF 0xF4

/* things get a bit odder here. may have to redefine if not xterm/aterm. */
/* ESC [ 1 ~ */
#define KR_HM 0x1B5B317E
#define KB_HM 0xF5
/* ESC [ 2 ~ */
#define KR_IN 0x1B5B327E
#define KB_IN 0xF6 
/* ESC [ 3 ~ */
#define KR_DL 0x1B5B337E
#define KB_DL 0xF7
/* ESC [ 4 ~ */
#define KR_EN 0x1B5B347E
#define KB_EN 0xF8
/* ESC [ 5 ~ */
#define KR_PU 0x1B5B357E
#define KB_PU 0xF9
/* ESC [ 6 ~ */
#define KR_PD 0x1B5B367E
#define KB_PD 0xFA

/* these color definitions assume linux vt102/xterm + ecma48 support */
#define N "\000"
#define VT102

#ifdef VT102
#define CR "\033[K\r"
#define NL "\033[K\n"
#define CLS "\033[1;1H\033[2J"

/* clear to end of line */
#define CEL "\033[K"
/* clear entire display, keep cursor pos */
#define CED "\033[2J"
/* clear from start of screen to cursor */
#define CSC "\033[1J"
/* clear from cursor to end of screen */
#define CCE "\033[J"
/* home cursor */
#define HOM "\033[1;1H"

#define DCARC "\033[%d;%dH" 

/* version+email then last cap status */
#define DCA0 HOM
/* use/free/total */
#define DCA_SPACE "\033[1;32H"
/* clock */
#define DCA_CLOCK "\033[1;59H"
/* header2 */
#define DCA_HEAD2 "\033[2;1H"
/* input field */
#define DCA_INPUT "\033[2;1H"
/* sig hdr field */
#define DCA_SIG "\033[2;18H"
/* device ID */
#define DCA_DEV "\033[2;72H"
/* signal scan line */
#define DCA_HEAD3 "\033[3;1H"
#define DCA_HEAD3C "\033[3;%dH"
/* timer header */
#define DCA_HEAD4 "\033[4;1H"
/* help header */
#define DCA_HELP "\033[5;1H"
/* tvct header */
#define DCA_VCT "\033[4;1H"
#define DCA_MGT "\033[4;1H"
#define DCA_CVC "\033[5;1H"

/* epg filter flags, bottom center */

/* program guide body start */
#define DCA_PG  "\033[4;1H"
#define DCA_PAGE "\033[25;1H"

/* extra lines */
#define DCA_15_1 "\033[19;1H"
#define DCA_16_1 "\033[19;1H"
#define DCA_17_1 "\033[19;1H"
#define DCA_18_1 "\033[19;1H"
#define DCA_19_1 "\033[19;1H"
#define DCA_20_1 "\033[20;1H"
#define DCA_21_1 "\033[21;1H"
#define DCA_22_1 "\033[22;1H"
#define DCA_23_1 "\033[23;1H"
#define DCA_24_1 "\033[24;1H"
#define DCA_25_1 "\033[25;1H"

/* STT, full time it thinks it has from the stream */
#define DCA_STT "\033[25;52H"

/* these seem broken in older aterm, show status uses */
/* save and restore cursor position */
#define SCP "\033[s"
#define RCP "\033[u"

/* set cursor invisible and visible
 #define SCI ""
 #define SCV ""
*/
#define SCI "\033[?25l"
#define SCV "\033[?25h"

/* dumbterm or printer use has been limited by direct cursor address */
#else
#define CR "\r"
#define NL "\n"
#define CLS "\014"
#endif

/*  colors, these can be safely disabled without breaking the output
    bright attribute for: black red green yellow blue magenta cyna white
 */

/* need bright control if no color */
/* attributes, normal, blink, inverse */
#define BK "\033[1;30m" 
#define BN "\033[0m"
#define BW "\033[1;37m"
#define BL "\033[5m"
#define BV "\033[7m"
/* bright white background for timer blink, inverts it so bright white text */
#define BBW "\033[47m" 
#define BT "\033[1;41;37m"

#ifdef USE_ECMA48
#warning using ECMA-48 for console colors
#define BR "\033[1;31m" 
#define BG "\033[1;32m"
#define BY "\033[1;33m"
#define BB "\033[1;34m"
#define BM "\033[1;35m"
#define BC "\033[1;36m"
#else
#define BR ""
#define BG BW
#define BY ""
#define BB ""
#define BM ""
#define BC ""
#endif

/* bar is 0-49, 2% increments */
#define SCALE_BAR 50

/* test for detached or quiet: fprintf if not detached and not quiet */
#define aprintf if ((arg_detach == 0) && (arg_quiet == 0)) fprintf

#define ahttp_log if (0 != arg_hlog) http_log
#define advrlog if (0 != arg_log) dvrlog
#define asyslog if (0 != arg_log) syslog

/* payload status */
#define PAY_READ 1
#define PAY_PARSE 2
#define PAY_GOOD 3
#define PAY_DROP 4

/* virtual channel elementary stream limit (first two, vid + main aud) */
#define VC_ES_LIMIT 2

/* cap info can only get so much from a bad stream. threshold and seconds */
/* SS is signal strength limit */
#define QOS_INFO_SS_LIMIT 40
#define QOS_INFO_TIMEOUT 30
#define PGM_INFO_TIMEOUT 60

/* ******************************************************* HTML definitions **/
#define DOCTYPE_XHTML "<!DOCTYPE html PUBLIC \042-//W3C//DTD XHTML 1.0 Transitional//EN\042 \042http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\042>\n"
#define DOCTYPE_HTML4 "<!DOCTYPE html PUBLIC \042-//W3C//DTD HTML 4.01 Transitional//EN\042 \042http://www.w3.org/TR/html4/loose.dtd\042>\n"
#define DOCTYPE_HTML3 "<!DOCTYPE html PUBLIC \042-//W3C//DTD HTML 3.2 Final//EN\042>\n"

/* uses these in non-http mode, too. yes i know, it's wide */
#define IMG_FMT "<img alt=\042%s\042 src=\042%s\042 width=%d height=%d hspace=%d vspace=%d border=%d />"
#define IMGA_FMT "<img alt=\042%s\042 src=\042%s\042 align=\042%s\042 width=\042%d\042 height=\042%d\042 hspace=\042%d\042 vspace=\042%d\042 border=%d />"
#define IMGB_FMT "<img alt=\042%s\042 src=\042/pg/img/%s\042 width=%d height=%d hspace=%d vspace=%d border=%d />"
#define IMGX_FMT "<img alt=\042%s\042 src=\042%s\042 border=\042%d\042 />"
#define IMG_EPG_FMT "<img alt=\042%s\042 src=\042/pg/img/%s\042 border=\0420\042 />"
#define IMG_EPG_CLASS "<img class=\042img_%s\042 alt=\042%s\042 src=\042/pg/img/%s\042 />"
#define IMG_EPG_CSS "<img class=\042%s\042 />"

/* table format: validator says align can only be: left center right */
#define TBL_FMT "<table border=%d cellspacing=%d cellpadding=%d align=\042%s\042 width=\042%s\042>\n"
#define TBL_BRD 0

/* table data format: validator says no halign: dump_epg_html after head */
#define TD_FMT "<td valign=\042%s\042 width=\042%s\042>"
//#define TD_FMT "<td halign=\042%s\042 width=\042%s\042>"

/* table header format: validator says no border or halign: build head html3 */
#define TH_FMT "<th valign=\042%s\042 width=\042%s\042>"

#define FN_FMT "<%s %s %s> %s\n"

#define HR_FMT "<hr width=\042%s\042>\n"



/********************************************** end of standard definitions */


/*** START GLOBAL ****************************************** START GLOBAL ***/

volatile long long vol_free = 0LL;
volatile long long vol_size = 0LL;
volatile long long cut_free = 0LL;
volatile long long cut_size = 0LL;

/* table of ecma-48 bright on black text colors */
char bc[8][8] =
{
    BN,BB,BM,BR,BY,BG,BC,BW
};

char *boilerplate =
BG NAME " " VERSION " " LASTEDIT " is " COPYRIGHT " by " EMAIL "\n"
"New versions of " NAME " may be found here:  " WEBPAGE "\n"
"The author of " NAME " may be reached here:  " EMAIL "\n"
"\n"
BW NAME " is free GPL software. Any use" BR "*" BW " implies acceptance of the "
"terms of the\n"
" " LICENSE ". If you did NOT receive a copy of the Source and\n"
" the License, please report it to me or to the Free Software Foundation, Inc.,\n"
" at 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n"
"\n"
BR"*USE " NAME " AT YOUR OWN RISK. " NAME " IS DISTRIBUTED WITHOUT ANY WARRANTY.\n"
"\n";

/* every option program needs one of these */
char *usehelp =
"Usage:\n"
"       "NAME" {-options}\n"
"\n"
"       -h              Help? This is it! Good Luck!\n"
"\n"
"       -v              Show version, boilerplate and buffer use\n"
"\n"
"       -i #            Input device #, default is 0 for /dev/dvb/adapter0\n"
"\n"
"       -m              Captures sequence and frame data to .tsx files.\n"
"                        This makes xtscut usable immediately after capture,\n"
"                        without having to generate the files with atscut -s\n"
"                        Data is generated only for single Program captures.\n"
"\n"
"       -n              Pad single Program cap with NULL packets. Keeps the\n"
"                        bitrate constant at 19.36Mb/s for hardware players.\n"
"                        NOTE: This uses 8.7G per hour no matter what.\n"
"                        If you have Roku HD1000 or similar, use this option.\n"
"\n"                
"       -c path         Config file path override, default is /etc/atscap/.\n"
"                        Files are named atscap[0-3].conf to match\n"
"                         /dev/dvb/adapter[0-3]. See also: -i\n" 
"\n"
"       -s seconds      Capture arg channel for seconds duration; example:\n"
"                        -s1800 19 gets chan 19 for 30 minutes.\n"
"                        -s ignores stdin.\n"
"                       See also: -o -p -i -q -d\n"
"\n"
"       -o file         Output filename override default of MMDD-hhmm-CH.ts\n"
"                       Mostly useful for single capture from cron script.\n"
"                       See also: -s -p\n"
"\n"
"       -p path         Capture output path override, default is /dtv/.\n"
"                       Remember you can symlink /dtv/ anywhere you like.\n"
"                       See also: -s -o\n"
"\n"
"       -g seconds      change default guide load/display timeout.\n"
"\n"
"       -z nn [99]      Zap cap if QoS drops below this value for a minute.\n"
"\n"
"       -k              Klutz Keyboardo mode, disables stdin. Use for demos.\n"
"\n"
"       -F n            Select frequency table from one of the following:\n"
"                        8VSB: (default if -F not specified)\n"
"                               0 USA ATSC center frequencies (-28615 Hz)\n"
"                        QAM256:\n"
"                               1 USA Cable EAI-542 HRC center frequencies\n"
"                               2 USA Cable EAI-542 IRC center frequencies\n"
"                               3 USA Cable HRC center frequencies\n"
"                               4 USA Cable IRC center frequencies\n"
"                               5 USA Cable Standard center frequencies\n"
"\n"
"       -l              Log a lot more activity than usual; debug log\n"
"                        Default is to log version and capture info.\n"
"                        Be advised this is likely to cause buffer overruns\n"
"                        from the dvb device when this is enabled, unless\n"
"                        you send the log to a file on a RAM volume.\n"
"\n"
"       -d              Detach forks itself to a process without stdio.\n"
"                        Control is returned immediately to caller.\n"
"                         Use with -s if you don't want script to wait.\n"
"                         Use without -s and it enters timer daemon mode.\n"
"\n"
"       -q              Quiet disables stdout, but doesn't detach.\n"
"                        Control is not returned to caller until completion.\n"
"                         Use with -s if you want script to wait.\n"
"\n"
"       -N              No boilerplate/mem usage splash delay.\n"
"                        Makes it start immediately. This is not recommended\n"
"                         because the device needs a few seconds to reset.\n"
"\n"
"       GNU SCREEN OPTIONS ARE CONSIDERED EXPERIMENTAL BUT WORK FINE.\n"
"\n"
"       -W              Use GNU screen to manage the session. Default: no.\n"
"\n"
"       -D              Use GNU screen to start detached. Default: no.\n"
"\n"
"       -R              Use GNU screen to re-attach session. Default: no.\n"
"\n\n\n"
"********************************* EXPERIMENTAL ****************************\n"
"\n"
"       -E              EPA Energy Star mode. EPG from RAM allows hard drive\n"
"                        spin-down timer to kick in and save some wattage.\n"
"\n"
"                       Use hdparm -C to inspect, hdparm -S60 to spin-down.\n"
"                        Cool-n-Quiet or SpeedStep should also be used.\n"
"                        tmpfs will be mounted at /dtv/ram, or -p path/ram\n"
"                        Spin down may not be supported by your IDE drive.\n"
"                        hdparm -S may be IDE and SATA specific.\n"
"\n"
"\n";

char usehelpx[] = "" 
#ifdef USE_WWW
"\n"
"\n"
"       THE REST ARE VERY EXPERIMENTAL. YOU HAVE BEEN WARNED.\n"
"       THESE MAY NOT WORK AT ALL, OR CAUSE ALL KINDS OF PROBLEMS:\n"
"\n"
"***************** EXPERIMENTAL TCP HTTP WEB SERVER EXAMPLES ***************\n"
"\n"
"       Put an IP address and name entry in /etc/hosts for this machine.\n"
"       Put a service name and host mask in /etc/hosts.allow for local net.\n"
"\n"    
"       /etc/hosts:\n"
"               192.168.1.2 dtv\n"
"\n"
"       /etc/hosts.allow:\n"
"               atscap: 192.168.1.\n"           
"\n"
"       atscap -w ADDR[:MASK:PORT:THREADS]\n"
"           Enable small HTTP server:\n"
"               ADDR is required, dotted IP or hostname allowed\n"
"               MASK defaults to Class C subnet, dotted or number of bits\n"
"               PORT defaults to TCP port 80, is PORT+devnum for actual port\n"
"               THREADS defaults to 5 threads\n"
"\n"
"       atscap -i0 -w dtv:24:380:10\n"
"           Start server on host dtv, TCP port 380\n"
"       atscap -i1 -w dtv:24:380:10\n"
"           Start server on host dtv, TCP port 381 (-i1 adds 1 to PORT)\n"
"               The subnet mask will allow connects from 192.168.1.x only.\n"
"               The server will start 10 threads for incoming connections.\n"
"\n"
"       NOTE:  xine http:// doesn't do Range: but mplayer reportedly does.\n"
"\n"
"\n"
#endif
#ifdef USE_MCAST
"************** EXPERIMENTAL ************* UDP MULTICAST SERVER ************\n"
"\n"
"       -u ADDR:PORT\n"
"\n"
"                   Echo live stream to Multicast UDP address and port.\n"
"               [u] key will toggle transmit off or on. Default is on.\n"
"\n"
"       NOTES:      This will probably only work with hardware decoders that\n"
"               actually can deliver a certain frame rate without delays.\n"
"               Use -n (nulls) for hardware deocders. They need them.\n"
"\n"
"                   You have to set the Virtual Program Number because most\n"
"               hardware players can't understand multiplexed streams.\n"
"\n"
"       IP UDP Multi-Casting Setup:\n"
"                   Build a kernel with IP multi-casting, but no tunnelling\n"
"               or routing unless you need those for other uses.\n"
"\n"
"                   The problems with UDP are that it sends too fast, has no\n"
"               handshake or throttling and no trick modes. Unless decoder\n"
"               is fast enough to keep up, it will drop frames and look bad.\n"
"\n"
"                   UDP works live because ATSC dvb device is the throttle.\n"
"               With TCP + software playback, the decoder is the throttle.\n"
"\n"
"        Examples:\n"
"\n"
"               For capture system [as root]:\n"
"                 # " NAME " -u 224.1.2.3:1234\n"
"\n"
"               For player system(s) [as user]:\n"
"                 $ xine udp://224.1.2.3.4:1234\n"
"\n"
"                   Captures are still saved so you won't miss anything.\n"
"               Real testing shows playback worse than http mode, but YMMV!\n"
"               It looks about as bad as xine direct from dvb device.\n"
"\n"
"\n"
#endif

"************** EXPERIMENTAL **************** MISCELLANY *******************\n"
"\n"
"       -a              Enable Acquisition Of Signal check before capture.\n"
"                        This depends on your ATSC device driver having a\n"
"                        working signal strength function. Most devices\n"
"                        do NOT have a working signal strength function.\n"
"\n"
"       -A              Strict enforcement ATSC A/65b & MPEG reserved bits:\n"
"                         If [v] or [g] or [p] stop working with this\n"
"                         it means the station is a bit out of spec.\n"
"                        Default check is Table ID and protocol version.\n"
"\n"
"       -r file.ts      Read-only replay simulation of capture, 10x speed.\n"
"                        Mostly used for PSIP debug of atscut -kmgt samples.\n"
"                        Path in filename overrides /dtv/ or -p path.\n"
"\n"
"       -e              Extra error detail toggle off. This will not fill\n"
"                        the .html capture log with error per second detail.\n"
"\n"
"************** FILE SYSTEMS ***********************************************\n"
"\n"
"           Ext2/3 and others will glitch the capture transfer if you delete\n"
"       files from the capture directory during a current capture.\n"
"       The ext2/3 unlink() routines are too inefficient for large files.\n"
"\n"
"           XFS does not suffer this problem, which is why it is recommended.\n"
"       If you can manage to move your drives to XFS you will see a benefit.\n"
"\n"
"           The only drawback is XFS does not support bad blocks like ext2/3.\n"
"       If you have drives with bad blocks, you should stay with ext2/3.\n"
"\n"
"           If you can manage cutting from one physical volume to another,\n"
"       you should not see any problems with single channel saturation.\n"
"       I'm testing xfs/xfs, xfs/ext3 and ext3/ext3 to see how it goes.\n"
"\n"
"       NOTE: USB storage: use separate controllers to make it faster.\n"
"\n"
"***************************************************************************\n"
"\n"
#if 0
"************************************ TODO *********************************\n"
"ENVIRONMENT VARIABLES: [TODO: need to write parse envars()...]\n"
"\n"
"       ATSCAP_FIFO=n           FIFO allocated n bytes instead of 9MB\n"
"       ATSCAP_MCAST=addr:port  IP multi-cast uses this address for UDP broadcast\n"
"       ATSCAP_HTTP=addr:port   http binds to this instead of inaddr_any\n"
"       ATSCAP_THREADS=n        http uses this many threads instead of 3\n"
"\n"
"   If someone wants to write these, go ahead! It's far down my own list.\n"
"***************************************************************************\n"
#endif
"\n";

char *usehelpshort = 
"\n"
"\n"
"EXAMPLE OPTION USAGE:\n"
"\n"
"    Check device number X for stations and create "
"/etc/" NAME "/atscapX.conf:\n"
"\n"
"               Where X is number 0-3 given with -i:\n"
"               " NAME " -i0 -S (single card users or first card)\n"
"                  \042   -i1 -S (two card users)\n"
"                  \042   -i2 -S (three card users)\n"
"                  \042   -i3 -S (four card users)\n"
"\n"
"    Multi-card users may save time by copying the first config file.\n"
"\n"
"    Start a web server for a 253 IP subnet at 1.2.3.1, on port 1080\n"
"       with a maximum of 5 threads to be used for http, on dvb0.dvr0.\n"
"       This is assuming you have the ethernet card at 1.2.3.1.\n"
"\n"
"\t\t" NAME " -i0 -w 1.2.3.1:24:1080:5\n"
"\n"
"       You can also use a hostname to access it behind NAT, but you will\n"
"       need to update /etc/hosts with the hostname you will use, with\n"
"       different ip addresses on the server and the client machines.\n"
"\n"
"       This example will start the http server without a netmask. You\n"
"       use TCP wrapper /etc/hosts.allow & hosts.deny to limit access.\n"
"\t\t" NAME " -i0 -w dtv:0:380:5\n"
"\n"

;

char *welcome = 
BW "Welcome to " NAME " " VERSION "-" LASTEDIT
BC   " compiled on " LASTDATE " at " LASTTIME "\n"
;


/* what you see when you hit ? */
char *timerskeyhelp =
BG "Manual Control: "BR"(locked out during capture, "BY"[o] overrides for Over Time"BR")\n\n"
BG "  [v] Virtual Channel Guide      "BW"[p] view Program Guide"BG"  [g] Master Guide\n"
BG "  = [ ] ' + arrows  Scroll keys  [e] toggle elapsed/ETA  [s] toggle TS stats\n"
BG "  [u] toggle UDP simulcasting    [f] last capture log    [^L] redraw console\n"
BR "  [1-9/A-Z] channel hotkeys      [ENTER] manual capture  " BY "[BKSP] stop capture\n"
BR "  [TAB] toggle timers/channels   [w] toggle sig info     [x] clear sig stats\n"
BR "  [l] load Program Guide         [a] toggle auto EPG     [q] quit atscap\n"
BN "\n"
BM "Timer Control:\n\n"
 "  [t] set a timer                [m] move timer          [r] reschedule/remove\n"
 "  [d] delete a timer             [!] clear all timers    [z] zap current timer\n"
 "  [_] load configuration         [+] save configuration\n"
BN "\n";

char *programskeyhelp =
"\n" CEL
BC"Program Guide Control:\n\n"
"  [UP] / [=]   [DN] / ['] scroll large list\n" 
"  [0] - [9] / [A] - [Z] jump to page 0 - 35\n"
"  [t] add timer for event range, optional weekday bits\n"
"  [m] show only events with names that match timers\n"
"  [s] toggle spam status for event range\n"
"  [a] toggle age past events\n"
"  [h] toggle hide junk events\n"
"  [n] toggle numeric debug display\n"
"  [z] stop PG cap & exit PG\n"
"  [x] clear PG\n"
"  [p] exit PG\n"
"\n"
BW
"  EPG# (range) is specified by \042r1 - r2\042\n"
"  Input abort for [s] and [t] is [ENTER] key (blank line)\n"
BN
"  [t] with weekday bits specifies permanent weekday timer.\n"
"  [t] without weekday bits specifies volatile one-shot timer.\n"
BN
; /* programskeyhelp */

char *vchannelskeyhelp =
"\n"CEL
BC "Virtual Channel Guide Control:\n\n"
"  [UP] or [=]   [DN] or ['] scroll large list\n"
"  [1] to [9] select Virtual Channel 1 through 9 to set Program\n"
"  [c] select next Virtual Channel Program \n"
"  [a] select next Audio Channel within Program\n"
"  [r] reset to full capture: ATSC PSIP and all Virtual Channels\n"
"  [d] toggle details for VCT and PMT descriptors\n"
"  [v] or [ENTER] exit Virtual Channel Guide\n"
"  [m] to toggle MPEG PAT/PMT Virtual Channels (vs ATSC)\n"
"  [ENTER] twice to start cap with current Program and Audio\n"
"\n"
"  The Program and Audio selected will be used for manual captures.\n"
BR"     RED missing, " BY "YELLOW ignored, " BG "GREEN current\n"
BN
; /* vchannelskeyhelp */

char *mgtkeyhelp = 
"\n" CEL
BG "Master Guide Table " BN "shows the relationship between\n"
"PID (Packet ID) and ATSC table type. Without this guide,\n"
"there is no Event Program Guide, since this table contains\n"
"the only way to cross reference the ATSC EPG table types.\n"
"\n"
"It is scrollable with the up and down arrows or [=] ['] keys, but\n"
"no other options are available for it since it is display only.\n"
"Also, be aware that it is not kept after channel changes.\n"
; /* mgtkeyhelp */

char *caplogkeyhelp =
"\n" CEL
BG " Capture Log " BN "shows the current capture error status.\n"
"\n"
"It is scrollable with the UP and DOWN arrows or [=] ['] keys, but\n"
"no other options are available for it since it is display only.\n"
"\n"
"After the log has enough minutes to fill the screen, you can hit\n"
"[f] key twice to start the display from current minute.\n"

; /* caplogkeyhelp */


/* what you see when you pull up usage */
char *keyhelp =
"    Manual Control ( *=locked out during capture, $=locked out during timer )\n\n"
"       PGUP/DN scroll keys for navigation\n"
"       Arrows  more scroll keys for navigation\n"
"       = [ ] ' non edit scroll keys for navigation\n"
"\n"
"   *   1-9/A-Z hotkey to conf channel list offset and lock onto it\n"
"                 hit same key to toggle signal scan on/off\n"
"   *   SP      toggle channel lock | scan (spacebar key)\n"
"   *   w       toggle signal percent | peak | wavelen | freq | SNR\n"
"   *   a       toggle automatic signal scan timeout enable | disable\n"
"   *   q       quit (locked out during capture to prevent accidents)\n"
"   $   CR      [ENTER] start VC capture of MPEG2 on selected VC\n"
/* "   $   \\       [BackSlash] start capture of full ATSC stream\n" */
"   $   BS      [BackSpace Delete] (not ^H) stop capture\n"
"       TAB     toggle timer/channel list display\n"
"       l       load Program Guide for current channel\n"
"       o       override in-progress timer, switch to manual, unlock DEL/BS\n"
"       x       clear logged signal or capture statistics\n"
"       p       Event Program Guide (EPG)\n"
"       v       Virtual Channel Table display and VC + audio selection\n"
"       g       Master Guide Table (MGT) display, scrollable list\n"
"       f       capture log with overall errors per second, scrollable list\n"
"       s       statistics display toggle\n"
"       z       zap, stop capture and delete capture files, or stop info cap\n"
"     ctrl-L    clear and refresh display\n"
"     ctrl-C    abort " NAME ". stops capture or signal scan then exits\n"
"\n"
"    Timer Control:\n\n"
"       t       set a timer for channel, hh:mm, length mm, daybits and name\n"
"       m       move timer to another config file\n"
"       r       reschedule/remove a timer or range of timers\n"
"       d       delete a timer or range of timers\n"
"       e       toggle elaspsed or remaining time for current timer\n"
"       _       load configuration info (channels, timers) from file\n"
"       +       save configuration info (channels, timers) to file\n"
"       !       delete all timers on list (does not save until next add)\n"
"\n"
"    Program Guide Control (after [p] key):\n\n"
"       0-9/A-Z jumps to page of program guide, 0 is first page\n"
"       t       add Program Guide event or range of events to timer list\n"
"       a       toggle display of aged-out Program Guide events\n"
"       h       toggle display of hidden/unavailable/junk events\n"
"       m       toggle display of events that match timer names\n"
"       s       toggle three sort methods: pgm(default), date, name\n"
"       n       toggle numeric debug display\n"
"       x       clear program guide and all stored EIT/ETT payloads\n"
"       z       zaps current capture, if any, and exits guide\n"
"       p       exits guide\n"
"\n"
"    Virtual Channel Control (after [v] key):\n\n"
"       c       set the virtual channel number\n"
"       a       set the audio stream number\n"
"       r       reset to full capture mode\n"
"       d       toggle VCT and PMT descriptor details\n"
"       m       toggle MPEG/ATSC Virtual Channel info\n"
; /* keyhelp from -h command line option */



/************************************************************* PACKET COUNTERS
 * ATSC packet counters in an easy to clear structure, 90 ints at least
 */
struct pkt_s {

    /* top level counters */
    int count;  /* total ATSC TS packet count */
    int errors; /* total errors detected */

    /* transport counters */
    int tserrt; /*      transport errors total */
    int tsccdt; /*      countinuity counter duplicates total */
    int tsccet; /*      continuity counter error total */
    int teiert; /*      transport error indicator bit total */
    int tscert; /*      scramble bit total */
    int tsprit; /*      priority bit total */

    /* crc counters */
    int crcats; /*  ATSC section CRC32 errors total */
    int crcstt; /*      errors in STT */
    int crcmgt; /*      errors in MGT */
    int crctvct; /*     errors in VCT */
    int crccvct; /*     errors in VCT */
    int crceit; /*      errors in EIT */
    int crcett; /*      errors in ETT section */
    int crcrrt; /*      errors in RRT */

    int crcmp2; /* MPEG CRC32 errors total */
    int crcpat; /*      errors in PAT */
    int crccat; /*      errors in CAT */
    int crcpmt; /*      errors in PMT */

    int crcpes; /*      not sure if PES has crc, don't think so. checking */

    /* sync counters */
    int synert; /* sync errors total */
    int synct;  /*      sync total */
    int alignt; /*      align count of non-zero align */
    int syncb;  /*          syncs in block */
    int synerr; /*          error in block */
    int skips;  /*          bytes skipped from sync error */
    int align;  /*          sync alignment offset, 0 is aligned */
    
    /*  packet type counters */
    int null;   /* PID 1FFF is for NULL */
    int atsc;   /* PID 1FFB is for ATSC */
    int mpeg2;  /* PID 0000-0FFF  0=PAT 1=CAT */

    /* ATSC table type counters */
    int stt;    /*  STT System Time Table, single packet */
    int mgt;    /*  MGT Master Guide Table */
    int mgtp;   /*  MGT Master Guide Table */
    int tvct;   /*  TVCT Terrestrial Virtual Channel Table */
    int tvctp;  /*  TVCT Terrestrial Virtual Channel Table */
    int cvct;   /*  CVCT Cable Virtual Channel Table */
    int cvctp;  /*  CVCT Cable Virtual Channel Table */
    int eit;    /*  EIT Event Information Table */
    int eitp;   /*  EIT Event Information Table */
    int ett;    /*  ETT Extended Text Table */
    int ettp;   /*  ETT Extended Text Table */
    int rrt;    /*  RRT Region Rating Table */
    int rrtp;   /*  RRT Region Rating Table */

/* not used */
    int dcct;   /*  DCCT Directed Channel Change Table */
    int dccsct; /*  DCCSCT Directed Channel Change Selection Code Table */

    /* MPEG2 table type and PES counters */
    int pat;    /*  PAT Program Association Table unique */
    int patt;   /*  PAT Program Association Table total tables */
    int patp;   /*  PAT Program Association Table total packets */
    int cat;    /*  CAT Conditional Access Table (not used) */
    int catp;   /*  CAT Conditional Access Table (not used) */
    int pmt;    /*  PMT TS Program Map Table unique */
    int pmtt;   /*  PMT TS Program Map Table total tables */
    int pmtp;   /*  PMT TS Program Map Table total packets */
    int pes;    /*   PES (audio+video) count for single Program cap */
    int vid;    /*     MPEG video ES total count */
    int aud;    /*     AC3 audio ES total count */
    int vcvid;  /*      single virtual channel MPEG video ES count */
    int vcaud;  /*      single virtual channel AC3 audio ES count */
    int afcpcr; /* hold down VC video until AFC PCR seen sets this */
    int other;  /* A/90 or other non audio/video packet */

    /* descriptor counts */
    int pmtrc;  /* PMT has stupidity but not EIT like specs say */
    int eitrc;  /* other place for stupidity according to spec but not seen */
    int rc;     /* rc is a stupid waste of time */

    /* packet status */
    unsigned int psi;   /* payload start indicator for current packet */
    unsigned int afc;   /* adaptation field control */
    unsigned int afl;   /* adaptation field length if afc=2 or 3 */
    unsigned int mpegtid; /* MPEG payload table id from last packet with psi=1 */
    unsigned int atsctid; /* ATSC payload table id from last packet with psi=1 */

    /* ATSC found status */
    int fstt;   /* found stt */
    int fvct;   /* found vct */
    int fmgt;   /* found mgt */
    int feit;   /* found eit */
    int fett;   /* found ett */
    int frrt;   /* not displaying? */

    /* MPEG2 found status */
    int fpat;   /* found PAT program association table */
    int fcat;
    int fpmt;   /* found PMT program map table after PAT */

    /* cap control */
    int keep;   /* write current packet if PID's match */
    int kept;   /* count writes */

    /* */
    int esec; /* current errors - previous errors */
    int perr;
    int audps; /* one shot payload start indicator */
    int vidps; /* same but not used, sequence_idx instead */
    
};
struct pkt_s pkt;

/* program guide masks and measurements */
struct pgm_s {
        int chan;                       /* guide channel */
        int refresh;                    /* meta refresh for html */
        int mtime;                      /* uts last save epg */
        short idt;                      /* index total count (display only) */
        int idx;                        /* index un/filtered from above vars */
        short ett;                      /* description count */
        char age;                       /* 'a' guide filter: age */
        char hide;                      /* 'h' guide filter: spam */
        char find;                      /* 'm' guide filter: match timer */
        char search;                    /* 'f' guide filter: search */
        char etmids;                    /* 'n' numeric ETMIDs */
        char fail;                      /* guide fail reason */
        short pn;
        short daynum;           /* day filter, only this EPG day if nz */
};

/* TODO: OPTIMIZE THIS: some fields are over-large for 128 copies */
/* NAMING FIXME: sig_s should be chan_s if you keep adding to it */
/* signal structure */
struct sig_s {
        char sid[8];            /* user supplied station id 3 chars */
        unsigned int freq;      /* table lookup. set frequency */
        int freqr;              /* driver frequency return */
        int fohz;               /* calc frequency offset in hertz */
        unsigned int mode;      /* VSB_8 or QAM_256 */

        char call[8];           /* user supplied callsign 7 chars */
        unsigned int ptc;       /* channel index in ptc_*_frequencies */
        unsigned int chan;      /* channel index in scanlist */
        short major;            /* major channel # from vct, 10 bits */

        /* pointer to ecma48 color string for signal bar */
        char *sig_col;

        /* get signal lock sets these */
        unsigned int lock;      /* nz if fe_status has FE_HAS_LOCK bit set */
        unsigned int lock_sum;  /* how many signal locks, used for avg */
        unsigned short snr;     /* SNR 8.8 value calc by driver */
        unsigned short snr_rms; /* RMS of 50 SNR samples */
        unsigned int strength;  /* SNR % of 35dB, as computed by driver */
        unsigned int str_avg;   /* Average of 50 strength % samples */
        unsigned int ber;       /* bit errors */

        int vc; /* user selected virtual channel video # for manual cap */
        int va; /* user selected virtual channel audio # for manual cap */
        int pn; /* user selected program #               for manual cap */
        int pnx; /* cable uses to translate program number in load epg */
        int pnxf; /* file# to download for EPG channel translate */
        int pgto;       /* auto guide enable/disable */
        int pgmt;       /* program guide mod time, -1 is skip */
        int pgrt;       /* program guide refresh time */

        int cap_fail;   /* last cap status for this channel */
        int cap_ets;    /* last cap elapsed time in seconds */

/* last zapped (or deleted) program guide timer start time */
/* per PTC to prevent channel change autoguide restarting of zapped */

        int lzpgt;

/* FIXME: needs pgm number too? */
        int lzpgm;

/* -1 is unknown: b0 mgt b1 vct b2 ett b3 eit b4 rrt */
        unsigned char psip;

        int mgt_hrs;            /* MGT EIT count * 3hrs */

        int smp[SIG_PNG_W];     /* strength sample history */
        int rmp[SIG_PNG_W];     /* SNR multi points */
        int smx;                /* index to current sample */
        struct pkt_s pkt;       /* packet counts for last capture */
        int ms;                 /* http stats mpeg toggle (volatile) */
        int as;                 /* http stats as toggle (volatile) */
        int pgx;                /* how many events in last loaded epg? */
/* station video h-res */
        int hres;               /* detected video horizontal res */     

        short yday;             /* day filter, only this EPG day-1 if nz */
};

/* glob sort list */
struct globsort_s {
        char *name;     /* file name pointer to globtmp allocation */
        time_t mt;      /* file modification time */    
        long long fz;   /* file size */
};


#ifdef USE_SIGNALS
volatile int sig_val = 0;
int sig_kill = 0;
char *sig_text[32] = {
        "NULL", "HUP", "INT", "QUIT", "ILL", "TRAP", "ABRT",  "BUS",
        "FPE", "KILL", "USR1", "SEGV", "USR2", "PIPE", "ALRM", "TERM",
        "STKFLT", "CHLD", "CONT", "STOP", "TSTP", "TTIN", "TTOU", "URG",
        "XCPU", "XFSZ", "VTALRM", "PROF", "WINCH", "IO", "PWR", "SYS"
    };
#endif

char *mons[13] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
                    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };

char *days[7] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
char *daysl[7] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
                    "Friday", "Saturday" };

#define J_TEXT 0
#define J_LARGE 1
#define J_SMALL 2
#define J_TINY 3
#define J_GRID 4

#define SGML_FMT 4
#define SGML_MAX 8
char *sgmls[SGML_MAX] = { "HTML", "HTML", "Big", "BIG",
                            "Small", "SMALL", "Tiny", "TINY" };

/* HTML4 + CSS stylesheet color definitions */
#define COLORZ 9
char *colors[COLORZ] = { "black", "red", "green", "blue", 
                    "cyan", "magenta", "yellow", "grey",
                    "white" };

/* HTML3 font color definitions */
char *colors3[COLORZ] = {
            "color=\042#000000\042", /* black */
            "color=\042#FF0000\042", /* red */
            "color=\042#00FF00\042", /* green */
            "color=\042#FFFF00\042", /* yellow */
            "color=\042#808080\042", /* grey */
            "color=\042#00FFFF\042", /* cyan */
            "color=\042#FF00FF\042", /* magenta */
            "color=\042#FFFFFF\042", /* white */
};

/* US broadcast */
struct scanlist_s {
    struct sig_s sig;   /* signal scan info */
};

/* option -C sets pointer to broadcast or cable lists */
int ptc_max = 70; /* default for ATSC 8VSB */
struct scanlist_s ptc[128]; /* was *ptc for below */
/* ptc gets populated by set_ptc_frequencies, based on -F option */
int *frequencies; /* current frequency list for fine-tune reset */


/* exported from dvb apps package by freqn.c. */

/* TODO: center frequency is 28.615kc above what is in ptc_broadcast */
/* TODO: test these frequencies below, also need QAM64 if anyone using it */

/* users with stations still sending above 700MHz should define USE_700M */
#define USE_700M
#ifdef USE_700M
#define ATSC_MAX 70
#else
#define ATSC_MAX 52
#endif

/* us-ATSC-center-frequencies-8VSB: 700MHz+ FCC auction limits to 2-51 */
int ptc_atsc_center[ 128 ] = {
        0,         0,  57028615,  63028615,  69028615,  79028615,  85028615, 177028615, 183028615, 189028615, 
195028615, 201028615, 207028615, 213028615, 473028615, 479028615, 485028615, 491028615, 497028615, 503028615, 
509028615, 515028615, 521028615, 527028615, 533028615, 539028615, 545028615, 551028615, 557028615, 563028615, 
569028615, 575028615, 581028615, 587028615, 593028615, 599028615, 605028615, 611028615, 617028615, 623028615, 
629028615, 635028615, 641028615, 647028615, 653028615, 659028615, 665028615, 671028615, 677028615, 683028615, 
689028615, 695028615, 

#ifdef USE_700M
/* FCC sold off this band. 52 - 69 will no longer exist for broadcast */
701028615, 707028615, 713028615, 719028615, 725028615, 731028615, 737028615, 743028615, 
749028615, 755028615, 761028615, 767028615, 773028615, 779028615, 785028615, 791028615, 797028615, 803028615,
#endif

};

/* us-Cable-EIA-542-HRC-center-frequencies-QAM256 */
int ptc_cable_eia542_hrc[ 128 ] = {
        0,         0,  73753600,  55752700,  61753000,  67753300,  77753900, 
 83754200, 175758700, 181759000, 187759300, 193759600, 199759900, 205760200, 
211760500, 121756000, 127756300, 133756600, 139756900, 145757200, 151757500, 
157757800, 163758100, 169758400, 217760800, 223761100, 229761400, 235761700, 
241762000, 247762300, 253762600, 259762900, 265763200, 271763500, 277763800, 
283764100, 289764400, 295764700, 301765000, 307765300, 313765600, 319765900, 
325766200, 331766500, 337766800, 343767100, 349767400, 355767700, 361768000, 
367768300, 373768600, 379768900, 385769200, 391769500, 397769800, 403770100, 
409770400, 415770700, 421771000, 427771300, 433771600, 439771900, 445772200, 
451772500, 457772800, 463773100, 469773400, 475773700, 481774000, 487774300, 
493774600, 499774900, 505775200, 511775500, 517775800, 523776100, 529776400, 
535776700, 541777000, 547777300, 553777600, 559777900, 565778200, 571778500, 
577778800, 583779100, 589779400, 595779700, 601780000, 607780300, 613780600, 
619780900, 625781200, 631781500, 637781800, 643782100,  91754500,  97754800, 
103755100, 109775000, 115775000, 649782400, 655782700, 661783000, 667783300, 
673783600, 679783900, 685784200, 691784500, 697784800, 703785100, 709785400, 
715785700, 721786000, 727786300, 733786600, 739786900, 745787200, 751787500, 
757787800, 763788100, 769788400, 775788700, 781789000, 787789300, 793789600, 
799789900 };

/* us-Cable-EIA-542-IRC-center_frequencies-QAM256 */
int ptc_cable_eia542_irc[ 128 ] = {
        0,         0,  75012500,  57025000,  63012500,  69012500,  79012500, 
 85012500, 177012500, 183012500, 189012500, 195012500, 201012500, 207012500, 
213012500, 123012500, 129012500, 135012500, 141012500, 147012500, 153012500, 
159012500, 165012500, 171012500, 219012500, 225012500, 231012500, 237012500, 
243012500, 249012500, 255012500, 261012500, 267012500, 273012500, 279012500, 
285012500, 291012500, 297012500, 303012500, 309012500, 315012500, 321012500, 
327012500, 333025000, 339012500, 345012500, 351012500, 357012500, 363012500, 
369012500, 375012500, 381012500, 387012500, 393012500, 399012500, 405012500, 
411012500, 417012500, 423012500, 429012500, 435012500, 441012500, 447012500, 
453012500, 459012500, 465012500, 471012500, 477012500, 483012500, 489012500, 
495012500, 501012500, 507012500, 513012500, 519012500, 525012500, 531012500, 
537012500, 543012500, 549012500, 555012500, 561012500, 567012500, 573012500, 
579012500, 585012500, 591012500, 597012500, 603012500, 609012500, 615012500, 
621012500, 627012500, 633012500, 639012500, 645012500,  93012500,  99012500, 
105012500, 111012500, 117012500, 651012500, 657012500, 663012500, 669012500, 
675012500, 681012500, 687012500, 693012500, 699012500, 705012500, 711012500, 
717012500, 723012500, 729012500, 735012500, 741012500, 747012500, 753012500, 
759012500, 765012500, 771012500, 777012500, 783012500, 789012500, 795012500, 
801012500 };

/* us-Cable-HRC-center-frequencies-QAM256 */
int ptc_cable_hrc[ 128 ] = {
        0,         0,  73753600,  55752700,  61753000,  67753300,  77753900, 
 83754200, 175758700, 181759000, 187759300, 193759600, 199759900, 205760200, 
211760500, 121756000, 127756300, 133756600, 139756900, 145757200, 151757500, 
157757800, 163758100, 169758400, 217760800, 223761100, 229761400, 235761700, 
241762000, 247762300, 253762600, 259762900, 265763200, 271763500, 277763800, 
283764100, 289764400, 295764700, 301765000, 307765300, 313765600, 319765900, 
325766200, 331766500, 337766800, 343767100, 349767400, 355767700, 361768000, 
367768300, 373768600, 379768900, 385769200, 391769500, 397769800, 403770100, 
409770400, 415770700, 421771000, 427771300, 433771600, 439771900, 445772200, 
451772500, 457772800, 463773100, 469773400, 475773700, 481774000, 487774300, 
493774600, 499774900, 505775200, 511775500, 517775800, 523776100, 529776400, 
535776700, 541777000, 547777300, 553777600, 559777900, 565778200, 571778500, 
577778800, 583779100, 589779400, 595779700, 601780000, 607780300, 613780600, 
619780900, 625781200, 631781500, 637781800, 643782100,  91754500,  97754800, 
103755100, 109755400, 115755700, 649782400, 655782700, 661783000, 667783300, 
673783600, 679783900, 685784200, 691784500, 697784800, 703785100, 709785400, 
715785700, 721786000, 727786300, 733786600, 739786900, 745787200, 751787500, 
757787800, 763788100, 769788400, 775788700, 781789000, 787789300, 793789600, 
799789900 };

/* us-Cable-IRC-center-frequencies-QAM256 */
int ptc_cable_irc[ 128 ] = {
        0,         0,  75000000,  57000000,  63000000,  69000000,  79000000, 
 85000000, 177000000, 183000000, 189000000, 195000000, 201000000, 207000000, 
213000000, 123000000, 129000000, 135000000, 141000000, 147000000, 153000000, 
159000000, 165000000, 171000000, 219000000, 225000000, 231000000, 237000000, 
243000000, 249000000, 255000000, 261000000, 267000000, 273000000, 279000000, 
285000000, 291000000, 297000000, 303000000, 309000000, 315000000, 321000000, 
327000000, 333000000, 339000000, 345000000, 351000000, 357000000, 363000000, 
369000000, 375000000, 381000000, 387000000, 393000000, 399000000, 405000000, 
411000000, 417000000, 423000000, 429000000, 435000000, 441000000, 447000000, 
453000000, 459000000, 465000000, 471000000, 477000000, 483000000, 489000000, 
495000000, 501000000, 507000000, 513000000, 519000000, 525000000, 531000000, 
537000000, 543000000, 549000000, 555000000, 561000000, 567000000, 573000000, 
579000000, 585000000, 591000000, 597000000, 603000000, 609000000, 615000000, 
621000000, 627000000, 633000000, 639000000, 645000000,  93000000,  99000000, 
105000000, 111000000, 117000000, 651000000, 657000000, 663000000, 669000000, 
675000000, 681000000, 687000000, 693000000, 699000000, 705000000, 711000000, 
717000000, 723000000, 729000000, 735000000, 741000000, 747000000, 753000000, 
759000000, 765000000, 771000000, 777000000, 783000000, 789000000, 795000000, 
801000000 };

/* us-Cable-Standard-center-frequencies-QAM256 */
int ptc_cable_std[ 128 ] = {
        0,         0,  57000000,  63000000,  69000000,  79000000,  85000000, 
177000000, 183000000, 189000000, 195000000, 201000000, 207000000, 213000000, 
123012500, 129012500, 135012500, 141000000, 147000000, 153000000, 159000000, 
165000000, 171000000, 219000000, 225000000, 231012500, 237012500, 243012500, 
249012500, 255012500, 261012500, 267012500, 273012500, 279012500, 285012500, 
291012500, 297012500, 303012500, 309012500, 315012500, 321012500, 327012500, 
333025000, 339012500, 345012500, 351012500, 357012500, 363012500, 369012500, 
375012500, 381012500, 387012500, 393012500, 399012500, 405000000, 411000000, 
417000000, 423000000, 429000000, 435000000, 441000000, 447000000, 453000000, 
459000000, 465000000, 471000000, 477000000, 483000000, 489000000, 495000000, 
501000000, 507000000, 513000000, 519000000, 525000000, 531000000, 537000000, 
543000000, 549000000, 555000000, 561000000, 567000000, 573000000, 579000000, 
585000000, 591000000, 597000000, 603000000, 609000000, 615000000, 621000000, 
627000000, 633000000, 639000000, 645000000,  93000000,  99000000, 105000000, 
111025000, 117025000, 651000000, 657000000, 663000000, 669000000, 675000000, 
681000000, 687000000, 693000000, 699000000, 705000000, 711000000, 717000000, 
723000000, 729000000, 735000000, 741000000, 747000000, 753000000, 759000000, 
765000000, 771000000, 777000000, 783000000, 789000000, 795000000, 801000000
};

char *header_version = BG NAME VERSION "-" LASTEDIT " " BN;

char *header_channels =  
    BN "k Chn    Call Net" BN " SIG%    " 
    BN "   " BB ".JUNK " BM "-ECHO " BR "+SKIP "
    BY "=POOR " BG "#FAIR " BC "$GOOD " BW "!BEST" BN CEL;

char *header_capture =
    "%sNet PTC Time %s"
    BN " SIG%%"
    BC " FIFO/max%%"
    BG " QoS/avg%%"
    BG "      Error#" 
    BW "     TS PKT#"
    BG " MPG#" SCI CEL;

char *header_timers =
    BY "T # " BG "Status Ch Name                "
    "Day Date   Time  Len " BN "SMTWTFS " BC "Nextday"
    BN CEL SCI;

/* filled in with 3 colors and "sid.chan call" by show program guide */
char *header_guide =
    BG "%sEPG# "
    BW "Pgm#" BN " "
    BG "Day Time"BN "   "
    BR "Len "
    BM "Events" BN " on "
    BY "%-15s"
    BR "[Rating] "
    BG "Description" BN SCI;

/* each line is 2% */
char sigbar[ SCALE_BAR + 1] [ SCALE_BAR + 1] = {
  "",
  ".",
  "..",
  "...",
  "....",
  "-...-",
  "--..--",
  "---.---",
  "--------",
  "+-------+",
  "++------++",
  "+++-----+++",
  "++++----++++",
  "+++++---+++++",
  "++++++--++++++",
  "+++++++-+++++++",
  "++++++++++++++++",
  "=+++++++=+++++++=",
  "==++++++==++++++==",
  "===+++++===+++++===",
  "====++++====++++====",
  "=====+++=====+++=====",
  "======++======++======",
  "=======+=======+=======",
  "========================",
  "#=======#=======#=======#",
  "##======##======##======##",
  "###=====###=====###=====###",
  "####====####====####====####",
  "#####===#####===#####===#####",
  "######==######==######==######",
  "#######=#######=#######=#######",
  "################################",
  "$#######$#######$#######$#######$",
  "$$######$$######$$######$$######$$", 
  "$$$#####$$$#####$$$#####$$$#####$$$",
  "$$$$####$$$$####$$$$####$$$$####$$$$",
  "$$$$$###$$$$$###$$$$$###$$$$$###$$$$$",
  "$$$$$$##$$$$$$##$$$$$$##$$$$$$##$$$$$$",
  "$$$$$$$#$$$$$$$#$$$$$$$#$$$$$$$#$$$$$$$",
  "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$",
  "!$$$$$$$!$$$$$$$!$$$$$$$!$$$$$$$!$$$$$$$!",
  "!!$$$$$$!!$$$$$$!!$$$$$$!!$$$$$$!!$$$$$$!!",
  "!!!$$$$$!!!$$$$$!!!$$$$$!!!$$$$$!!!$$$$$!!!",
  "!!!!$$$$!!!!$$$$!!!!$$$$!!!!$$$$!!!!$$$$!!!!",
  "!!!!!$$$!!!!!$$$!!!!!$$$!!!!!$$$!!!!!$$$!!!!!",
  "!!!!!!$$!!!!!!$$!!!!!!$$!!!!!!$$!!!!!!$$!!!!!!",
  "!!!!!!!$!!!!!!!$!!!!!!!$!!!!!!!$!!!!!!!$!!!!!!!",
  "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!",
  "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!",
  "!!!!!!!!!!!!!!!!!!!!! 100% !!!!!!!!!!!!!!!!!!!!!!!",
};

/* frame rates x100 */
int frame_rate_table[9] =
    { -1, 2397, 2400, 2500, 2997, 3000, 5000, 5994, 6000 };

struct dvb_frontend_info fe_info;               /* front end info w/ name */
struct dmx_pes_filter_params dmx_filter;        /* front end demux filter */
struct dvb_frontend_parameters fe_param;        /* front end parameters */
fe_status_t fe_status;                          /* front end status */
unsigned short fe_strength;                     /* front end strength */
unsigned int fe_ber;                            /* front end bit errors */

pthread_t fifo_input_thread;                    /* input thread ptr */
pthread_attr_t fifo_input_attr;                 /* input thread attributes */
struct sched_param fifo_input_param;            /* input sched parameters */

pthread_t fifo_output_thread;                   /* output thread ptr */
pthread_attr_t fifo_output_attr;                /* output thread attributes */
struct sched_param fifo_output_param;           /* output thread parameters */

/* fifo struct */

/* combination smp/up support via mutex locks */
struct fifo_s {
    pthread_mutex_t mutex;              /* mutex lock for SMP */
    volatile size_t filled;             /* how much FIFO currently has */
    unsigned char * volatile read_ptr;  /* fifo read/file write output ptr  */
    unsigned char * volatile write_ptr; /* device read/fifo write input ptr */

    unsigned char *buffer;      /* constant after init, not volatile */
    unsigned char *end_ptr;     /* constant after init, not volatile */
    size_t max_bytes;           /* constant after init, not volatile */
};

/* pointer to a fifo. buffer is created by fifo init malloc */
struct fifo_s ts_fifo;

/* DEFAULTS: first card and /dtv/ directory for config and output */
char cfg_name[256] = "atscap0.conf"; /* new default config name */
char cfg_path[256] = "/etc/atscap/"; /* new default config directory */
char out_name[256] = "";        /* capture will change */
char out_path[256] = "/dtv/";   /* default output path */
char cut_path[256] = "/dtv/cut/"; /* default edit output path */
char ram_path[256] = "";        /* -E sets this to "ram/" */
char log_path[256] = "/dtv/";   /* -p, -E overrides this */
char del_name[256] = "";        /* file to delete after cap */

/* capture log */
char caplog_name[256];
char dvrlog_name[256];
char syslog_name[256];

/* serialize dvrlog */
#define LOG_LINES 1024
#define LOG_CHARS 1024
FILE                    *dvrlog_fd;             /* log file ptr */
pthread_t                dvrlog_thread;         /* log thread ptr */
pthread_attr_t           dvrlog_attr;           /* log thread attributes */
struct sched_param       dvrlog_param;          /* log sched params NOT USED */
pthread_mutex_t          dvrlog_mutex;          /* log thread mutex */
char                     dvrlog_list[ LOG_LINES * LOG_CHARS ]; /* log list */
volatile int             dvrlog_idx;            /* list length */

/* serialize http index_html */
pthread_mutex_t          index_mutex;
int idx_sort = 2;       /* default is sort by date descending order */

/* serialize test epgs */
pthread_mutex_t epg_mutex;

/* serialize dump cap log */
pthread_mutex_t caplog_mutex;

/* cable uses this for guide server */
char epg_srv[ 255 ];

/* serialize build sig png */
pthread_mutex_t png_mutex;

/* serialize dump epg grid */
pthread_mutex_t          grid_mutex;


#ifdef USE_GNU_BACKTRACE
pthread_mutex_t bt_mutex;
#endif

/* dvb names, adapter0 set by arg_devnum */
char  fe_name[256] = "/dev/dvb0.frontend0"; /* default */
char dmx_name[256] = "/dev/dvb0.demux0";    /* dvb */
char dvr_name[256] = "/dev/dvb0.dvr0";      /* names */

char in_name[256]; /* same as dvr name or -r file name */

/* last 188 are used for alignment with oversized read */
unsigned char ts_buf[TSBUFZ+TSPZ];      /* device input buffer */
unsigned char out_buf[TSBUFZ+TSPZ];     /* file output buffer */
unsigned char cut_buf[TSBUFZ+TSPZ];     /* parsed output buffer */
unsigned char nul_buf[TSPZ];            /* a single null packet */
char chan_name[ 16 ];                   /* current VCT channel name */

int  fe_file = -1;      /* fd for dvb front end control */
int dmx_file = -1;      /* fd for dvb de-multiplex control */
int dvr_file = -1;      /* fd for dvb de-multiplex output */
int in_file = -1;       /* fd for dvr[0...3] */
int out_file = -1;      /* fd for output */

unsigned char blinky = 0;
volatile int block_widx = 0;    /* block write index */

char fe_text1[80]; /* device name */
char fe_text2[80]; /* device supports */
char fe_text3[80]; /* device supports */

/* channel signal scan control, another struct candidate */
/*
 load cfg sets this list and count from the C lines in conf file
 80x25: 2 line header, leaves 22 lines and a blank line for bottom
 */
int scan_list[ 128 ];   /* ATSC and cable channel range */
int scan_idx = 0;       /* shouldn't go past ptc_max */

int scan_pos = 0;               /* where in scan_list[...] are we? */

/* flow control flags for channel scan */
int scan_one    = 0;    /* make scan loop stay on this channel */
int scan_next   = 0;    /* what channel to jump to next? */
int scan_sig    = 0;    /* do signal scan or wait for timers only */
int scan_rate   = 9;    /* get signal lock changes this */
int scan_freq   = 0;    /* set channel one shot inhibit */
int scan_png    = ~0;   /* sig scan chart size, 0 is 24 nz is 48 */
#ifdef USE_DVB_EXPERIMENTAL
int scan_snr    = ~0;   /* sig display for web is SNR RMS if nz */
int scan_khz    = ~0;   /* sig display for web has +/- KHz for -x */
#else
int scan_snr    = 0;    /* sig display for web is SNR RMS if nz */
int scan_khz    = 0;    /* sig display for web has +/- KHz for -x */
#endif

/* http flags for output control */
int web_legend  = 0;    /* show legend: img + desc text */
int web_config  = ~0;   /* show config options */
int web_stats   = 0;    /* show time, uptime and transport stats */

/* TODO: need web versions of vct selection and mgt display screens */
int web_vctsel  = 0;    /* show vct selector */
int web_vctdesc = 0;    /* show vct descriptors */
int web_mgtdisp = 0;    /* show master guide table */

/* int scan_pkt = 0; */ /* 'y' key, sets quiet mode and dumps pkts */

/* capture control flags */
volatile int cap_now    = 0;    /* start cap threads now */
int cap_done    = 0;    /* signals end of ts capture */
int cap_prev    = 0;    /* ts cap mode for  dump cap stats */
int cap_prvc    = 0;    /* ts cap vc for dump cap stats */
int cap_prpn    = 0;    /* ts cap program for dump cap stats */
int cap_pchn    = 0;    /* ts cap channel number for dump epg */
volatile int cap_chan   = 0;    /* from which channel to cap */
int cap_zap     = 0;    /* set if current cap gets removed */
int cap_zapped  = 0;    /* set if previous cap was removed */
int cap_etime   = 0;    /* set if timer shows elapsed not left */
int cap_zc      = 0;    /* ATSC System Time channel */
int cap_zd      = 0;    /* ATSC System Time delta to match ntp */
int cap_zto     = 0;    /* timeout hold down one shot for STT */
int cap_frames  = 0;    /* copy arg_frames, clears if out of frame storage */
int cap_vc      = -1;   /* vc[cap_vc].espid[0-7] hunt for this VC */
int cap_va      = -1;   /* -1 use first audio, else use audio 0-7 */
int cap_pn      = -1;   /* -1 use full cap, otherwise this program number */
int cap_pidx    = 0;            /* non zero if cap_pids populated */
unsigned short cap_pids[ 8 ];   /* VC ES limit */
unsigned short cap_tsid = 0;    /* capture TSID of current PTC */

char ntp_name[128] = ""; /* NTP server name for system("ntpdate Z-line") */

/* failure modes to let you know why, sets s->cap_fail */
#define FAIL_NONE  0
#define FAIL_TSYNC 1
#define FAIL_IFIFO 2
#define FAIL_OFIFO 3
#define FAIL_ZAP   4 
#define FAIL_NOSPC 5
#define FAIL_QOS   6
#define FAIL_AOS   7
char *cap_fails[] = {
        "OK",  "SYN", "IFI", "OFO",
        "ZAP", "FUL", "QOS", "AOS"
};
        
/* this is status from load guide, sets pgm_fail */
#define PG_FAIL_NONE 0
#define PG_FAIL_NF 1
#define PG_FAIL_TO 2
#define PG_FAIL_GE 3
#define PG_FAIL_BG 4

/* FIXME: pick one: blank or empty. meaning has changed now, don't need both */
char *epg_fails[] =
 { "OK", "NO EPG", "EPG EXPIRED", "EPG EMPTY", "EPG BLANK" };

int epg_grd = ~0;       /* CSS EPG grid on by default */
int epg_sb = 0;         /* CSS EPG scrollbars off by default */
int use_css = 1;        /* 0 is HTML3.2   1,2,3 is HTML4.01 with CSS */
int epg_all  = 0;       /* nz uses old style large epg with all events */
int epg_gs = 0; /* epg grid start hour */

int cap_fail  = 0;      /* 0 if last capture was ok */

/* total error count from everything */
long long cap_errors = 0LL;

/* fifo fill and fill max */
volatile int fill_max = 0;      /* per second fifo fill */
volatile int fill_max2 = 0;     /* highest fifo fill */

long long frdbc = 0LL;  /* fifo write bc */
long long fwrbc = 0LL;  /* fifo read bc */
long long outbc = 0LL;  /* number of bytes written to .ts file */
/* nanosleeps */
/* ATSC max frame time is 16.66_ ms, io thread sleep is half that */
struct timespec atomic_sleep      =  { 0,     77555 };  /* 1/12898 sec */
struct timespec atomic10x_sleep   =  { 0,    775550 };  /* 1/1290  sec */
struct timespec atomic50x_sleep   =  { 0,   3906250 };  /* 1/256   sec */
struct timespec dummy_read_sleep  =  { 0,   7756147 };  /* 1/129   sec */
struct timespec console_read_sleep = { 0,  10000000 };  /* 1/100   sec */
struct timespec dummy_write_sleep =  { 0,  40000000 };  /* 1/25    sec */
struct timespec guide_loop_sleep  =  { 0,  62500000 };  /* 1/16    sec */
struct timespec write_thread_sleep = { 0,  83333330 };  /* 1/12    sec */
struct timespec signal_loop_sleep =  { 0, 100000000 };  /* 1/10    sec */
struct timespec signal_sleep      =  { 0, 200000000 };  /* 1/5     sec */ 
struct timespec msg_sleep         =  { 0, 250000000 };  /* 1/4     sec */
struct timespec guide_sleep       =  { 0, 500000000 };  /* 1/2     sec */
struct timespec signal_long_sleep =  { 1,         0 };  /* signal scan off */
struct timespec msg_long_sleep    =  { 2,         0 };  /* 2 seconds */
struct timespec msg_longer_sleep  =  { 4,         0 };  /* 4 seconds */
struct timespec cap_start         =  { 0,         0 };  /* capture start */
struct timespec cap_stop          =  { 0,         0 };  /* capture stop */
struct timespec cap_diff          =  { 0,         0 };
int console_init = 1;   /* init console to nonblock noecho */

/* these are the direct cursor addresses for various parts that could change */
struct {
    char tstat[16];             /* transport stat position bottom-6 */
    int tstatn;                 /* transport stat line start center */
    char astat[16];             /* atsc stat position bottom right */
    char pstat[16];             /* program stat position, bottom left */
    char sstat[16];             /* free space stat position */
    char wstat[16];             /* wall clock position */
    char cstat[16];             /* capture stat header start */
    char hstat[16];             /* line 2 headers to the left */
    char mstat[16];             /* program guide mask flags position */
    char zstat[16];             /* card type and dtv number status */
    char ustat[16];             /* user help indication */
    char vstat[16];             /* vc stats bottom-1 */
} dca;

char csp[16];           /* current scan position DCA string */

/* date handling */
char date_now[32];      /* now date string */
char date_rec[32];      /* queue date string (computed after 1st) */
char date_fut[32];      /* reque date string, computed */
char date_next[32];
char bascii[128];       /* unsigned to ascii bin output buffer */

char wecma[32];         /* weekday letters, from bascii string */
char *chid = NULL;      /* gets pointed to station id */


/* 80x25: 3 lines for legends, 1 line for channel status.
        This leaves 21 lines for timers, so that's why TIMER_LIST_MAX is 21.
    You can make TIMER_LIST_MAX higher if you have more vertical lines, but if
    you go past your consoles line count, the cursor addressing will be ugly.
*/

/* timer status flags */
#define T_FUBAR 0
#define T_STREAM 1
#define T_ACTIVE 2
#define T_IGNORE 3
#define T_TODAY 4
#define T_FUTURE 5
#define T_SEARCH 6
#define T_DONE 7
/*  queue status text */
char st_a[8][8] = {
    "fubar!", "STREAM", "ACTIVE", "IGNORE",
    "TODAY ", "FUTURE", "SEARCH", " DONE " };



/* some timer/display state flags */
volatile int timer_rec = -1;    /* q that is currently capturing */
volatile int timer_idx = 0;     /* next timer entry, shouldn't pass TIMER_LIST_MAX */

int signal_timeout = ~0; /* signal scan always times out after 300s */

int timer_tot = 0;      /* total timer count including weekday bits */
int timer_sort = ~0;    /* sort timers at init */
int timer_offset = 0;   /* display offset n into timer list ' = keys */

/* FIXME: should be time_t: time values in epoch seconds */
volatile int utsnow = 0; /* epoch seconds for time now */
int utstpg = 0; /* epoch seconds, overall hold down auto guide */
int utsmgt = 0; /* hold down mgt to 5 minutes per update */
int utsfut = 0; /* epoch seconds, signal scan timeout in future */
int utsdsh = 0; /* dump stats in html when expired */
int utsdcl = 0; /* dump cap log in text when expired */
int utsdpg = 0; /* dump program guide when expired */
int utsmid = 0; /* epoch seconds for time 0000 hours previous */
int utscap = 0; /* writes started at this epoch second index */
int utstcf = 0; /* hold down test config to once every 5s */
int utspte = 0; /* hold down for test packet stats cap stats update */
int utsvsu = 0; /* hold down for statfs */
/* time values not in epoch seconds, but derived from above */
int utsday = 0;  /* number of seconds since 0000 hours previous */
int utswday = 0; /* current weekday */
int utsets = 0;  /* capture elapsed time seconds */
/* int sttdiff = 0; / * last diff from STT to utsnow */ 
int utswuv;     /* wake up volume */
#ifdef USE_POWERDOWN
int utspdd = USE_POWERDELAY; /* time_t to power down device */
#endif
int utsgmt = 0; /* seconds east or west of greenwich, west is negative */

uid_t uid = 0;
uid_t euid = 0;
gid_t gid = 0;
gid_t egid = 0;

/* ATSC epoch time offset, including seconds west, set by calc_epoch */
int utc_offset;
int utc_check; /* 2007-Jan-1 set by calc_epoch */
/* uptime: when program started in unix epoch seconds */
int utc_up = 0;

/* temp global vars for time functions, duplicated to avoid global overwrite */
struct tm tloc; /* get_time sets to current local time */
struct tm tloc1; /* current timer queue time */
struct tm tloc2; /* current timer reschedule time */
struct tm tloc3; /* capture start time */
struct tm tloc4; /* epg grid start time */

/* more epoch second time globals, but in a different format */
time_t tnow;    /* tnow is epoch seconds for current date/time */
time_t ptnow;   /* prev tnow, hold show clock/timer/cap to 1/s */
time_t trec1;   /* current queue date/time in epoch seconds */
time_t trec2;   /* reschedule date/time in epoch seconds */

/* previous time check daylight savings time global flag */
int pisdst;     /* prev isdst value, if current differs, DST change */

/* pthread ID globals, for tracking via debug */
/* TESTME: what is the size of pid_t on 64bit x86? */
volatile pid_t pid_m = 0; /* main process id console ui */
volatile pid_t pid_i = 0; /* input process id,  nz means thread is alive */
volatile pid_t pid_o = 0; /* output process id, nz means thread is alive */
volatile pid_t pid_c = 0; /* nz means ts capture in progress */

/* statfs filesystem globals, give free/used statistics */
struct statfs vol_fsp;  /* statfs capture path for free space */
struct statfs cut_fsp;  /* statfs cut path for free space */
int cf_mt = 0;          /* config file modify time */
int cf_smt = 0;         /* config file spamlist modify time */
int cf_no = ~0;         /* no config file found flag */
int cf_once = 0;        /* oneshot to display config error once */
int timer_lock = 0;     /* lock out timer check until cfg loaded */

int arg_nulls = 0;      /* -n option gives nulls to hardware players */
int arg_strict = 0;     /* -A option ATSC strict checking */
int arg_extras = 0;     /* -x nonzero reads status during capture */
int arg_devnum = 0;     /* dtv[0...3] or dvb[0...3] */
int arg_log = 0;        /* -l full log enable, for debug */
int arg_hlog = 0;
int arg_quiet = 0;      /* -q no stdio, don't detach */
int arg_detach = 0;     /* -d no stdio, detach from ctl'n tty */
int arg_sdetach = 0;    /* -D detach with screen */
int arg_sattach = 0;    /* -R re-attach with screen */
int arg_capture = 0;    /* -s ss nn, capture chan nn for ss seconds */
int arg_edetail = ~0;   /* -e error detail dump to capture log */
int arg_notimers = 0;   /* -t don't load timers from config file */
int arg_nokb = 0;       /* -k don't scan stdin */
int arg_zapper = 0;     /* -z nn QOS zap threshold, default worst case */
int arg_fastfs = 0;     /* -f file sys is fast, no delete time */
int arg_tmpfs = 0;      /* -E energy save run EPGs from tmpfs */
int arg_dummy = 0;      /* -r replay option */
int arg_scan = 0;       /* -S setup by scanning all frequencies */
int arg_chan = 0;       /* channel for -s */
char arg_name[256];     /* argv[0] instance invokation name */
char arg_dummyn[256] = ""; /* -r option changes with parm */

char arg_whost[ WWW_HOST_MAX ] = WWW_HOST; /* www ip number */
short arg_wport = WWW_PORT;     /* http port */
#ifdef USE_WWW
int arg_www = 0;                /* -w option to start http /dtv/ server */
unsigned int arg_waddr = 0;     /* inaddr_any is default */
unsigned int arg_wmask = 0;     /* http accept mask */
int arg_wthreads = WWW_THREADS; /* default number of threads */
#endif
char arg_wroot[ WWW_ROOT_MAX ] = "/dtv";        /* www root */
int www_dvrs = WWW_DVBS;

#ifdef USE_MCAST
int arg_mcport = 0;     /* -u IP:port, port field */
char arg_mcaddr[16]; /* -m IP:port, IP field */
#endif

char *arg_device = "";  /* -i name, input device name override */
char *arg_ofile = "";   /* -o file, output override, for -s */
char *arg_opath = "";   /* -p output path added to -o file spec */
char *arg_cpath = NULL; /* -c config file path or full name */

/* normal production defaults */
/* you probably want to leave nosplash 0 otherwise you'll be wondering
   why the keys don't work for 3 seconds after everything is drawn
*/

#ifdef USER_TEST
int arg_nosplash = ~0;          /* -N no splash or device load delay */
#else
int arg_nosplash = 0;           /* -N no splash or device load delay */
#endif

int arg_screen = 0;             /* -W use screen (vty manager) */
int arg_aos = 0;                /* -a AOS check else aos always passes */
int arg_frames = ~0;            /* -m write frame and seq file for xtscut */
int arg_cable = 0;              /* -C option to use cable list */

#ifdef USE_CABLE
#warning using Cable default frtable 2
int arg_frtable = 2;            /* comcast works with table 2 */
#else
int arg_frtable = 0;            /* default is 0, ATSC broadcast */
#endif
int arg_setuid = 0;
int arg_setgid = 0;

extern char **environ;

/* This will be non-zero if there was a problem opening the input device
    The effect being no real I/O, except logging, will be done if not zero.
    The option -r allows read-only of device or file
*/

int test_mode = 0; /* not zero means demo/test/no stream mode */

int uses_screen = 0; /* non zero means screen was detected */
int in_screen = 0;

/* show cap stats */
int sec_good = 0;       /* how many seconds of good stream */
int sec_bad = 0;                /* how many seconds of bad stream */


/* list of frame types and packet counts */
struct frame_s {
    int pct;    /* frame type */
    int vpn;    /* video packet number */
};

/* TODO: needs -f frame hours option or similar envar + malloc */
/* NOTE: this is a bit large because it's really 59.94fps */
/* increased from 6: issues with FOX & MNT using insane Intra frames */
#define FRAME_HOURS 12
#define FRAME_MAX (FRAME_HOURS * SECHR * 60)

#ifdef USE_DYNAMIC
unsigned short *frames;
#else
unsigned short frames[ FRAME_MAX ];
#endif
int frame_idx = 0;
int pict[4]; /* 0 none, 1 Intra-frame, 2 Predictor-frame, 3 Bidi-frame */

/* 2 sequences per second, nominal */
#define SEQUENCE_MAX (FRAME_HOURS * 7200)
#ifdef USE_DYNAMIC
unsigned int *sequences;
#else
unsigned int sequences[ SEQUENCE_MAX ];
#endif
int sequence_idx = 0;
long long last_sbo = 0LL;       /* last sequence byte offset */
int last_vpn;                   /* last video packet number */

/* 17 bytes per tsid entry */
struct tsid_s {
    unsigned short tsid;        /* Transport Stream ID */
    unsigned short pn;          /* program number */
    char call[8];               /* call: 7 chars + NUL */
    char sid[4];                /* sid: 3 chars + NUL */ 
    unsigned char ptc;          /* physical transmission channel */
};
/* FIXME: limited to ptc[] max */
#define TSID_MAX 0x80
struct tsid_s tsids[ TSID_MAX ];
pthread_mutex_t tsid_mutex;
unsigned short tsidx = 0;
unsigned short otsidx = 0;

#ifdef USE_ASCII_XLATE
/* translate chars 128 - 255 to ascii versions */
unsigned char c8859_1[128] = {
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0x3F,
0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x43,0x45,0x45,0x45,0x45,0x49,0x49,0x49,0x49,
0xD0,0x4E,0x4F,0x4F,0x4F,0x4F,0x4F,0xD7,0x4F,0x55,0x55,0x55,0x55,0x59,0xDE,0xDF,
0x61,0x61,0x61,0x61,0x61,0x61,0x61,0x63,0x65,0x65,0x65,0x65,0x69,0x69,0x69,0x69,
0xF0,0x6E,0x6F,0x6F,0x6F,0x6F,0x6F,0xF7,0x6F,0x75,0x75,0x75,0x75,0x79,0xFE,0x41,
};

unsigned char c8859_15[128] = {
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,
};

#endif

/****************************************************************** ATSC CRC32
 from ffmpeg. the only cut and paste from ffmpeg, aside from the function
*/
const unsigned int crc_lut[256] = {
0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7,
0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3,
0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef,
0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb,
0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4,
0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08,
0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc,
0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050,
0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1,
0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5,
0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9,
0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd,
0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2,
0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e,
0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a,
0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676,
0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};

/********************************************************* ATSC HUFFMAN DECODE
 A/65b Table C5 Huffman Title Decode Tree (c) 1997 General Instruments Corp.

 Not exact table, extracted from specs by me, faster and more useful this way
  since exact table is big endian but x86 isn't.

 Byte offsets of character i tree root:
*/
unsigned int huffman1bo[128] = { 
0x0000, 0x003A, 0x003C, 0x003E, 0x0040, 0x0042, 0x0044, 0x0046, 
0x0048, 0x004A, 0x004C, 0x004E, 0x0050, 0x0052, 0x0054, 0x0056, 
0x0058, 0x005A, 0x005C, 0x005E, 0x0060, 0x0062, 0x0064, 0x0066, 
0x0068, 0x006A, 0x006C, 0x006E, 0x0070, 0x0072, 0x0074, 0x0076, 
0x0078, 0x00CE, 0x00D2, 0x00D4, 0x00D6, 0x00D8, 0x00DA, 0x00DC, 
0x00E6, 0x00E8, 0x00EA, 0x00F0, 0x00F2, 0x00F4, 0x0106, 0x0112, 
0x0114, 0x011C, 0x0128, 0x0130, 0x0134, 0x0136, 0x0138, 0x013A, 
0x013C, 0x013E, 0x0146, 0x0148, 0x014A, 0x014C, 0x014E, 0x0150, 
0x0152, 0x0154, 0x017E, 0x0192, 0x01AC, 0x01BA, 0x01D2, 0x01E4, 
0x01FA, 0x0206, 0x021E, 0x0226, 0x0232, 0x023E, 0x0252, 0x0264, 
0x027A, 0x0294, 0x0298, 0x02A4, 0x02C8, 0x02DE, 0x02E6, 0x02F4, 
0x0304, 0x0306, 0x030C, 0x0310, 0x0312, 0x0314, 0x0316, 0x0318, 
0x031A, 0x031C, 0x0352, 0x036A, 0x038E, 0x03AE, 0x03EE, 0x0406, 
0x0428, 0x0444, 0x0472, 0x0476, 0x0490, 0x04BE, 0x04D6, 0x050A, 
0x0544, 0x0564, 0x0566, 0x059A, 0x05D0, 0x05FC, 0x0622, 0x062C, 
0x0646, 0x0654, 0x067C, 0x068A, 0x068C, 0x068E, 0x0690, 0x0692
};

/* These were also extracted from specs by me, but no changes made.
 Character i order-1 trees. These are byte sized for next branch or leaf.
 NOTE: Byte look-up should not have endian issues.
*/

#define TITLE_COZ 1683
unsigned char huffman1co[1684] = { 
0x1B,0x1C,0xB4,0xA4,0xB2,0xB7,0xDA,0x01,0xD1,0x02,0x03,0x9B,0x04,0xD5,0xD9,0x05,
0xCB,0xD6,0x06,0xCF,0x07,0x08,0xCA,0x09,0xC9,0xC5,0xC6,0x0A,0xD2,0xC4,0xC7,0xCC,
0xD0,0xC8,0xD7,0xCE,0x0B,0xC1,0x0C,0xC2,0xCD,0xC3,0x0D,0x0E,0x0F,0x10,0xD3,0x11,
0xD4,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x29,0x2A,0xD8,0xE5,0xB9,0x01,0xA7,0xB1,
0xEC,0xD1,0x02,0xAD,0xB2,0xDA,0xE3,0xB3,0x03,0xE4,0xE6,0x04,0x9B,0xE2,0x05,0x06,
0x07,0x08,0x09,0xD5,0x0A,0xD6,0x0B,0xD9,0x0C,0xA6,0xE9,0xCB,0xC5,0xCF,0x0D,0x0E,
0xCA,0xC9,0x0F,0xC7,0x10,0x11,0xE1,0x12,0x13,0xC6,0xD2,0xC8,0xCE,0xC1,0xC4,0xD0,
0xCC,0x14,0x15,0xEF,0xC2,0xD7,0x16,0xCD,0x17,0xF4,0xD4,0x18,0x19,0x1A,0xC3,0xD3,
0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x01,0x80,
0xA0,0x9B,0x9B,0x9B,0x9B,0x9B,0xB1,0x9B,0x9B,0x9B,0x9B,0xA0,0x04,0xF3,0xE4,0xB9,
0x01,0xF4,0xA0,0x9B,0x02,0x03,0x9B,0x9B,0x9B,0x9B,0x01,0x02,0x9B,0xC1,0xC8,0xD3,
0x9B,0x9B,0x9B,0xA0,0x07,0x08,0xB1,0xD2,0xD3,0xD4,0xD5,0xAD,0xCD,0xC1,0x01,0x02,
0x03,0xA0,0x04,0x9B,0x05,0x06,0xA0,0x05,0xC9,0xD7,0xD3,0x01,0x02,0x9B,0xAE,0x80,
0x03,0x04,0x9B,0x9B,0x02,0x03,0xAD,0x9B,0x01,0x80,0xA0,0xB0,0x04,0x05,0x80,0x9B,
0xB1,0xB2,0xA0,0xB0,0xB9,0x01,0x02,0x03,0x02,0x03,0xB1,0xBA,0x01,0xB0,0x9B,0x80,
0x80,0x01,0xB0,0x9B,0x9B,0xB8,0x9B,0x9B,0x9B,0x9B,0x9B,0xB0,0x9B,0xA0,0x02,0x03,
0xB1,0xB3,0xB9,0xB0,0x01,0x9B,0x9B,0xA0,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x9B,0x80,0x9B,0x9B,0x13,0x14,0xAA,0xAD,0xAE,0xF6,0xE7,0xF4,0xE2,0xE9,0x01,0x02,
0xC2,0xF0,0x9B,0xF3,0xE3,0xE6,0xF7,0x03,0xF5,0x04,0x05,0x06,0xF2,0x07,0x08,0x09,
0x0A,0x0B,0x0C,0xE4,0xA0,0x0D,0xEC,0xEE,0x0E,0xED,0x0F,0x10,0x11,0x12,0x08,0x09,
0xC1,0xD3,0x9B,0x01,0xC3,0x02,0xE9,0xEC,0x03,0xF2,0xF5,0x04,0xEF,0xE1,0x05,0xE5,
0x06,0x07,0x0B,0x0C,0xC1,0xF9,0x01,0xC2,0xCF,0xE5,0xF5,0x9B,0xE9,0x02,0xA0,0x03,
0x04,0x05,0xF2,0x06,0xEC,0x07,0xE1,0x08,0x09,0xE8,0x0A,0xEF,0x05,0x06,0xF9,0x9B,
0x01,0xF5,0x02,0xF2,0xE9,0xE5,0xEF,0x03,0xE1,0x04,0x0A,0x0B,0xF1,0xF5,0xF3,0x01,
0xED,0xF9,0xC3,0x02,0xEC,0xEE,0xE4,0xF8,0x03,0x9B,0xF6,0x04,0x05,0xE1,0x06,0x07,
0x08,0x09,0x07,0x08,0xA0,0x9B,0xCC,0x01,0xE5,0x02,0xEC,0xF5,0xEF,0x03,0xE9,0xF2,
0x04,0x05,0xE1,0x06,0x09,0x0A,0xAE,0xEC,0xF9,0xC1,0xE8,0x01,0x9B,0x02,0x03,0x04,
0xE1,0xF5,0xE9,0x05,0xE5,0x06,0xF2,0xEF,0x07,0x08,0xEF,0x05,0x80,0x9B,0xF5,0x01,
0x02,0xE9,0xE1,0x03,0xE5,0x04,0xEE,0x0B,0xBA,0xD4,0xAE,0xF2,0xE3,0x01,0xA0,0x02,
0x80,0x9B,0xED,0x03,0xC9,0xF3,0xF4,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x02,0x03,
0x9B,0xF5,0x01,0xE1,0xEF,0xE5,0x05,0xE9,0xE1,0xEF,0xF5,0xEE,0x9B,0xE5,0x01,0x02,
0x03,0x04,0x04,0x05,0xA0,0x9B,0x01,0xF5,0x02,0xE5,0xEF,0x03,0xE1,0xE9,0x08,0x09,
0xAA,0xD4,0x01,0x9B,0xE3,0x02,0xF2,0x03,0xE5,0x04,0xF5,0xF9,0xE9,0x05,0xEF,0x06,
0x07,0xE1,0xE5,0x08,0xCE,0xA0,0xC6,0xF5,0x01,0x02,0x9B,0xC2,0x03,0xE1,0x04,0xEF,
0x05,0xE9,0x06,0x07,0x09,0x0A,0xE4,0xF3,0xE6,0xF6,0xF7,0xF0,0xF2,0x01,0xEC,0x02,
0x03,0xA0,0x9B,0x04,0x05,0xF5,0x06,0x07,0xEE,0x08,0x0B,0x0C,0xA0,0xF3,0xF9,0xAE,
0xD2,0xC7,0x01,0x9B,0x02,0xF5,0x03,0x04,0x05,0xE9,0xEC,0x06,0xE5,0x07,0xEF,0x08,
0xE1,0x09,0xF2,0x0A,0x01,0xF5,0x9B,0xD6,0x04,0x05,0xE8,0x9B,0x01,0xF5,0x02,0xE1,
0xE9,0xEF,0x03,0xE5,0x10,0x11,0xAA,0xEC,0xF1,0xAE,0xA0,0xF7,0xED,0xEE,0x01,0x02,
0x9B,0xEB,0x03,0x04,0x05,0x06,0xE3,0x07,0xEF,0x08,0xE9,0xF5,0x09,0xE1,0xE5,0xF0,
0xE8,0x0A,0x0B,0x0C,0x0D,0xF4,0x0E,0x0F,0xE8,0x0A,0xAD,0xCE,0x9B,0x01,0xD6,0x02,
0xF5,0xF7,0x03,0x04,0xE1,0xE5,0xE9,0x05,0xF2,0x06,0xEF,0x07,0x08,0x09,0xEE,0x03,
0xEC,0xAE,0x01,0x9B,0x02,0xF0,0x06,0xE9,0xA0,0xC3,0xEF,0x9B,0xE5,0x01,0x80,0x02,
0x03,0xE1,0x04,0x05,0x06,0x07,0xC6,0xD7,0x01,0x9B,0xF2,0x02,0x03,0xE8,0xE5,0xE1,
0x04,0xE9,0xEF,0x05,0x9B,0x9B,0x02,0xEF,0xE1,0x9B,0x01,0xE5,0x01,0xEF,0x9B,0xE1,
0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x19,0x1A,0x9B,0xBA,
0xE5,0xEA,0xF8,0x01,0x02,0xE6,0xA7,0x03,0xFA,0xE8,0x04,0xF7,0x05,0xF5,0xE2,0x06,
0xEB,0x07,0xF0,0x08,0x80,0xF6,0xE7,0x09,0xE4,0x0A,0xA0,0xE9,0x0B,0xE3,0xF9,0x0C,
0x0D,0xED,0x0E,0x0F,0xF3,0x10,0x11,0xEC,0x12,0xF4,0xF2,0x13,0xEE,0x14,0x15,0x16,
0x17,0x18,0x0A,0x0B,0xF3,0x9B,0xF5,0xE2,0x01,0x80,0xA0,0x02,0xE5,0xF2,0xE9,0x03,
0xEC,0x04,0xF9,0x05,0xEF,0x06,0xE1,0x07,0x08,0x09,0x10,0x11,0xC3,0xCC,0xC7,0x9B,
0xE3,0x01,0x80,0xEC,0xF9,0x02,0xF3,0x03,0xF5,0x04,0x05,0xF2,0x06,0xE9,0xA0,0x07,
0x08,0xEF,0xF4,0x09,0x0A,0xE1,0x0B,0xE8,0xEB,0xE5,0x0C,0x0D,0x0E,0x0F,0x0E,0x0F,
0xAE,0xF5,0xF7,0x01,0xEC,0x02,0xE4,0xE7,0xF2,0x03,0x9B,0xEF,0x04,0xF6,0x05,0x06,
0xF9,0xF3,0x07,0xE9,0xE1,0x08,0x09,0x80,0x0A,0x0B,0xE5,0x0C,0x0D,0xA0,0x1E,0x1F,
0x9B,0xA1,0xAD,0xE8,0xEA,0xF1,0xF5,0xFA,0x01,0x02,0x03,0x04,0xBA,0xF8,0xA7,0xE2,
0xE9,0x05,0x06,0x07,0xE6,0xED,0xE7,0xEB,0x08,0x09,0xF6,0xF0,0x0A,0xEF,0x0B,0xE3,
0x0C,0x0D,0x0E,0xF9,0x0F,0xE4,0xEC,0x10,0xE5,0x11,0xF4,0xF7,0x12,0x13,0xE1,0x14,
0x15,0x16,0xEE,0xF3,0x17,0x80,0x18,0x19,0xF2,0x1A,0x1B,0xA0,0x1C,0x1D,0xA0,0x0B,
0xF5,0x9B,0x01,0xEC,0xF3,0xF2,0x80,0xE1,0x02,0x03,0xF4,0xE9,0xEF,0xE6,0x04,0x05,
0x06,0x07,0xE5,0x08,0x09,0x0A,0x0F,0x10,0xBA,0xF9,0xA7,0xF4,0x9B,0x01,0xE7,0xEC,
0x02,0xEE,0x03,0xEF,0xF5,0x04,0xF2,0x05,0x06,0xE9,0x07,0xF3,0xE1,0x08,0x09,0x0A,
0x0B,0xE5,0x80,0x0C,0xE8,0xA0,0x0D,0x0E,0xE5,0x0D,0xE2,0xF5,0xF7,0x9B,0xEC,0x01,
0xF9,0xEE,0x02,0x03,0x04,0xF2,0x05,0x80,0x06,0xA0,0xE1,0xEF,0x07,0xF4,0xE9,0x08,
0x09,0x0A,0x0B,0x0C,0x15,0x16,0xA1,0xF8,0xE9,0xEB,0x01,0x80,0x9B,0xFA,0xE2,0x02,
0x03,0x04,0xA0,0xF0,0x05,0x06,0x07,0xE1,0x08,0xE6,0xF2,0xED,0xF6,0x09,0xE4,0x0A,
0xEF,0xF4,0xEC,0xF3,0xE7,0xE5,0x0B,0xE3,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,
0xEE,0x14,0xEF,0x01,0x9B,0xE1,0x0B,0x0C,0xD4,0xEF,0xE6,0xEC,0xF7,0xE1,0x01,0xBA,
0x02,0x9B,0xF9,0x03,0x04,0x05,0xF3,0x06,0x07,0x08,0xE9,0xA0,0x09,0x80,0xE5,0x0A,
0x15,0x16,0xA7,0xBA,0xE3,0xF7,0xF2,0xAD,0xE2,0x01,0x02,0x9B,0xE6,0x03,0xED,0xF6,
0x04,0xEB,0x05,0xF4,0x06,0x07,0x08,0xF3,0x09,0xF5,0x0A,0xEF,0x0B,0x0C,0x80,0xF9,
0xE1,0x0D,0xE4,0xE9,0xA0,0x0E,0x0F,0xEC,0xE5,0x10,0x11,0x12,0x13,0x14,0x0A,0x0B,
0xF9,0x9B,0xF5,0xF3,0x01,0x02,0xE2,0xED,0x80,0x03,0xF0,0xEF,0x04,0xA0,0x05,0xE9,
0x06,0xE1,0x07,0x08,0x09,0xE5,0x18,0x19,0xE2,0xEA,0xF2,0xE8,0xEC,0xED,0xFA,0x9B,
0x01,0xF5,0x02,0x03,0xF6,0x04,0xBA,0xE6,0x05,0x06,0xEB,0xEF,0x07,0xA7,0xF9,0x08,
0x09,0x0A,0x0B,0xE3,0x0C,0xEE,0xE1,0x0D,0xF3,0x0E,0xE9,0x0F,0x10,0xF4,0x80,0xE4,
0xE5,0x11,0x12,0xE7,0xA0,0x13,0x14,0x15,0x16,0x17,0x1B,0x1C,0xAE,0xFA,0xBF,0x01,
0xA7,0x9B,0x02,0xE9,0xF8,0xF9,0x03,0xE5,0xE8,0x04,0xE1,0xEB,0x05,0xE2,0x06,0x07,
0xE3,0x08,0xE7,0xF4,0x09,0x80,0xF6,0xF0,0x0A,0xE4,0x0B,0xF3,0xF7,0x0C,0x0D,0xEF,
0xEC,0xA0,0x0E,0x0F,0xED,0xE6,0x10,0xF5,0x11,0x12,0x13,0x14,0x15,0xF2,0x16,0xEE,
0x17,0x18,0x19,0x1A,0x0E,0x0F,0xED,0xA7,0x9B,0xE4,0x01,0xF9,0xF3,0xF2,0xF4,0x02,
0xE8,0x03,0xEC,0xF0,0x04,0xE1,0xE9,0x05,0x06,0x80,0xA0,0x07,0x08,0x09,0x0A,0xE5,
0xEF,0x0B,0x0C,0x0D,0x9B,0xF5,0x18,0x19,0xBA,0xAC,0xF6,0x9B,0xF0,0xE2,0x01,0xE6,
0x02,0xA7,0xAE,0xE7,0x03,0xE3,0xF5,0x04,0xED,0x05,0x06,0x07,0xEB,0x08,0x09,0xEE,
0xF2,0x0A,0xE4,0x0B,0xF9,0xEC,0x0C,0x0D,0xF4,0x80,0x0E,0xEF,0xF3,0xA0,0xE1,0x0F,
0xE9,0x10,0x11,0xE5,0x12,0x13,0x14,0x15,0x16,0x17,0x19,0x1A,0xA7,0xAC,0xBF,0xC3,
0xC8,0xE4,0xE6,0xED,0xF2,0xAE,0xEC,0xEE,0xF9,0x01,0x02,0x03,0x04,0xBA,0x05,0x9B,
0xF5,0x06,0x07,0x08,0x09,0xEB,0xF0,0x0A,0x0B,0x0C,0xE1,0xE3,0x0D,0xE8,0x0E,0x0F,
0xEF,0x10,0x11,0xF3,0x12,0xE9,0x13,0xE5,0x14,0x15,0xF4,0x16,0x17,0xA0,0x18,0x80,
0x14,0x15,0xBA,0xBF,0xE4,0xF7,0x9B,0xA7,0x01,0xEE,0x02,0x03,0x04,0xE3,0xE2,0xED,
0x05,0xF9,0x06,0xF4,0x07,0xEC,0x08,0xF5,0xF2,0x09,0xE1,0xF3,0x0A,0xEF,0x0B,0x0C,
0x0D,0xE9,0x80,0xE5,0x0E,0xA0,0x0F,0xE8,0x10,0x11,0x12,0x13,0x11,0x12,0xEB,0xFA,
0x80,0xE6,0x9B,0x01,0xA0,0x02,0x03,0xE9,0xE1,0x04,0xE4,0xF0,0xED,0xE2,0xE3,0xE7,
0xEC,0x05,0xE5,0x06,0x07,0x08,0x09,0xF4,0x0A,0x0B,0x0C,0xF3,0xEE,0x0D,0x0E,0xF2,
0x0F,0x10,0x04,0xE5,0xF3,0xEF,0x9B,0x01,0xE1,0x02,0x03,0xE9,0x0B,0x0C,0xA7,0xE2,
0xEC,0xE3,0xF2,0x01,0x9B,0x02,0x03,0x04,0xE9,0xEF,0xEE,0xE5,0xE1,0x80,0x05,0xA0,
0x06,0x07,0x08,0x09,0xF3,0x0A,0x05,0x06,0x9B,0xA0,0xE1,0xE5,0xE9,0x01,0x80,0xF0,
0x02,0xF4,0x03,0x04,0xA0,0x13,0xE3,0xAD,0xE4,0xE9,0xEE,0xEF,0xF0,0xF4,0xF6,0xA1,
0xE1,0xED,0x01,0xE2,0x02,0x03,0x04,0xA7,0x05,0x06,0xF7,0x07,0x9B,0xEC,0x08,0xE5,
0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0xF3,0x0F,0x10,0x11,0x80,0x12,0x05,0x06,0xE5,0xFA,
0xA0,0xF9,0x9B,0x01,0x80,0xE9,0x02,0xE1,0x03,0x04,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x9B,0x9B
};

/*
 A/65b Table C7 Huffman Description Decode Tree (c) General Instruments Corp.

 Not exact table, extracted from specs by me, faster more useful version
  since exact table is big endian but x86 isn't.

 Byte offsets of character i tree root:
*/
unsigned int huffman2bo[128] = { 
0x0000, 0x002C, 0x002E, 0x0030, 0x0032, 0x0034, 0x0036, 0x0038, 
0x003A, 0x003C, 0x003E, 0x0040, 0x0042, 0x0044, 0x0046, 0x0048, 
0x004A, 0x004C, 0x004E, 0x0050, 0x0052, 0x0054, 0x0056, 0x0058, 
0x005A, 0x005C, 0x005E, 0x0060, 0x0062, 0x0064, 0x0066, 0x0068, 
0x006A, 0x00DE, 0x00E0, 0x00EA, 0x00EC, 0x00EE, 0x00F0, 0x00F2, 
0x00F8, 0x00FA, 0x00FC, 0x00FE, 0x0100, 0x0104, 0x0116, 0x0120, 
0x0122, 0x012C, 0x0132, 0x0138, 0x013C, 0x0140, 0x0144, 0x0146, 
0x014A, 0x014C, 0x0154, 0x0156, 0x0158, 0x015A, 0x015C, 0x015E, 
0x0160, 0x0162, 0x0176, 0x0184, 0x0194, 0x01A2, 0x01B2, 0x01BA, 
0x01C8, 0x01D2, 0x01DE, 0x01EA, 0x01F2, 0x01FC, 0x0208, 0x0210, 
0x021A, 0x0228, 0x022A, 0x0234, 0x024A, 0x025A, 0x025E, 0x0264, 
0x026E, 0x0270, 0x0272, 0x0274, 0x0276, 0x0278, 0x027A, 0x027C, 
0x027E, 0x0280, 0x02B4, 0x02CE, 0x02F0, 0x031A, 0x0358, 0x036E, 
0x038E, 0x03AC, 0x03D8, 0x03E0, 0x03F4, 0x0424, 0x0440, 0x0476, 
0x04AE, 0x04CE, 0x04D0, 0x0506, 0x0534, 0x0560, 0x0586, 0x0592, 
0x05AA, 0x05B8, 0x05DC, 0x05EC, 0x05EE, 0x05F0, 0x05F2, 0x05F4, 
};

#define DESCR_COZ 1525
/* These were also extracted from specs by me, but no changes made.
 Character i order-1 trees. These are byte sized for next branch or leaf.
 NOTE: Byte look-up should not have endian issues.
*/
unsigned char huffman2co[1526] = { 
0x14,0x15,0x9B,0xD6,0xC9,0xCF,0xD7,0xC7,0x01,0xA2,0xCE,0xCB,0x02,0x03,0xC5,0xCC,
0xC6,0xC8,0x04,0xC4,0x05,0xC2,0x06,0xC3,0xD2,0x07,0xD3,0x08,0xCA,0xD4,0x09,0xCD,
0xD0,0x0A,0xC1,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x38,0x39,0xAD,0xAF,0xB7,0xDA,
0xA8,0xB3,0xB5,0x01,0x02,0x9B,0xB4,0xF1,0xA2,0xD5,0xD6,0xD9,0x03,0x04,0x05,0xCF,
0x06,0xC9,0xF9,0xEA,0xEB,0xF5,0xF6,0x07,0x08,0x09,0xB2,0xC5,0xC6,0xB1,0x0A,0xEE,
0xCB,0x0B,0xD4,0x0C,0xC4,0xC8,0xD2,0x0D,0x0E,0x0F,0xC7,0xCA,0xCE,0xD0,0xD7,0x10,
0xC2,0x11,0xCC,0xEC,0xE5,0xE7,0x12,0xCD,0x13,0x14,0xC3,0x15,0x16,0x17,0xED,0x18,
0x19,0xF2,0x1A,0xD3,0x1B,0x1C,0xE4,0x1D,0xC1,0xE3,0x1E,0xE9,0xF0,0xE2,0xF7,0x1F,
0xF3,0xE6,0x20,0x21,0x22,0xE8,0xEF,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0xF4,
0x2B,0x2C,0x2D,0x2E,0x2F,0xE1,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x9B,0x9B,
0x03,0x04,0x80,0xAE,0xC8,0xD4,0x01,0x02,0x9B,0xA0,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x02,0xF3,0xA0,0xF4,0x9B,0x01,0x9B,0x9B,0xAC,0x9B,0x9B,0x9B,0x9B,0x9B,
0x01,0xA0,0x9B,0xA2,0x07,0x08,0xE2,0xE4,0xE5,0xE6,0xA0,0xF2,0xE1,0x01,0x02,0xF3,
0xE3,0x03,0x04,0x05,0x9B,0x06,0x04,0x80,0xCA,0xD3,0xA2,0x01,0x9B,0x02,0x03,0xA0,
0x9B,0xA0,0x03,0x04,0x9B,0xB7,0xF4,0xA0,0xB0,0xF3,0x01,0x02,0xB9,0x02,0xB8,0x9B,
0xA0,0x01,0xAE,0x02,0xB6,0x9B,0x01,0xA0,0xA0,0x01,0x9B,0xB0,0xAE,0x01,0x9B,0xA0,
0xAE,0x01,0xA0,0x9B,0x9B,0x9B,0x9B,0x01,0xAC,0xAE,0x9B,0x9B,0x02,0x03,0x9B,0xA0,
0xB5,0xB6,0xB8,0x01,0x9B,0xA0,0x9B,0xA0,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0xA0,
0x9B,0x9B,0x08,0x09,0xE6,0xF5,0xF3,0xF4,0x9B,0xE4,0x01,0xED,0x02,0x03,0x04,0xF2,
0x05,0x06,0xEC,0xEE,0x07,0xA0,0x05,0x06,0x9B,0xEC,0xF5,0x01,0x02,0xE1,0xEF,0xE5,
0xE9,0xF2,0x03,0x04,0x06,0x07,0x9B,0xE9,0xF9,0xF2,0xF5,0x01,0x02,0x03,0xEC,0xEF,
0xE1,0x04,0xE8,0x05,0x05,0x06,0xF9,0xF2,0xF5,0x9B,0xE5,0xEF,0x01,0x02,0xE9,0xE1,
0x03,0x04,0x06,0x07,0xE1,0xE9,0xEE,0xF6,0xE4,0xEC,0xF3,0x01,0x02,0xF2,0x03,0x04,
0x9B,0x05,0x02,0x03,0xE5,0xEC,0x9B,0xEF,0x01,0xF2,0x05,0x06,0xF5,0xEF,0x9B,0xEC,
0xE9,0x01,0xE1,0xF2,0x02,0xE5,0x03,0x04,0x03,0x04,0x9B,0xE5,0xE9,0xF5,0xE1,0x01,
0xEF,0x02,0x04,0x05,0xA0,0xC9,0xF3,0x9B,0xAE,0xF2,0x01,0x02,0x03,0xEE,0xEF,0x05,
0x9B,0xAE,0xE9,0xE5,0x01,0xF5,0x02,0xE1,0x03,0x04,0xE5,0x03,0xE1,0xE9,0xF2,0x9B,
0x01,0x02,0x03,0x04,0x9B,0xE9,0xF5,0x01,0xE5,0x02,0xEF,0xE1,0xE1,0x05,0x9B,0xE3,
0xEF,0x01,0xF5,0xE5,0x02,0x03,0xE9,0x04,0xE5,0x03,0x9B,0xE9,0x01,0xE1,0xEF,0x02,
0x03,0x04,0xA7,0xEE,0xEC,0xF2,0xF3,0x01,0x9B,0x02,0xE1,0x06,0x9B,0xE8,0xE9,0x01,
0xF2,0xEC,0x02,0xEF,0x03,0xE5,0x04,0x05,0x9B,0x9B,0x03,0x04,0x9B,0xAE,0x01,0xE9,
0x02,0xE1,0xE5,0xEF,0x09,0x0A,0xF6,0xF9,0x01,0xAE,0xE3,0xE9,0xF5,0x9B,0xE5,0xEF,
0x02,0x03,0xE1,0x04,0xE8,0x05,0x06,0xF4,0x07,0x08,0xE8,0x07,0xE5,0xF7,0xD6,0xE1,
0x9B,0xE9,0xF2,0x01,0x02,0x03,0x04,0xEF,0x05,0x06,0xAE,0x01,0x9B,0xEE,0xE9,0x02,
0xE5,0x9B,0xA0,0x01,0x03,0x04,0x9B,0xE8,0xE5,0xE1,0xEF,0x01,0xE9,0x02,0x9B,0x9B,
0x9B,0xEF,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
0x18,0x19,0xE8,0xEF,0xF8,0x9B,0xA7,0xF7,0xFA,0x01,0x02,0x03,0x04,0xE5,0xAE,0x05,
0xE6,0xE2,0x06,0xF6,0xEB,0xF5,0xE9,0x07,0xF0,0xF9,0xE7,0x08,0x09,0xE4,0x0A,0xE3,
0x0B,0xED,0x0C,0xF3,0x0D,0x0E,0x0F,0xEC,0x10,0xF4,0x11,0x12,0xF2,0xA0,0x13,0x14,
0x15,0xEE,0x16,0x17,0x0B,0x0C,0xE4,0xF3,0x9B,0xAE,0xE2,0x01,0x02,0x03,0xEC,0xA0,
0x04,0xE9,0xF2,0xF5,0x05,0xF9,0xE1,0x06,0xEF,0x07,0xE5,0x08,0x09,0x0A,0x0F,0x10,
0xF1,0xAE,0xC4,0xF9,0xAC,0x01,0xE3,0x02,0x9B,0xF2,0x03,0x04,0xA0,0xEC,0xF5,0x05,
0x06,0xE9,0x07,0xEB,0x08,0xF4,0x09,0xE5,0x0A,0xEF,0xE1,0xE8,0x0B,0x0C,0x0D,0x0E,
0x13,0x14,0xA7,0xBB,0xE6,0xED,0xF7,0xE7,0xF6,0x01,0x02,0x9B,0xEE,0x03,0x04,0xEC,
0x05,0xF5,0x06,0xAC,0xE4,0xF9,0xF2,0x07,0x08,0x09,0xAE,0x0A,0xEF,0x0B,0xE1,0xF3,
0x0C,0xE9,0x0D,0x0E,0x0F,0x10,0xE5,0x11,0x12,0xA0,0x1D,0x1E,0xA9,0xE8,0xF5,0x9B,
0x01,0xAD,0xBB,0xEB,0xFA,0x02,0xA7,0xE6,0xE2,0xE7,0x03,0x04,0x05,0x06,0xE9,0xF8,
0x07,0xAC,0xEF,0xF0,0x08,0xED,0xF6,0xF9,0x09,0xF7,0x0A,0x0B,0xAE,0x0C,0xE3,0x0D,
0xE5,0xF4,0x0E,0x0F,0xE4,0x10,0xEC,0x11,0xE1,0x12,0x13,0x14,0x15,0x16,0xEE,0xF3,
0x17,0x18,0xF2,0xA0,0x19,0x1A,0x1B,0x1C,0x09,0x0A,0xAE,0x9B,0xEC,0x01,0xF5,0x02,
0xF4,0xE6,0x03,0xE1,0xE5,0xE9,0x04,0xF2,0xEF,0x05,0x06,0x07,0xA0,0x08,0x0E,0x0F,
0xAD,0xE7,0x9B,0xA7,0xF9,0x01,0xEC,0x02,0xAC,0xF2,0x03,0xAE,0xF3,0xF5,0x04,0x05,
0xEF,0x06,0x07,0xE9,0xE1,0x08,0x09,0xE8,0x0A,0x0B,0xE5,0x0C,0xA0,0x0D,0x0D,0x0E,
0xA7,0xAC,0xF3,0xAD,0x01,0x02,0x9B,0xF9,0xF5,0xAE,0x03,0xEE,0x04,0xF2,0x05,0x06,
0xF4,0x07,0x08,0x09,0xEF,0xE1,0xA0,0x0A,0xE9,0x0B,0x0C,0xE5,0x14,0x15,0xAC,0xE2,
0xF8,0x9B,0xAE,0xFA,0x01,0xEB,0x02,0xA0,0x03,0x04,0xF0,0x05,0x06,0xE6,0xF6,0x07,
0xE4,0xED,0xE7,0x08,0xE1,0xEF,0xF2,0x09,0x0A,0x0B,0xEC,0x0C,0xE5,0xE3,0x0D,0xF4,
0x0E,0xF3,0x0F,0x10,0x11,0xEE,0x12,0x13,0x03,0xEF,0x9B,0xE1,0xE5,0xF5,0x01,0x02,
0x08,0x09,0xEC,0xF9,0xA7,0xEE,0x01,0xAC,0x9B,0xAE,0x02,0x03,0x04,0xF3,0x05,0xE9,
0x06,0xA0,0x07,0xE5,0x16,0x17,0xA7,0xAD,0xEE,0xE3,0xEB,0xF2,0x9B,0xE2,0x01,0x02,
0xF5,0x03,0xF4,0xAC,0x04,0x05,0xE6,0xED,0xF6,0x06,0xAE,0xF0,0x07,0x08,0xF3,0x09,
0x0A,0xE4,0x0B,0x0C,0xF9,0x0D,0xEF,0x0E,0xE1,0x0F,0x10,0xE9,0xEC,0x11,0xA0,0xE5,
0x12,0x13,0x14,0x15,0x0C,0x0D,0xA7,0xBB,0x9B,0x01,0xF9,0xAE,0xE2,0x02,0xED,0xF3,
0x03,0xF5,0xEF,0xF0,0x04,0x05,0xE9,0x06,0x07,0x08,0x09,0xA0,0xE1,0xE5,0x0A,0x0B,
0x19,0x1A,0xAD,0xBB,0xE2,0xEA,0xED,0xF2,0xFA,0xE6,0xEC,0x01,0x02,0x03,0x9B,0xF5,
0x04,0xA7,0xF6,0xF9,0x05,0x06,0xEB,0xEF,0x07,0x08,0x09,0x0A,0xAC,0x0B,0x0C,0xE3,
0xAE,0x0D,0xEE,0xE9,0x0E,0xE1,0x0F,0xF3,0x10,0x11,0xF4,0x12,0xE7,0xE5,0x13,0x14,
0xE4,0x15,0x16,0x17,0xA0,0x18,0x1A,0x1B,0xC2,0x9B,0xAD,0xAC,0xF8,0x01,0xAE,0x02,
0x03,0xE5,0xE7,0xE8,0xF9,0xE9,0xEB,0x04,0xE3,0xE1,0x05,0xF6,0x06,0xE4,0x07,0xE2,
0xF0,0x08,0x09,0xF3,0xF4,0xF7,0xEF,0x0A,0x0B,0x0C,0x0D,0xEC,0x0E,0x0F,0x10,0xF5,
0xED,0x11,0xE6,0xA0,0x12,0xF2,0x13,0x14,0x15,0xEE,0x16,0x17,0x18,0x19,0x0E,0x0F,
0xAD,0xED,0xF9,0x9B,0xAE,0x01,0xF3,0x02,0x03,0xF5,0xF4,0xF0,0x04,0xEF,0x05,0xE9,
0x06,0xE8,0xA0,0xE1,0xEC,0x07,0xF2,0x08,0xE5,0x09,0x0A,0x0B,0x0C,0x0D,0x9B,0xF5,
0x19,0x1A,0xA9,0xBB,0xF6,0xE6,0x01,0x9B,0xAD,0xE2,0xF0,0x02,0xA7,0x03,0x04,0x05,
0xF5,0xE3,0xAC,0xE7,0xF2,0x06,0xEB,0x07,0xEC,0xED,0xEE,0xF9,0x08,0xAE,0x09,0x0A,
0xE4,0x0B,0x0C,0xF4,0x0D,0xF3,0x0E,0x0F,0x10,0xE1,0xEF,0x11,0xE9,0x12,0x13,0xE5,
0x14,0xA0,0x15,0x16,0x17,0x18,0xA0,0x16,0xA2,0xA7,0xE2,0xEB,0xED,0xEE,0x9B,0xF7,
0x01,0x02,0x03,0xBB,0xF9,0xF0,0x04,0x05,0xEC,0x06,0x07,0x08,0xF5,0xE1,0x09,0xAC,
0xE3,0x0A,0xE8,0x0B,0xE9,0x0C,0xEF,0xF3,0xAE,0x0D,0x0E,0xE5,0x0F,0x10,0x11,0xF4,
0x12,0x13,0x14,0x15,0x14,0x15,0xBB,0xE2,0xAD,0xED,0x01,0x9B,0xA7,0xE3,0xAC,0xEC,
0xEE,0x02,0xF7,0x03,0x04,0xF9,0x05,0x06,0x07,0x08,0xF4,0xAE,0xF5,0x09,0x0A,0xF2,
0xE1,0xF3,0x0B,0x0C,0x0D,0xE9,0x0E,0x0F,0xEF,0xE5,0x10,0xA0,0xE8,0x11,0x12,0x13,
0x11,0x12,0xEF,0xF6,0x9B,0xEB,0xF9,0x01,0xA0,0xE2,0x02,0xE1,0x03,0xED,0x04,0xE3,
0xE9,0x05,0xE4,0xE5,0xE7,0x06,0xEC,0xF0,0x07,0x08,0x09,0x0A,0x0B,0xF3,0x0C,0xF4,
0xEE,0x0D,0xF2,0x0E,0x0F,0x10,0x05,0xE5,0xF3,0xF9,0x9B,0x01,0xEF,0x02,0x03,0xE1,
0x04,0xE9,0x0A,0x0B,0xAE,0x9B,0xEC,0xED,0x01,0x02,0xF3,0xEE,0xF2,0x03,0xE5,0x04,
0xE8,0xA0,0xE1,0x05,0xEF,0x06,0x07,0x08,0xE9,0x09,0x05,0x06,0xA0,0xAC,0xAD,0xF4,
0xE9,0x01,0x02,0xE1,0xE5,0x03,0x9B,0x04,0x11,0xA0,0xBF,0xE1,0xE2,0xE6,0xED,0xE4,
0xE9,0xF7,0xA7,0x01,0x02,0xBB,0x03,0x04,0xEC,0x05,0x9B,0xEE,0x06,0xEF,0x07,0xAC,
0xE5,0xF3,0x08,0x09,0x0A,0xAE,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x06,0x07,0xA0,0xAE,
0xE1,0xE5,0xEC,0xFA,0x9B,0xEF,0xE9,0x01,0x02,0x03,0x04,0x05,0x9B,0x9B,0x9B,0x9B,
0x9B,0x9B,0x9B,0x9B,0x9B,0x9B,
};

/* external is only for debugging kern values */
//#define USE_KERNING_H
#ifdef USE_KERNING_H
#define USE_KERN_PER256
#include "kern.h"
#warning using EXTERNAL kerning header + func
#else
#warning using internal kerning header + func
unsigned char kern_p256_8859_1[ 256 ] = {
/* x00                                                                    */
          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
/* x10                                                                    */
          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
/* x20        !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /   */
         99, 77,118,215,215,215,215, 38, 97, 97,159,159, 77,159, 59,225,
/* x30    0   1   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?   */
        225,159,225,225,225,225,225,225,225,225, 77, 77,192,192,192,225,
/* x40    @   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   */
        225,225,225,225,225,225,225,225,225, 77,156,225,225,225,225,225,
/* x50    P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _   */
        225,225,225,225,225,225,225,255,225,192,118,118,225,118,118, 31,
/* x60    `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o   */
         15,156,156,156,156,156, 59,159,156, 38, 77,156, 38,216,156,156,
/* x70    p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~   .   */
        156,156, 99,156, 99,159,179,243,177,177,177,118, 38,118,156,225,
/* x80                                                                    */
        179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,
/* x90                                                                    */
        179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,
/* xa0                                                                    */
        179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,
/* xb0                                                                    */
        179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,
/* xc0                                                                    */
        179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,
/* xd0                                                                    */
        179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,
/* xe0                                                                    */
        179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,
/* xf0                                                                    */
        179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,
};


#endif

/************************************************************* ATSC RRT [VCHIP]
 This avoids RRT huffman parse w/ fast lookup of pre-decoded built-in table:
    The RRT only repeats once per minute so better to have it ready here.
    Most (short) EPGs are complete in less time than the RRT repeat cycle.
    The actual received RRT is only parsed for CRC32 to help QoS detection.
*/

/* FUTURE FIXME: This Rating Region Table is built-in and will not reflect
    any new categories. The spec short-changes the RRT size, at 1024 bytes
    and it's mostly full, so adding new categories is a moot point.
*/
char *ratings[] = {
"Audience", "", "None", "TV-G", "TV-PG", "TV-14", "TV-MA","","","",
"Dialogue", "", "D","","","","","","","",
"Language", "", "L","","","","","","","",
"Sex", "", "S","","","","","","","",
"Violence", "", "V","","","","","","","",
"Children", "", "TV-Y","TV-Y7","","","","","","",
"Fantasy Violence", "", "FV","","","","","","","",
"MPAA", "", "N/A","G", "PG", "PG-13","R","NC-17","X","NR",
}; /* aka vchip */

/************************************************************** ATSC VARS */

/* ATSC System Time, 32 bit and structure versions */
time_t atsc_stt = 0;
struct tm atsc_stt_tm;
/* unsigned int stt_prev = 0; */


/* shorts use about 84k bytes for 12 hours of transport error counts.
    Terrestrial should never see more than 12898 errors per second.
    Cable maximum error rate should be around 25800 errors per second.
    Define the limits. want to only change CAP_HRS, let rest be computed.
*/
#define CAP_HRS 6
#define CAP_STZ (CAP_HRS * 3600)
short cap_stats[ CAP_STZ ]; /* 6 hours of capture error stats log */
/* enough rows to match size of cap_stats[], plus 2 for full error text */
#define CAP_ROWS (2+(CAP_HRS * 60))
/* entire line is 80 columns, but only two ansi colors in wall+ets
   giving computation of (62 * 8) + 20 bytes per line
 */
/* each line of capture log is this many bytes */
#define CAP_COLS ((62 * 8) + 20)

/* enough for descriptor length and width, with some ansi color codes */
/* enough for 32 lines of description per vc and 8 vc selects */
#define TVCT_ROWS 256
/* at least 80 for no color codes, and 5 8-byte color codes, uses only 2 */
#define TVCT_COLS 128

/* enough for 128 EITs + 128 ETTs + 24 extras, adjust if needed */
#define MGT_ROWS 280
/* enough for some ansi color */
#define MGT_COLS 128

char cap_text[ CAP_ROWS ][ CAP_COLS ];
unsigned int cap_idx; /* lines in cap text */

/* too small to calloc */
char tvct_text[ TVCT_ROWS ][ TVCT_COLS ];

/* vct no idea how many lines needed */
unsigned int tvct_idx;
char mgt_text[ MGT_ROWS ][ MGT_COLS ];

/* mgt needs enough for each EIT ETT + a few more */
unsigned int mgt_idx;
unsigned int mgt_dl;            /* mgt descriptor length */

unsigned int pmt_atcc;          /* pmt closed caption indication */

int vc_ncs = 0;         /* # of populated vc[] entries */
int pat_ncs = 0;                /* # of PMTs found in PAT */
int vct_ncs = 0;                /* # of VCs found in VCT */

unsigned int vct_crc = 0;
unsigned int vct_dtl = 0;       /* vct detail [d] key toggle */
unsigned int mgt_crc = 0;

/* display resize handling */
int columns = 80;               /* screen x max */
int lines   = 25;               /* screen y max */
int pcol;
int prow;
int user_lines = 20;            /* how many lines after line 5 */

/* program guide handling */
volatile int pgme = 0;  /* previous program event count */
volatile int pgmd = 0;  /* previous program description count */
int pgmto = 0;  /* program timeout */
int pgm_done = 0;/* non zero when event + desc = no change */
/* int pgm_fail = 0;/ * PG_* defines */

int qosc = 0;      /* 100 - (100 * errors / (packets/seconds)) */
long long qost = 0LL; /* 100 - (100 * errors total / ts packet total) */
int last_qos;    /* ^ v indicators */
int last_pktb;   /* last packet bad count */
int last_pktc;   /* last packet count */

/******************************************************************** TS
 * transport validation and counters: test packet_uses these
 */

unsigned char last_cc[0x2000];  /* 8k  last CC seen   by PID 0-1FFF */
unsigned int cce_pids[0x2000];  /* 32k CC errors      by PID 0-1FFF */
unsigned int psi_pids[0x2000];  /* 32k payload counts by PID 0-1FFF */
unsigned int pids[0x2000];      /* 32k packet counts  by PID 0-1FFF */

unsigned int mg_idx = 0; /* increments with new list entries */
unsigned int mg_eit = 0; /* 0 = no EIT in MGT */
unsigned int eit_idx = 0;
unsigned int ett_idx = 0;
unsigned char mgt_vn = 0xFF;

/* Terrestrial has 8 vc max, cable has no EPG but > 16 possible VCs.
   The most I've seen active at once, with video, on cable is about 8 SDs.
 */
#ifdef USE_CABLE
#define VCZ 32
#else
#define VCZ 8
#endif

/****************************************************************************
 * 16 virtual channels is all that is supported, but more could be.
 * VC n has Program # (.1 .2 .3) which EIT/ETT etmid uses from sr field
 * Each VC entry is just over 10 kilobytes.
 ********************************************************************* ATSC VC
 */
struct vc_s {
    char name[16];      /* 7 unicode 16 bit words for vc name + NULL */
    char cname[16];     /* component name from pmt for specific program */
    unsigned int major;         /* 10 bit major channel number for vc */
    unsigned int minor;         /* 10 bit minor channel number for vc */
    unsigned int mode;          /* modulation mode: see A/65b table 6.5 */
    unsigned int freq;          /* frequency, obsolete, 0 after jan 1 2010 */
    unsigned short tsid;        /* VCT TSID to match against PAT TSID */
    unsigned int pn;            /* program number for (or from) PAT and PMT */
    unsigned int etm;           /* extended text message location, 0 if none */

    /* next three get ignored, but stored */
    unsigned int actrl;         /* 1 bit access is not controlled if 0 */
    unsigned int hide;          /* 1 bit nz makes channel surf skip this one */

/* cable uses these two, but not terrestrial */
    unsigned int psel;          /* path select (0=1st or 1=2nd tuner in STB) */
    unsigned int oob;           /* 1 is TSID is not in PTC of this CVCT? */

    unsigned int hideg;         /* if hidden set, hide the guide too */

    /* more useful bits */
    unsigned int svct;          /* service type */
    unsigned int src;           /* source id, part of etmid, pgn LU for EPG */
    unsigned short adl;         /* addition descriptor length also skipped */
    unsigned int acn;           /* audio channels in this vc */
    /* is adl is used? */

    unsigned int vctes;                 /* Elementary Streams in this VCT */
    unsigned int pmtes;                 /* Elementary Streams in this PMT */

    unsigned short pcrpid;              /* ES used for timing on this VC */
    unsigned short pmtpid;              /* PMT used for this VC */
    unsigned short vcdlen;              /* VC descriptor length 10 bits */
    unsigned char vcdescr[1024];        /* ATSC VCT descriptors */
    unsigned char vct_vn;               /* VCT vn, VCZ copies of same VN */
    
    unsigned short pilen;               /* PMT info descriptor len 10 bits */
    unsigned char pidesc[1024];         /* PMT info descriptor */
    unsigned char pmtvn;                /* PMT version for this VC */

/* elementary stream max allowed for VCT is ESZ */
#define ESZ 8
    unsigned int  espid[ESZ];           /* VCT ES PID of streams */
    unsigned char estype[ESZ];          /* VCT ES stream types */
    char eslang[ESZ][4];                /* VCT ES ISO-639 lang code */
    unsigned int  esilen[ESZ];          /* VCT ES descriptors length */
    unsigned char esdesc[ESZ][1024];    /* VCT ES descriptors */
    unsigned char ca;                   /* PMT has CA flag */
    int hres;                           /* SEQ video horizontal resolution */
    int vres;                           /* SEQ video vertical resolution */
    int vfr;                            /* SEQ video framerate */
/* not on cable. ATSC broadcasts send bitrate in desc: 192 = 2.0 384 = 5.1 */
    int abr[ESZ];                       /* AC3 desc audio bitrate */
    int ach[ESZ];                       /* AC3 desc audio chans (calc) */
};
struct vc_s vc[VCZ]; /* terrestrial uses less than 8 VChannels */

/* PAT + PMT fill these in, VCT copies over descriptors when it arrives */
struct pa_s {
    unsigned short pmtpid;              /* PAT PMTPID               12 bits */
    unsigned short pn;                  /* PAT program number       16 bits */
    unsigned short tsid;                /* PAT transport stream id  16 bits */
    unsigned char vn;                   /* PMT version number        8 bits */
    unsigned char lv;                   /* PMT last version          8 bits */
    unsigned short pcrpid;              /* PMT pcrpid               12 bits */
    unsigned short pilen;               /* PMT program info len     10 bits */
    unsigned char pidesc[1024];         /* PMT program info desc  1024 bytes */ 
    unsigned short pmtes;               /* PMT number of streams     2 bytes */
    unsigned short acn;                 /* PMT number of audios      2 bytes */ 

/* 8 PMT streams per program map, with 8 PAT programs, 1 video, multi audios */
    unsigned short espid[ESZ];          /* PMT ES PIDs of streams   16 bytes */
    unsigned char estype[ESZ];          /* PMT ES stream types       8 bytes */
    char eslang[ESZ][4];                /* PMT ES ISO-639 lang code 32 bytes */
    unsigned short esilen[ESZ];         /* PMT ES stream desc len   16 bytes */
    unsigned char esdesc[ESZ][1024];    /* PMT ES stream descrptr  8192 bytes */
    unsigned char ca;                   /* PMT has CA flag */
    int hres;                           /* SEQ video horizontal resolution */
    int vres;                           /* SEQ video vertical resolution */
    int vfr;                            /* SEQ video frame rate */

/* not on cable. ATSC broadcasts send bitrate in desc: 192 = 2.0 384 = 5.1 */
    int abr[ESZ];                       /* AC3 desc audio bitrate */
    int ach[ESZ];                       /* AC3 desc audio chans (calc) */
};
struct pa_s pa[ VCZ ];                  /* allocation minimum 75k bytes */



/* NOTE: KQED has 5, but they cheat by hiding some streams at different
   times, so not all the VChanels on the list are actually active.
   This should not present any timer scheduling issues, as long as you
   don't depend on a specific Vchannel order but instead use program number.
*/

/*
    A/65b specification does not give any fixed limit to how many events may
    be included in a single EIT, only that the EIT covers a 3 hour time frame.

 program guide eit section event max
   8 gives round numbers, 7 seems to be the max so far, 6 is no-dup minimum,
   except FOX has nationwide PSIP screw-up that prevents 6 from working.
   
 PEZ also see (numevs-1) for why last event is ignored
                [because it's duplicated in next EIT]

 Math is easier to debug with PEZ 8, but wastes memory. Using it anyway because
 of issues with FOX sending weirdo out-of-chronological-order EIT events.

 Program Event siZe, anticipated max number of events per EIT

*/
#define PEZ 8
/* EITn maximum count, in the spec */
#define EIZ 128
/* ETTn maximum count, in the spec */
#define ETZ 128
/* virtual channel count, vc[8] limits to 8 */

/* program guide size */
/* VC # is top level multiplex for each entry in pgm */
#ifdef USE_CABLE
#define PGZ (1 * EIZ * PEZ)
#else
#define PGZ (VCZ * EIZ * PEZ)
#endif

/*  If you change the EPG data sizes, don't forget to do make eclean,
    or else the saved EPG data structure being wrong size will crash it.

    ATSC A/65b allows 512 bytes for event title and description.
    It uses over 8MB in RAM with full EPG data allocated, mostly blank.

    Define USE_TINY_EPG for an EPG that uses about 2.5MB for 8 VCs.

        FIXME: Are any places left where the size is numerical constant,
                and not using either the define constant or sizeof? 
                Seems to be OK so far, aside from forgetting make eclean.
*/
#define USE_TINY_EPG
#ifndef USE_TINY_EPG
/* old style */
#define PNZ 512
#define PDZ 512
#warning using full EPG
#else
/* new style */
#define PNZ 64
#define PDZ 256
#warning using tiny EPG
#endif

/* rating text limit */
#define PRZ 16


/* NOTE:
    1k per event for text only is wasteful. Usually is about 160 chars,
    with around 20-30 being used for event name and rest for text, so
    64 and 192 chars should be enough for most event guides.
    
 PDZ 256 may be insufficient. uncompressed raw text max should be 256,
 but some Huffman decompressed descriptions on KPXB are nearly 512 chars
 so 512 is probably the real limit for ETT single mss

 This should be limited in huffman decode, so PNZ/PDZ can be tweaked here.
 Do not tweak it here until huffman decode isolates the 512 char buffer, as
 well as boundary checking on parse eit/ett mss so they don't overflow.
 The rest of the code should treat PNZ PDZ as the maximums for the fields.

TODO:
    Eventuallly I'll have realloc on the EPG events and EIT/ETT to allow
    the maximum title and description sizes without wasting too much memory.
*/

/************************* ATSC PSIP PROGRAM LIST ****************************
 * This is the largest array the program needs for speed.
 * Maximum is 128 EIT's, each EIT covers 3 hours, so max is 6 programs/EIT
 * 6 because assuming 30 min smallest pgm, gives 6 pgms in 3 hours
 * NOTE: always seems to be the last EIT is duplicate of next first.
 * 128 * VCZ * 6 is maximum number of program events to allocate for 8 vc's
 *
 * NEEDLESS COMPLEXITY: MEMORY IS CHEAP: USING 128 * VCZ * 8
 *        MGT should calloc this based on (EIT+ETT)*VCZ tables given?
 *        MGT can't be depended upon because it seems to be broken.
 *        Need to test if more than 6 valid pgms ever in one EIT. ok so far.
 *
 * NOTE: handling non-chron broken FOX EPG requires 8, not 6, EIZ events.
 *
 ******************************************************* ATSC PROGRAM GUIDE */
struct event_s {
    unsigned int etmid;         /* Extended Text Message ID */

    char name[PNZ];             /* from EIT, name title text/huffman + NUL */
    char tname[32];             /* name truncated to 16 chars [+ MMDD-HHMM?] */

    char nlang[4];              /* from EIT, name title language code + NUL */
    unsigned char eitn;         /* from EIT number n */
    unsigned char eitvn;        /* from EIT, last version for title */
    unsigned char ncomp;        /* from EIT, name compression type */
    unsigned char nmode;        /* from EIT, name unicode mode */
    unsigned char nchr;         /* from EIT, name bytes in description */


    char desc[PDZ];             /* from ETT, description text/huffman + NUL */
    char dlang[4];              /* from ETT, description language code + NUL */
    unsigned char ettn;         /* from ETT number n */
    unsigned char ettvn;        /* from ETT, last version seen for desc */
    unsigned char dcomp;        /* from ETT, desc compression type */
    unsigned char dmode;        /* from ETT, desc unicode mode */
    unsigned char dchr;         /* from ETT, desc bytes in description */

    char rating[PRZ];           /* from EIT, descriptors xref RRT + NUL */
    char movie;                 /* 0 is no rating/not movie, nz is mpaa idx */

    unsigned short source;      /* from EIT ETMID top 16 bits */
    unsigned short pn;          /* from VCT lookup of source */

    unsigned int st;            /* from EIT, start time */
    struct tm stm;              /* start time as type tm */
    unsigned int ls;            /* from EIT, length in seconds */

    char vc;                    /* from ETMID source, VC select */
    char va;                    /* VC audio select, always 0 for now */
    char chan;                  /* scanlist ch # for logical ch # */
};


struct event_s epg[ PGZ ];      /* live program guide raw [chopped] format */
struct event_s *epg2 = NULL;    /* test epg pointer */
#ifdef USE_WWW
struct event_s *epg3 = NULL;    /* http epg pointer */
struct event_s *epg4 = NULL;    /* http epg grid pointer */
#endif
    
/* program guide version of epg re-sorted/re-arranged, blanks moved to end */
short  pg[ PGZ ];               /* index to user selected entries in epg[] */
short pg1[ PGZ ];               /* index for save/load */
short pg2[ PGZ ];               /* index for test guides */
#ifdef USE_WWW
short pg3[ PGZ ];               /* index for dump epg */
short pg4[ PGZ ];               /* index for dump epg */
#endif

struct pgm_s pgm;               /* active program guide settings */
struct pgm_s pgm1;              /* load/save epg copy */
struct pgm_s pgm2;              /* test guides copy */
#ifdef USE_WWW
struct pgm_s pgm3;              /* http refresh copy */
struct pgm_s pgm4;              /* http refresh copy */
#endif

unsigned char eit_vn[EIZ][VCZ];

/* If guide ever gets above 32768 entries, short will be a problem.
   It's not likely to for terrestrial and no guide on cable yet, so is moot.
*/

/*
 7 bits for eit and 3 bits for source, terrestrial hasnt had 8 VCs here yet
 SEE numevs, using numevs-1, because last event is repeated as first next
 multiply by 6 to account for 6 out of 7 EIT mss being non-duplicate
 multiply by 8 too, because that's how many vc[] structs for Program lookup.

 */
int epg_test = 0;               /* test guides in progress hold down */
int epg_www = 0;                /* 'w' status means http is bound */



/******************************************************************** ATSC STT
 * see A/65b Table 6.1
 */
struct stt_s {
/* payload data */
    unsigned int st;            /* system time */
    unsigned char guo;          /* gps utc offset */
    unsigned short ds;          /* daylight savings flag */

/* parsed data */
    unsigned char dss;          /* nz means DST in effect */
    unsigned char dsd;          /* nz means DST change on this day of month */
    unsigned char dsh;          /* nz means DST change on this hour of day */
};
struct stt_s astt;      /* copy of data in last STT read */

/* generic payload structure */
struct payload_s {
    unsigned int crc;                   /* crc32 result */
    unsigned int payoff;                /* payload offset */
    unsigned short sl;                  /* section length */
    unsigned char payok;                /* payload status */
    unsigned char vn;                   /* version number */
    unsigned char lv;                   /* last version */
    unsigned char payload[4096];        /* payload */
};

/* These structures are the generic payload structures used during capture.
   They are allocated before capture to point to valid memory, and
   freed after capture because they aren't useful until next capture.
*/
struct payload_s stt;           /* single packet, 56 bit payload */
struct payload_s rrt;           /* 4k rating region table */
struct payload_s ctt;           /* 4k channel text table */
struct payload_s mgt;           /* 4k master guide table */
struct payload_s vct;           /* 4k virtual channel table */
struct payload_s pat;           /* 4k program association table */
struct payload_s cat;           /* 4k conditional access table */
struct payload_s pmt[VCZ];      /* 4k program map table per VC */

struct payload_s stt;           /* single packet, 56 bit payload */
struct payload_s rrt;           /* 4k rating region table */
struct payload_s ctt;           /* 4k channel text table */
struct payload_s mgt;           /* 4k master guide table */
struct payload_s vct;           /* 4k virtual channel table */
struct payload_s pat;           /* 4k program association table */
struct payload_s cat;           /* 4k conditional access table */
struct payload_s pmt[VCZ];      /* 4k program map table per VC */

#ifdef USE_DYNAMIC
#warning using dynamic EIT & ETT & FIFO
/* dynamic EIT ETT allocation, causes crash on [l]-[p]-[enter] ? */
struct payload_s *eit = NULL;   /* 4k * 128 Event Info Table alloc */
struct payload_s *ett = NULL;   /* 4k * 128 Event Text Table alloc */
#else
#warning using static EIT & ETT & FIFO
/* old static usage > 1MB, no pointer changes needed to parse eit/ett yet */
struct payload_s eit[ EIZ ];    /* 4k * 128 Event Info Table */
struct payload_s ett[ EIZ ];    /* 4k * 128 Event Text Table */
#endif

#ifdef USE_AV_PAYLOADS
/* not using yet, but may find use later. gobbles CPU to assemble mpeg2 */
/* atscut -s tries to avoid parsing mpeg2 (except SEQ) and is real fast now */
/************************************************************** MPEG2 Video */
/* MPEG2 Video Payload */
#define MPEG2_MAX (128 << 10)
struct {
    unsigned int payoff;
    unsigned int payok;
    unsigned int afl_payoff;            /* where section starts after afc */
    unsigned char payload[ MPEG2_MAX ]; /* don't know size limit */
} mpv;
/************************************************************** MPEG2 Audio */
/* A/52 Audio Payload */
#define A52_MAX 65536
struct {
    unsigned int payoff;
    unsigned int payok;
    unsigned int afl_payoff;            /* where section starts after afc */
    unsigned char payload[ A52_MAX ];   /* dont know size limit */
} a52;
/****************************************************************************/
#endif
unsigned char new_pat[188]; /* no descriptors */
unsigned char new_pmt[376]; /* has descriptors */
int pat_built = 0;
int pmt_built = 0;

/***************  END OF RAW PAYLOAD TABLES BUILT FROM STREAM ***************/

/* it's only a concidence that Table limit is same as PID limit */
#define TABLE_MAX 0x2000
#define PID_MAX 0x2000
/*************************************************************** LOCAL MGTs */
/* master guide created every time MGT version number changes */
struct mg_s {
    unsigned short tt;
    unsigned short pid;
    unsigned short nb;
    unsigned short nb1;
    unsigned short dl;
    unsigned char vn;
    unsigned char vn1;
}; /* 9 bytes */

/* specs says reserved in some places so don't need all 0x2000
    has big gaps, wastes memory, but a much faster lookup.

 TODO:
    All the ATSC stuff should be above 0x1000, so can halve the list size.

    4096 . 9 bytes, 36k per struct below, about 144k total
*/
struct mg_s mg[ TABLE_MAX ];    /* raw order parsed by MGT, up to mg_idx */
struct mg_s mgp[ PID_MAX ];     /* mg by PID, not for sytem PID 1FFB */
struct mg_s mgs[ TABLE_MAX ];   /* mg sorted by table type */

/* max chars in name */
#define SEARCH_NAME_MAX 32
/* max names on list */
#define SEARCH_LIST_MAX 256

struct search_s {
    char name[ SEARCH_NAME_MAX ];       /* search name [required] */
    int chan;                           /* channel filter [optional] */
    unsigned short pn;                  /* program# filter [optional] */
    char days;                          /* week day filter [optional] */
};

struct search_s search_list[ SEARCH_LIST_MAX ]; /* dynamic event search */
int search_idx; /* number of search event names in cfg file */

/* spam filter, name and age are saved, len is computed on load */
/* max age before spam is automatically removed is 30 days */
#define SPAM_NAME_MAX 20
#define SPAM_LIST_MAX 1024
#define SPAM_AGE_MAX (SECDAY * 365)
struct spam_s {
    char name[ SPAM_NAME_MAX ]; /* truncated spam name */
    time_t st;          /* last matching spam found */
    int len;            /* byte len of name */
};

struct spam_s spam_list[ SPAM_LIST_MAX ];
pthread_mutex_t spam_mutex;
int spam_idx = 0; /* spam index */

/* output reductions for ssh and maximum efficiency with no extra redraws */
struct {
        int w; /* old termio width to trigger refresh if current differs */
        int h; /* old termio height to trigger refresh if current differs */

        int channels;   /* TODO */
        int clock;      /* TODO date and time */
        int volstats;   /* TODO cap dir space left */
        int headers;    /* TODO headers for various modes */
        int timers;     /* replaces timer_list */
        int pstats;     /* table parser stats */
        int vstats;     /* channel vc status */
        int estats;     /* event stats */
        int mgt;        /* no redux? */
        int vct;        /* redux */
        int epg;        /* redux */
        int log;        /* redux (this one does not redux very well) */
} refresh;

/* EIT locks allow drain thread to change epg[] before UI thread uses it */
volatile unsigned char epg_locks[ EIZ * VCZ ]; /* 8 VCs of 128 EITs per VC */

/* timer, mgt, vct, epg and capture log display
   start or end of capture resets to 0 for timers
   and to make sure capture log gets written
 */
#define D_TIMERS 0
#define D_HELP 1
#define D_MGT 2
#define D_VCT 3
#define D_EPG 4
#define D_LOG 5
#define D_CHANNELS 6
/* default is always fall back to timer list */
int display_type = D_TIMERS;
int channel_offset = 0;
int channel_idx = 0;

/* standard [w] key display options for most DVB drivers */
#define SIG_STR 0
#define SIG_SNR 1
#define SIG_FMHZ 2
#define SIG_WLEN 3

/* 2 options for custom HD3000 driver, bit error rate/s and modulator freq */
#ifndef USE_DVB_EXPERIMENTAL
#define SIG_MODREG 4
#else
#warning using DVB EXPERIMENTAL driver
#define SIG_FOHZ 4
#define SIG_BER 5
#define SIG_MODREG 6
/* not done yet */
#endif

int display_sigtype = SIG_STR; /* default is show % of 30dB */

/* if non zero, show ATSC and MPEG2 transport status in bottom 7 lines */
int display_stat = ~0;

int udp_mcast = 0;              /* user toggles with u key */
#ifdef USE_MCAST
struct udp_s {
    int sock;
    int bind;
    struct sockaddr_in addr;
};
struct udp_s udp;
#endif


#define ALLOC_LIMIT 32
#define ALLOC_CHARS 32
struct alloc_s {
    void *p;
    size_t z;
    char n[ ALLOC_CHARS ];
};

struct alloc_s alloc_list[ ALLOC_LIMIT ];

#define TIMER_NAME_MAX 20
#define AOS_TIME_MIN 5

/* timer struct */
struct qtimer_s {
/* FIXME: use TIMER_NAME_MAX and fix ALL, still looking for stragglers */
    unsigned int chan;  /* PTC to capture */
    unsigned int start; /* event start time, keep as unsigned so -1 > rest */
    int h;              /* weekday timer start hours */
    int m;              /* weekday timer start minutes */
    int len;            /* event length in seconds */
    int days;           /* weekday bits */
    int pn;             /* program number */
    int vc;             /* VC to capture, -1 for raw stream capture */
    int va;             /* VC audio to capture */
    int future;         /* future time, if weekday bits set */
    int secdt;          /* short timer by this much for ext2fs delete delay */
    int etmid;          /* etmid to hold down auto-add after zap */
    int qstat;          /* queue status, set by show timers */
    char *tcol;         /* timer color set from status */
    char name[TIMER_NAME_MAX];  /* 16 chars + @.3 will fit in 19 allowed */
    char ename[PNZ];            /* full name from epg[] */
    char edesc[PDZ];            /* full description from epg[] */
    char lang[4];
};

/* mem use is MAX * ( (4 * 12) + 32 + (512 + 512) ) */
/* 256 is 282624 bytes */
#define TIMER_LIST_MAX 256
/* TIMER_LIST_MAX qtimer_s structures */
struct qtimer_s timer[ TIMER_LIST_MAX ];

/* from current timer if it was added from EPG */
char epg_name[PNZ];
char epg_desc[PDZ];
int epg_to;
int epg_ch;

#define RTC_MAX 3
char *clock_text[ RTC_MAX ] = {
        "REALTIME",
        "PROCESS_CPUTIME_ID",
        "THREAD_CPUTIME_ID"
};

clockid_t clock_ids[ RTC_MAX ] = {
        CLOCK_REALTIME,
        CLOCK_PROCESS_CPUTIME_ID,
        CLOCK_THREAD_CPUTIME_ID
};
clockid_t clock_method = CLOCK_PROCESS_CPUTIME_ID;
long long clock_res;            /* (tv.sec<<32) | tv.nsec */
int clock_idx;

#ifdef USE_PNG
struct img_s {
        jmp_buf jmpbuf;
        int width;
        int height;
        int depth;
        int transform;
        int colortype;
        int interlace;
        png_bytep row_pointers[SIG_PNG_H];
};
#endif

int fifoz = FIFOZ_CAP;

#ifndef USE_DYNAMIC
unsigned char fifo_buffer[FIFOZ_CAP];
#endif

#define F_PATH 1
#define F_PFILE 2
#define F_TFILE 3
#define F_FILE 4

/****************************** globals end *********************************/


/******************************* prototypes ***********************************/
/* Other prototypes would go here as necessary, if re-arranging doesn't help. */

/* threads. pthreads complains if static, so using globals */
void * dvrlog_loop ( void * arg );
void * fifo_input_loop ( void * arg );
void * fifo_output_loop ( void * arg );
void free_fifo( struct fifo_s *fifo );

/* functions, can be static or global */
void get_time( void );
void test_epgs( char *caller );
void open_device( char *caller );
void close_device( char *caller );
void save_config( char *caller );
void console_reset( void );
void console_scan( void );
// void console_exit( int errorcode );

/* http functions are stuck to the end for author expediency */
#ifdef USE_WWW
void http_close_sockets(void);
void http_load_allows(void);
#endif

int aos_delay = AOS_VSB_DELAY;


/***************************** main functions begin ************************/


/* Similar to but different from strncpy:
    No string greater than 64k allowed to be copied, log > 64k and NULLs.
    Does not pad destination with 0's if length of source is shorter than n.
    There is no valid reason to spend cpu cycles filling memory with zeros.
    This will always null terminate at n-1 even if s is n len bytes long.
    d result will always be n-1 characters long.
*/
/* static */
void
astrncpy ( char *d, char *s, unsigned int n )
{
        int c = n;
        char *t = d;
/* log nulls */
        if ( (NULL == d) || (NULL == s) ) {
#if 0
                dvrlog( LOG_INFO, "astrncpy() %p %p NULL", d, s);
#endif
                return;
        }
/* log 0 and > 65535 len */
        if ( (0 == n) || (n > 65535) ) {
#if 0
                dvrlog( LOG_INFO, "astrncpy() %d chars", n);
#endif
                return;
        }

/* count auto decrements, pointers auto increment */
        while (c-- > 0) if (0 == (*t++ = *s++)) break;

        d[n-1] = 0;
}


/* debug: used to find missing parameters. comment this for normal use */
/* #define asnprintf snprintf */

#ifndef asnprintf
/* Incremental snprintf, appends to string 'a' until size 'b' reached.
    This keeps 'b' limited to 'a' string alloc instead of blind melon limit.
    First call should have a strlen 0, *a = 0 or you get variable junk.
 */
/* static */
void
asnprintf ( char *a, size_t b, const char *fmt, ... )
{
        char *p, t[1024];
        int la;
        int lt;
        va_list ap;

        if (NULL == a) return;
        if (b < 1) return;

        memset(t, 0, sizeof(t));
        va_start(ap, fmt);
/* variable arg macro start, pass fmt and ap, variable arg macro end */
        vsnprintf( t, sizeof(t)-1, fmt, ap );
        va_end(ap);

        la = strlen(a);
        lt = strlen(t);

/* bit bucket does not overflow? */
        if ( (la + lt + 1) < b ) {
                p = &a[la];
/* nul term it */
                astrncpy( p, t, lt + 1 );
        }
/* if bit bucket does overflow, silently fail and don't exceed boundary */
}
#endif



/* VCT MGT EPG LOG guides need to refresh stats on exit to timer list */
/* Control-L also uses this to refresh the tube
*/
/* static */
void
set_refresh( void )
{
        refresh.channels = 1;
        refresh.headers = 1;
        refresh.volstats = 1;
        refresh.clock = 1;
        refresh.timers = 1;
        refresh.vstats = 1;
        refresh.pstats = 1;
        refresh.estats = 1;
        refresh.epg = 1;
        refresh.vct = 1;
        refresh.mgt = 1;
        refresh.log = 1;
}



#ifdef USE_ASCII_XLATE
/* step thru t until 0 and convert chars > 128 to ASCII table[char-128] */
/* static */
void
ascii_xlate( unsigned char *table, unsigned char *t )
{
        while (0 != *t) {
                if (*t > 128) *t = table[ *t - 128 ];
                if ('.' == *t) *t = ' ';
                if ('`' == *t) *t = ' ';
                if ('\'' == *t) *t = ' ';
                t++;
        }
}
#endif

/* debug: find missing parameters. comment this for normal use. */
/* also helped to find deadlock in dvrlog, thus the rewrite */
/* #define USE_SYSLOG */
#ifdef USE_SYSLOG
#define dvrlog syslog
#warning using syslog
#endif

#ifndef dvrlog
#warning using dvrlog
/* replacement for syslog */
/* static */
void
dvrlog ( int level, char *fmt, ... )
{
        char m[ LOG_CHARS ];            /* log text */
        va_list ap;                     /* variable length arg list */


/* variable arg macro start, pass fmt and ap, variable arg macro end */
        va_start( ap, fmt );
        vsnprintf( m, sizeof(m)-1, fmt, ap );
        va_end( ap );

/* log full silently drops messages */
        if (dvrlog_idx >= LOG_LINES) return;

        while (EBUSY == pthread_mutex_trylock( &dvrlog_mutex )) {
                nanosleep( &atomic_sleep, NULL );
        }

        get_time();

/* log file is open */
        snprintf( &dvrlog_list[ dvrlog_idx * LOG_CHARS], LOG_CHARS-1,
                    "%s %s\n", &date_now[4], m);
        dvrlog_idx++;

        pthread_mutex_unlock( &dvrlog_mutex );
}
#endif



#ifndef USE_SYSLOG
/* log queue drain thread */
void *
dvrlog_loop ( void * arg )
{
        int i;
        char *t;

        dvrlog( LOG_INFO, "%s detached %d", WHO, getpid() );

        while (dvrlog_fd != NULL) {
            if (dvrlog_idx > 0) {
                while (EBUSY == pthread_mutex_trylock( &dvrlog_mutex ))
                        nanosleep( &atomic_sleep, NULL );

                        for (i = 0; i < dvrlog_idx; i++) {
                                t = &dvrlog_list[i * LOG_CHARS];
                                fprintf( dvrlog_fd, "%s", t); 
                                *t = 0;
                        }
                        dvrlog_idx = 0;
                        fflush( dvrlog_fd );
                        pthread_mutex_unlock( &dvrlog_mutex );
                }
                nanosleep( &atomic_sleep, NULL );
        }
        return NULL;
}

/* start threads for dvrlog */
/* static */
void
init_dvrlog ( void )
{
        char n[256];
        int ok;

        if (NULL != dvrlog_fd) return;

        snprintf( dvrlog_name, sizeof(n)-1, "%s%s%d.log",
                    log_path, NAME, arg_devnum);

#ifdef USE_MULTI_LOG
/* need to rename it? */
        struct stat f;
        ok = stat( dvrlog_name, &f);
        if (0 == ok) {
                struct tm t;
                localtime_r( &f.st_mtime, &t);
                snprintf( n, sizeof(dvrlog_name)-1,
                        "%s.%04d%02d%02d-%02d%02d%02d",
                        dvrlog_name,
                        t.tm_year + 1900,
                        t.tm_mon + 1,
                        t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec );
                rename( dvrlog_name, n );
        }
/* USE_MULTI_LOG */
#endif

/* append to current file (or makes new one) */
        dvrlog_fd = fopen( dvrlog_name, "a" );
        advrlog( LOG_INFO, "log_fd %p %s", dvrlog_fd, dvrlog_name);

/* if opened, see if thread can start, if can't start, fallback to syslog */
        if (NULL != dvrlog_fd) {
                fprintf( dvrlog_fd, "--------------- ");
                fprintf( dvrlog_fd, "%s %s-%s %s\n",
                        syslog_name, VERSION, LASTEDIT, __DATE__ );
                fflush( dvrlog_fd );
            
                memset( &dvrlog_thread, 0, sizeof(pthread_t) );
                ok = pthread_attr_init( &dvrlog_attr );
                ok |= pthread_attr_setdetachstate( &dvrlog_attr,
                                        PTHREAD_CREATE_DETACHED);

                ok |= pthread_create( &dvrlog_thread, &dvrlog_attr,
                                      &dvrlog_loop, NULL );
                if (0 != ok) {
                    dvrlog_fd = NULL; /* fallback to syslog */
                    dvrlog( LOG_INFO, "%s failed, using syslog()", WHO);
                }
        }
}

/* if running in an xterm set the title and icon name */
/* static */
void
set_title()
{
        char *dpy = NULL;
        char *vty = NULL;

        dpy = getenv( "DISPLAY" );
        vty = getenv( "TERM" );
        if (NULL == dpy) return;
        if (NULL == vty) return;

        advrlog( LOG_INFO, "%s DISPLAY \042%s\042 TERM \042%s\042",
                WHO, dpy, vty);

        if (0 == strcmp(vty, "rxvt"))
                fprintf(stderr, "\033]0;%s%d\007", NAME, arg_devnum);

        if (0 == strcmp(vty, "screen"))
                fprintf(stderr, "\033k%s%d\033\\", NAME, arg_devnum);
}

/* not USE_SYSLOG */
#endif

#ifndef USE_KERNING_H
/* yet another variant of my old word wrapper code:
    word wrap san-serif size u for box x pixels wide and y lines high
    truncate s below matching pixel truncate point n,
    for string s using kern table c, stopping at k lines
        s string,
        k table,
        x pixel width of box
        p padding pixels (left+right) 1px margin is p = 2
        y number of lines in box
        u is pixel width of largest character 'W'
        f nz is fragment last word on last line, 0 is break only at ' '
*/
void
truncate_text_kern_box ( unsigned char *s,
                        unsigned char *k,
                        int x, int p, int y, int u, int f)
{
        unsigned char *c, *d;
        int i, r, t, v, w, z;
        unsigned char b;

        w = i = 0;
        t = x - p;
        d = s;
        c = d;

        while ( 0 != *d ) {
                b = *d;
                c = d;
                z = 0;
/* sum next word */
                while ( 0 != *c ) {
                        b = *c;
                        v = k[ b ];             /* per256 */
                        v *= u;                 /* times width */
                        r = 0xFF & v;           /* remainder */
                        v >>= 8;                /* result width in pixels */
                        if (r > 127) v++;       /* round up 1 pixel? */
                        v++;                    /* 1 pixel space */
                        z += v;                 /* total pixels in word */
                        w += v;                 /* total for line */

/* fragment last word on last line? */
                        if ( (0 != f) && (w >= t) && (i==(y-1)) ) {
/* truncate after last letter that fit */
                                *c = 0;
                                return;
                        }
                        c++;
/* NOTE: trailing space gets counted */
                        if (' ' == b) break;
                }

                if (w >= t) {                   /* word too big for line? */
                        i++;
                        if (i >= y) {           /* last line? */

/* truncate after last word that fit */
                                *d = 0;
                                return;
                        }
                        w = z;                  /* next line, end of word */
                }
                if (0 == *c) break;
                d = c;                          /* next word */
        }
/* FIXME: non-wrappable word stops here and loses logical line count */
        *c = 0;
}
#endif

/* filebase performs various truncations of a given file name:
   caller must insure destination can hold the truncated result

    d is destination address, s is source address, o is option flags 
        Options are mutually exclusive:
            F_PATH gives path
            F_PFILE gives path and truncated filename
            F_TFILE gives truncated filename
            F_FILE gives filename

    filebase delimiter is considered the last . at end of path/filename,
    because all files are considered to be *.ts or *.something.
    missing . in path+filename (sourced in s) will do nothing.
    missing / in path+filename (sourced in s) will do nothing.

    Example:    /dtv/News.0.ts
        has     4 reusable parts:
                F_PATH          path base /dtv/
                F_PFILE         path file base /dtv/News.0
                F_TFILE         file base name News.0
                F_FILE          file name only News.0.ts

    Example:    x.conf
        if no / in source, path is loaded with ./
                F_PATH          path base ./
                F_PFILE         path file base ./x
                F_TFILE         file base name x
                F_FILE          file name only x.conf
*/

/* static */
void
filebase ( char *d, char *s, int o )
{
        char *t;

        *d = 0;

/* limit option flags to non-bogus */
        if (0 == o) return;
        if (0 > o) return;

/* limit string handling to non-bogus */
        if (NULL == d) return;
        if (NULL == s) return;
        if (0 == *s) return;

/* mutually exclusive options for how to truncate the source name */
        switch( o )
        {
/* path only, with / */
        case F_PATH:
                strcpy( d, "./" );
                t = strrchr( s, '/' );
                if (NULL != t) {
                        strcpy( d, s );
                        t = strrchr( d, '/');
                        t++;
                        *t = 0;
                }
                break;

/* path and file, without last .ext */
        case F_PFILE:
                strcpy( d, "./" );
                t = strrchr( s, '/' );
                if (NULL == t) d += 2;
                strcpy( d, s );
                t = strrchr( d, '.');
                if (NULL != t) *t = 0;      /* truncate at last . */
                break;

/* truncated file only, without last .ext */
        case F_TFILE:
                t = strrchr( s, '/' ); /* skip path */
                if (NULL != t) {
                        t++;
                        strcpy( d, t );

/* truncate at last . */
                        t = strrchr( d, '.');
                        if (NULL != t) *t = 0;
                } else {
/* no path, truncate at last . */
                        strcpy( d, s );
                        t = strrchr( d, '.');
                        if (NULL != t) *t = 0;
                }
                break;

/* file only with .ext */
        case F_FILE:
                t = strrchr( s, '/' );
                if (NULL != t) {
                        t++;
                        strcpy( d, t );
                } else {
                        strcpy( d, s );
                }
                break;

        default:
                dvrlog( LOG_INFO, "filebase unknown parse type %u\n", o);
                break;
        }
}

/* Copy source file s to destination file d, a is 0 copy or 1 append:
    If source contains '*', source is used for glob list.
    If destination term with '/', [glob] source appends to dest.
    NOTE: It could *always* glob, however glob() uses a lot of cycles.
    Also, it tries to behave like cp -a and keep file date and mode bits.
    TODO? alloc buf fs.blocksize or page-size? 4k is OK
*/
/* static */
int
filecopy ( char *d, char *s, int a )
{
        char buf[4096], ni[512], no[512], fb[256], *p;
        int i, j, k, o, r, w, z, e, g, f, rc;
        struct utimbuf ut;
        int upm;
        glob_t globt;
        struct stat64 fs;

        z = sizeof(buf);

/* sanity checks */
        if (NULL == d) return -1;
        if (NULL == s) return -1;
        if (0 == *d) return -1;
        if (0 == *s) return -1;
    
        e = 0;
        f = 1;
        g = 0;

/* glob needed for * in filename? */
        p = strchr( s, '*' );
        if (NULL == p) p = strchr( s, '?' );
        if (NULL != p) g = ~0;
        
        if (0 != g) {
/* WARNING: no returns until globt is freed, only continues and breaks */
            glob( s, 0, NULL, &globt );

            f = globt.gl_pathc;
            advrlog( LOG_INFO, "%s glob %s files %d", WHO, s, f);
        }

/* any more glob files left to do, or is single file? */
        for (j = 0; j < f; j++) {

/* set name in and name out */
            astrncpy( ni, s, sizeof(ni) );
            astrncpy( no, d, sizeof(no) );
            
/* glob will change source name to glob index if found */
            if (0 != g) astrncpy( ni, globt.gl_pathv[ j ], sizeof(ni) );

/* remove any trailing / */
            p = no + strlen( no );
            p--;
            if ('/' == *p) *p = 0;

/* destination exists? */
            rc = stat64( no, &fs );
            if (0 == rc) {
                if (0 != (S_IFDIR & fs.st_mode)) {
                    filebase( fb, ni, F_FILE );
                    asnprintf( no, sizeof(no), "/%s", fb );
                }
            }

/* keep source metadata: cp -a emulation sets mtime and mode after copy */
            rc = stat64( ni, &fs);

/* skip bad file for whatever reason */
            if (rc < 0) {
                dvrlog( LOG_INFO, "%s can't stat %s", WHO, ni);
                continue;
            }

/* clear other time stamps */
            memset( &ut, 0, sizeof(ut) );
            ut.modtime = fs.st_mtime;
            ut.actime = fs.st_atime;

            upm = fs.st_mode;

            advrlog( LOG_INFO, "%s %s %s", (0 == a)?"copy":"append", ni, no );

/* peter knaggs says read only helps luser mode */
            i = open( ni, FILE_ROMODE );
            if (i < 3) {
                dvrlog( LOG_INFO, "%s can't open %s err %d", WHO, ni, errno);
                e = -1;
                continue;
            }

/* copy, mode is octal */
            if (0 == a)
                o = open( no, FILE_WMODE, 0644 );

/* append. seeks end of file instead of O_APPEND flag with NFS problems */
            if (0 != a)
                o = open( no, O_RDWR | O_CREAT, 0644 );

            if (o < 3) {
                dvrlog( LOG_INFO, "%s can't open %s", WHO, no);
                close ( i );
                e = -1;
                continue;
            }

/* append sets file position to end, should avoid NFS problems?
   no. append is broken. don't use it here.
*/
            if (0 != a) lseek( o, 0, SEEK_END );

            r = 1;
            e = 0;
            k = 0;
            while (r > 0) {
                r = read( i, buf, z );
                if (r > 0) {
                        w = write( o, buf, r );
                        k += r;
                        if (w < 1) {
                            dvrlog( LOG_INFO, "%s can't write %s", WHO, no);
                            e = -1;
                            break;
                        }

                        if (w != r) {
                                dvrlog( LOG_INFO, "%s wrote %d of %d to %s",
                                        WHO, w, r, no);
                                e = -1;
                                break;
                        }

                        if (r != z) {
                                advrlog( LOG_INFO, "%s EOF %s", WHO, ni);
                                break;
                        }
                }

                if (r < 0) {
                        dvrlog( LOG_INFO, "%s can't read %s", WHO, no);
                        e = -1;
                        break;
                }
            }
            close( i );
            fsync( o );
            close( o );

/* Change file permissions after close to match original mode then set
    mtime after chmod. This prevents guide from reloading every time it
    restarts with recent EPGs, and keeps auto-EPG reload on 3hr meridian.

   NOTE: It is not expected that you will have to restart it very often.
    This is mostly to make it easier if you're trying to add new features.
    The wait for guide load can be very annoying after a few dozen times. :>
*/
            chmod( no, upm );
            utime( no, &ut );
        }

/* don't forget to free what glob allocated */
        if (0 != g) globfree( &globt );

        return e;
}

/* see if this instance d is already running in /proc/ */
/* test luser calls to prevent starting another instance */
/* build snav_html calls to find other running servers */
/* returns 0 if not found, -1 if found */
/* static */
int
test_var_procpid( int d, int v )
{
        FILE *f;
        char n[64], s[1024];
        int p;

        snprintf(n, sizeof(n), "/var/run/%s/%s%d.pid", NAME, NAME, d);
        f = fopen(n, "r");

        if ((0 != v) && (NULL != f))
                fprintf( stderr, "fopen %p %s\n", f, n);

/* var pid file found */
        if (NULL == f) return 0;
        fscanf(f, "%d", &p);
        fclose(f);
        snprintf(n, sizeof(n), "/proc/%d/cmdline", p);
        f = fopen(n, "r");
        if (0 != v) fprintf( stderr, "fopen %p %s\n", f, n);

/* var pid file found but no matching cmdline */
        if (NULL == f) return 0;
        fread(s, sizeof(s), 1, f);
        fclose(f);
        s[sizeof(s)-1] = 0;
        if (0 != v) fprintf( stderr, "checking %s for %s\n", s, NAME);

/* command line has name */
        if (NULL != strstr(s, NAME)) return -1;

/* no match */
        return 0;
}


/* version that doesn't use system() */
/* static */
void
save_tmpfs ( char *caller )
{
        char s[512], d[512], r[512], o[1024];
        int rc;

        if (0 == arg_tmpfs) return;
        dvrlog( LOG_INFO, "%s %s", caller, WHO );

        snprintf( r, sizeof(r), "%s%s", out_path, ram_path);

/* destination is /etc/atscap/ usually */
        snprintf( d, sizeof(d), "/etc/%s/", NAME);

/* source is /dtv/ram/atscap[0-3].conf */
        snprintf( s, sizeof(s), "%s%s%d.conf", r, NAME, arg_devnum);
        rc = filecopy( d, s, 0 );

/* source is /dtv/ram/atscap[0-3].tsid,[vsb/qam] */
        snprintf( s, sizeof(s), "%s%s%d.tsid.%s", r, NAME, arg_devnum,
                    (0 == arg_cable)?"vsb":"qam" );
        rc = filecopy( d, s, 0 );

/* if you stop multiple instances, only instance 0 writes these files */
        if (0 == arg_devnum) {
                snprintf( s, sizeof(s), "%s%s.spam", r, NAME);
                rc = filecopy( d, s, 0 );
                
/* copy back possibly modified hosts.allow to /etc/hosts.allow */
// no: luser may not have permission for that
//              snprintf( s, sizeof(s), "%shosts.allow", r );
//              strcpy( d, "/etc/" );
//              rc = filecopy( d, s, 0 );

/* copy .epg and .vc files from ram/pg/ to /dtv/pg/, if any exist */
                snprintf( d, sizeof(d), "%spg/", out_path);
                snprintf( s, sizeof(s), "%spg/*.epg", r );
                rc = filecopy( d, s, 0 );
                snprintf( s, sizeof(s), "%spg/*.vc", r);
                rc = filecopy( d, s, 0 );

        }

/* append /dtv/ram/atscap#.log to /dtv/atscap#.log */
        snprintf( s, sizeof(s), "%s%s%d.log", r, NAME, arg_devnum );
        snprintf( d, sizeof(d), "%s%s%d.log", out_path, NAME, arg_devnum);

/* FIXME: append has bugs that make it go crazy on control C early during init
        rc = filecopy(d, s, 1); // append flag set for atscap#.log file
*/
        snprintf( o, sizeof(o), "cat %s >>%s", s, d);
        system( o );

/* remove ram log to avoid appending duplicate data */
        snprintf( s, sizeof(s), "%s%s%d.log", r, NAME, arg_devnum);
        remove( s );
}

/* Called after initial test config, scan_list[] populated to scan_idx
    This sets the ram path and copies config, epg and images to ram path.
 */
/* static */
void
load_tmpfs ( void )
{
        char s[512], d[512], r[512];
        int rc;

        if (0 == arg_tmpfs) return;
        advrlog( LOG_INFO, "%s", WHO );

/* tell everything else where the ram directory is */
        snprintf( r, sizeof(r), "%s%s", out_path, ram_path );
        snprintf( cfg_path, sizeof(cfg_path), "%s", r );
        snprintf( log_path, sizeof(log_path), "%s", r );
        advrlog( LOG_INFO, "cfg %s log %s", cfg_path, log_path );

/* all instances copy the config file for the instance */
        snprintf( s, sizeof(s), "/etc/%s/%s%d.conf", NAME, NAME, arg_devnum);
        snprintf( d, sizeof(d), "%s", r );
        rc = filecopy( d, s, 0 );


/* should only be for -S: OR can rerun & find stations without restarting? */
        snprintf( s, sizeof(s), "/etc/%s/%s%d.tsid.%s",
                        NAME, NAME, arg_devnum, (0 == arg_cable)?"vsb":"qam");
        rc = filecopy( d, s, 0 );

/* if multiple instances, only first one copies these files */
        if (0 == arg_devnum) {
                snprintf( s, sizeof(s), "/etc/%s/%s.spam", NAME, NAME);
                rc = filecopy( d, s, 0 );

/* copy /etc/hosts.allow */
                snprintf( s, sizeof(s), "/etc/hosts.allow");
                rc = filecopy( d, s, 0 );

                snprintf( d, sizeof(d), "%spg/", r);
                mkdir( d, 0777 );
                snprintf( s, sizeof(s), "%spg/*.epg", out_path);
                rc = filecopy( d, s, 0 );

                snprintf( s, sizeof(s), "%spg/*.vc",  out_path);
                rc = filecopy( d, s, 0 );

                snprintf( d, sizeof(d), "%spg/img/", r);
                mkdir( d, 0777 );
                snprintf( s, sizeof(s), "%spg/img/*.png", out_path );
                rc = filecopy( d, s, 0 );

                snprintf( s, sizeof(s), "%spg/img/*.css", out_path );
                rc = filecopy( d, s, 0 );
        }

}

#ifdef USE_SIGNALS
/* Dump backtrace to file and to stderr after clearing screen */
/* Check ALL pointers before output in case it's toast. */
/* NOTE: It should be pointed out that this is a Bad Idea. */
#ifdef USE_GNU_BACKTRACE_SCRIPT
#warning using GNU backtrace() script
/* static */
void
dump_backtrace( char **bts, size_t z, void *addr )
{
        FILE *f;
        char a[128+3]; /* address, up to 64 bits, plus 3 for 0x and nul */
        char o[256]; /* dump output name */
        char t[256]; /* temp copy of backtrace string */
        char n[256]; /* app or lib name */
        char s[256]; /* source function after address + name extract */
        char *p, *r;
        size_t y;
        unsigned int i;
        char has_name, has_addr, has_func;

        if (0 == z) return;
        if (NULL == bts) return;

        has_name = has_addr = has_func = 0;

/* Crash log script is /dtv/atscap#-pid.sh, calling addr2line for line numbers.
    NOTE: This only works if crash log matches current version compiled.
*/
        snprintf( o, sizeof(o), "%s%s%d-%d.sh",
                  out_path, NAME, arg_devnum,  (int)pid_m);

        f = fopen( o, "wb");

/* make .sh executable to call addr2line.sh to help debug */
        if (NULL != f) chmod( o, 0755 );

        if (NULL != f) {
            fprintf( f, "# %s\n", o);
            fprintf( f, "echo %s%d-%s SIG%s at address %p on %s.\n",
                        NAME, arg_devnum, VERSION,
                        sig_text[sig_val], addr, date_now );
            fprintf( f, "# addr2line helps find backtrace() line number.\n");
            fprintf( f, "# Comments below are strings from backtrace().\n");
            fprintf( f, "# Only %s lines are used for line numbers.\n", NAME);
            fprintf( f, "# Found %d stack frames.\n", z);
            fprintf( f, "#\n");

/* start at 1, because 0 is always signal_handler */
            for (y = 1; y < z; y++) {
                i = 0;

/* zero strings */
                memset( t, 0, sizeof(t) );
                memset( s, 0, sizeof(s) );
                memset( n, 0, sizeof(n) );
                memset( a, 0, sizeof(a) );

/* copy backtrace string for editing, first time */
                astrncpy( t, bts[ y ], sizeof(t) );

                if ( '[' != *t) has_name = ~0;

/* has name ? */
                if (0 != has_name) {
                    astrncpy( n, bts[ y ], sizeof(n));
                    if (NULL != strstr( n, NAME )) {
                        strcpy( n, NAME );
                    }
/* remove anything after name, work backwards from [ ( and blank */
                    p = strchr( n, '[' );               /* remove addr */
                    if (NULL != p) *p = 0;
                    p = strchr( n, '(' );               /* remove func */
                    if (NULL != p) *p = 0;
                    p = strchr( n, ' ' );               /* remove blank */
                    if (NULL != p) *p = 0;
                }

/* copy backtrace string for editing, again */
                astrncpy( t, bts[ y ], sizeof(t) );
                p = strchr( t, '[' );
                if (NULL != p) has_addr = ~0;

/* has address? */
                if (0 != has_addr) {
                    p = strchr( t, '[' );               /* point to addr */
                    if (NULL != p) {
                        p++;
                        sscanf( p, "%x", &i );          /* get addr */

/* convert all hexadecimal displays to upper case */
                        snprintf( a, sizeof(a), "0x%08X", i);
                    }
                }

/* copy backtrace string for editing, again */
                astrncpy( t, bts[ y ], sizeof(t) );
                p = strchr( t, '(' );
                if (NULL != p) has_func = ~0;

                *s = 0;

/* has function? */
                if (0 != has_func) {
                    p = strchr( t, '(' );
                    if (NULL != p) {
                        p++;
                        r = strchr( p, ')' );
                        if (NULL != r) {
                            *r = 0;
                            astrncpy( s, p, sizeof(s) );
                        }
                    }
                }

/* atscap default install location */
#define USE_PREFIX_BIN "/usr/local/bin/"

/* if file open */
                if (NULL != f) {
                    fprintf( f, "# %s\n", bts[ y ] );
                    if (0 != *n) {
                        if ( '/' != *n) 
                            fprintf( f, "addr2line -s -f -e %s%s %s # %s\n",
                                USE_PREFIX_BIN, n, a, s );
                    }
                }

            }
            if (NULL != f) fprintf( f, "# EOF\n");
        }

        if (NULL != f) fclose(f);

/* let user know it's all bad */
        fprintf( stdout, "Running %s to get backtrace lines:\n\n", o);
        fflush( stdout );

        nanosleep( &console_read_sleep, NULL );
        console_reset();
        console_reset();
        system( o );
        free( bts );
        exit( 252 );
        fprintf( stdout, "\n");
}
#endif

/* See http://www.linuxjournal.com/article/6391 Listing 3. */
/* NOTE: stack crashes will prevent most of this from working right,
    but simpler errors like NULL pointers may be more easily found.
*/
/* static */
void
/* signal_handler ( int sigval ) */ /* old style */
signal_handler( int sigval, siginfo_t *info, void *secret )
{
#ifdef USE_GNU_BACKTRACE
        void *bt[BTZ];
        size_t z;
        char t[256];
        int f;
#ifdef USE_GNU_BACKTRACE_SCRIPT
        char **bts = (char **) NULL;
#endif
#endif
        ucontext_t *uc;
        void *addr;
        char n[256];

//      return;

        *n = 0;

        addr = NULL;

/* EIP only works with GNU/Linux on intel/amd x86 32-bit arch */
#if defined(REG_EIP)
#warning using x86 arch uc_mcontext.gregs REG_EIP
        uc = (ucontext_t *)secret;
        addr = (void *) uc->uc_mcontext.gregs[ REG_EIP ];
#endif
/* RIP only works with GNU/Linux on intel/amd x86_64 64-bit arch */
#if defined(REG_RIP)
#warning using x86_64 arch uc_mcontext.gregs REG_RIP
        uc = (ucontext_t *)secret;
        addr = (void *) uc->uc_mcontext.gregs[ REG_RIP ];
#endif

        sig_val = sigval; /* save signal for exit processing */

        switch (sig_val)
        {

/* ignore sigpipe, is likely to be web server aborted connection */
            case SIGPIPE:
                return;
                break;

/* only sets flag for signal test called from console scan */
            case SIGWINCH:
                return;
                break;
            case SIGTERM:
                return;
                break;
            case SIGQUIT:
                return;
                break;
            case SIGINT:
                return;
                break;

#ifdef USE_GNU_BACKTRACE
            case SIGUSR1:
                z = backtrace( bt, BTZ);
                if (0 == z) break;

/* addr will be arch dependent on x86 and derivatives with newer GCC only */
                bt[2] = addr;

                snprintf( n, sizeof(n), "%s%s%d-%d.bt",
                          out_path, NAME, arg_devnum, pid_m);
                snprintf( t, sizeof(t),
                        "# %s%d-%s SIG%s at addr %p pid %d tid %d (%d) on %s\n\n",
                        NAME, arg_devnum, VERSION,
                        sig_text[sig_val], addr, pid_m,
                        (int) pthread_self(),
                        0x3FFF & (int) pthread_self(),  /* ignore if NPTL */
                        date_now );

                f = open( n, O_RDWR | O_CREAT, 0644 );

                if (f > 2) {
                    write( f, t, strlen(t) );

/* use btfd.sh to extract line numbers */
                    backtrace_symbols_fd( bt, z, f );
                    fsync( f );
                    close( f );
                }
                return;
                break;
#endif
        
/* fatal errors */
            case SIGSEGV:
            case SIGILL:
            case SIGFPE:
            case SIGBUS:
            case SIGIOT:

#ifdef USE_GNU_BACKTRACE
/* if backtrace or backtrace_symbols fail, give some exit indication */
                z = backtrace( bt, BTZ);
                if (0 == z) {
                    fprintf( stderr, CLS BN SCV
                             "Fatal error at addr %p, no backtrace.\n", addr );
                    console_reset();
                    console_reset();
                    exit(254);
                }
        
/* This is typical place where stack trace goes wrong, for pthreads. All
    examples of how to use have bt[1] instead, but are not pthread apps.
*/
                bt[2] = addr;
                
#ifdef USE_GNU_BACKTRACE_SCRIPT
/* Save backtrace to addr2line script. Is problematic if stack is crashed. */
                bts = backtrace_symbols( bt, z );
                if (NULL == bts) {
                    fprintf( stderr, CLS BN SCV
                             "Fatal error at addr %p, no backtrace.\n", addr );
                    console_reset();
                    console_reset();
                    exit(255);
                }

/* If you're here, it must have crashed. LET ME KNOW or send me a patch.  */
/* It logs what can be logged about crash. addr2line will help, somewhat. */
                fprintf( stderr, CLS SCV BN );
#if 0
                fprintf( stderr, "%s%d-%s SIG%s at addr %p on %s.\n",
                        NAME, arg_devnum, VERSION,
                        sig_text[sig_val], addr, date_now );
#endif

                dump_backtrace( bts, z, addr ); /* does not return, exit252 */
#else
/* Save backtrace to file instead. Is problematic if stack is crashed. */
/*      snprintf( n, sizeof(n), "%s%s-%d.bt", out_path, NAME, pid_m ); */
                snprintf( n, sizeof(n), "%s%s%d-%d.bt",
                            out_path, NAME, arg_devnum, getpid());
                snprintf( t, sizeof(t),
                        "# %s%d-%s SIG%s pid %d tid %d (%d) on %s\n",
                        NAME, arg_devnum, VERSION,
                        sig_text[sig_val], pid_m,
                        (int) pthread_self(),
                        0x3FFF & (int) pthread_self(), /* ignore if NPTL */
                        date_now );

                f = open( n, O_RDWR | O_CREAT | O_TRUNC, 0644 );
                if (f > 2) {
                    write( f, t, strlen(t) );
                    backtrace_symbols_fd( bt, z, f );
                    fsync(f);
                    close(f);
                }

/* USE_GNU_BACKTRACE_SCRIPT */
#endif
/* USE_GNU_BACKTRACE */

/* NOTE: if stack is crashed, these won't help and may make it worse */
                fprintf( stderr, CLS SCV BN 
                        "%s%d-%s SIG%s at addr %p on %s.\n",
                        NAME, arg_devnum, VERSION,
                        sig_text[sig_val], addr, date_now );

                fprintf( stderr, "Run btfd.sh <%s for stack trace.\n\n", n);
#endif
                dvrlog( LOG_INFO, "SIG%s at addr %p\n",
                         sig_text[sig_val], addr );
                fflush( dvrlog_fd );
                fclose( dvrlog_fd );

                pid_i = 0;
                pid_o = 0;
                console_reset();
                console_reset();
                exit(253);
                break;

/* the rest get logged */
            default:
                if (sig_val < 32) {
                    dvrlog( LOG_INFO, "%s %s(%d) tid %d ignored",
                        WHO, sig_text[ sig_val ], sigval, getpid() );
                } else {
                    dvrlog( LOG_INFO, "%s %d", WHO, sig_val);
                }
                break;
        }

        fprintf( stderr, CLS SCV BN
                    "%s%d-%s unhandled SIG%s at addr %p\n\n",
                    NAME, arg_devnum, VERSION, sig_text[sig_val], addr);
        console_reset();
        console_reset();
        exit( sig_val );
}

/* global signal init. got rid of -ansi -pedantic porting errors */
/* static */
void
signal_init ( void )
{
        struct sigaction act;

/*      act.sa_handler = signal_handler;  */
/* old style doesn't give EIP */
        
/* sigemptyset is required */
        sigemptyset( &act.sa_mask);
        act.sa_flags = SA_RESTART | SA_SIGINFO;
        act.sa_sigaction = signal_handler;

/* signals quit and term can be used to terminate it gracefully */
        sigaction( SIGQUIT, &act, NULL );
        sigaction( SIGTERM, &act, NULL );

/* control c will terminate it gracefully if not capturing */
        sigaction( SIGINT, &act, NULL );

/*      act.sa_handler = SIG_IGN;  */

/* console resize, using something else */
        sigaction( SIGWINCH, &act, NULL );

/* HTTP remote closed connection is usual cause of this.
   Example: refresh the page before it's done loading.
*/
        sigaction( SIGPIPE, &act, NULL );

/* these are all fatal */
        sigaction( SIGSEGV, &act, NULL );
        sigaction( SIGILL, &act, NULL );
        sigaction( SIGFPE, &act, NULL );
        sigaction( SIGBUS, &act, NULL );
        sigaction( SIGIOT, &act, NULL );

/* SIGUSR1 will dump a backtrace log of current threads */
        sigaction( SIGUSR1, &act, NULL );
}


/* SIGINT enable 1, disable 0 */
/* static */
void
sigint_set ( int s )
{
        struct sigaction act;

/* sigemptyset is required */
        sigemptyset( &act.sa_mask );
        act.sa_flags = SA_RESTART;
        act.sa_handler = SIG_IGN; 

/*      if (0 != s) act.sa_handler = signal_handler;  */ /* old style */
        if (0 != s) act.sa_sigaction = signal_handler; 

        sigaction( SIGINT, &act, NULL );
}

/* USE_SIGNALS */
#endif


#ifndef aprintf
/* insert delays each time it is called for debugging ui */
/* static */
void
aprintf ( FILE *f, const char *fmt, ... )
{
        char t[1024];
        struct timespec print_sleep = {0,100000000};

        va_list ap;

        if ((arg_detach != 0) || (arg_quiet != 0)) return;
        memset(t, 0, sizeof(t));
        va_start(ap, fmt);

/* variable arg macro start, pass fmt and ap, variable arg macro end */
        vsnprintf( t, sizeof(t)-1, fmt, ap );
        va_end(ap);
        fprintf( f, "%s", t);
        nanosleep( &print_sleep, NULL );
}
#endif


/* functions to track malloc, calloc and free usage */

/* unused compiler error avoid */
/* static */
void *
imalloc ( size_t z, char *id )
{
        void *p;
        int i;

        for (i = 0; i < ALLOC_LIMIT; i++)
                if (NULL == alloc_list[i].p)
                        break;

        if (ALLOC_LIMIT == i) {
                fprintf(stderr, CLS "malloc %s %d failed: alloc limit\n", id, z);
                exit(1);
                return NULL;
        }

        p = malloc( z );
        if (NULL == p) {
                fprintf(stderr, CLS "malloc %s %d failed\n", id, z);
                exit(1);
        }

        alloc_list[ i ].p = p;
        alloc_list[ i ].z = z;
        astrncpy( alloc_list[ i ].n, id, ALLOC_CHARS);
        return p;
}

/* static */
void *
icalloc ( size_t n, size_t z, char *id )
{
        void *p;
        int i;

        for (i = 0; i < ALLOC_LIMIT; i++)
                if (NULL == alloc_list[i].p)
                        break;

        if (ALLOC_LIMIT == i) {
                fprintf(stderr, CLS "calloc %s %d failed: alloc limit\n", id, z);
                exit(1);
                return NULL;
        }
    
        p = calloc( n, z );
        if (NULL == p) {
                fprintf(stderr, CLS "calloc %s %d failed\n", id, z);
                exit(1);
        }
        alloc_list[ i ].p = p;
        alloc_list[ i ].z = z * n;
        astrncpy( alloc_list[ i ].n, id, ALLOC_CHARS );
        return p;
}

/* incremental realloc, does not shrink only expands */
/* this behaviour is different from normal realloc which sets z size */
/* static */
void *
irealloc( void *p, int z, char *id )
{
        int i;

        if (NULL == p) return NULL;
        if (0 == z) return p;

        for (i = 0; i < ALLOC_LIMIT; i++)
                if (p == alloc_list[i].p)
                        break;

        if (ALLOC_LIMIT == i) {
                fprintf( stderr, CLS
                        "irealloc %p %d not found for %s\n", p, z, id);
                exit(1);
        }

        astrncpy( alloc_list[i].n, id, ALLOC_CHARS );

        alloc_list[i].z += z;
        alloc_list[i].p = realloc( p, z );

        if (NULL == alloc_list[i].p) {
                fprintf( stderr, CLS
                        "irealloc failed for %s %p %d\n", id, p, z);
                exit(1);
        }

        return alloc_list[i].p;
}

/* static */
void
ifree ( void *p, char *n )
{
        int i;

        if (NULL == p) {
                fprintf( stderr, CLS "ifree can not free NULL pointer %s\n",n);
                exit(1);
                return;
        }

        for ( i = 0; i < ALLOC_LIMIT; i++ )
                if ( p == alloc_list[ i ].p )
                    break;

        if (ALLOC_LIMIT == i) {
                fprintf(stderr, CLS "ifree can not find pointer %s %p\n", n, p);
                exit(1);
                return;
        }

/* found a match? */
        free( p );
        memset( alloc_list[i].n, 0, ALLOC_CHARS );
        alloc_list[i].p = NULL;
        alloc_list[i].z = 0;
}

static
void
init_allocs( void )
{
        int i;

        for (i = 0; i < ALLOC_LIMIT; i++) {
                memset( alloc_list[i].n, 0, ALLOC_CHARS );
                alloc_list[i].p = NULL;
                alloc_list[i].z = 0;
        }

/* static spam list clear */
        memset( spam_list, 0, sizeof(spam_list));
}

/* long long to ascii comma delimited to make big numbers easier to read.
    Assumes dest has enough bytes for result (19 digits + 6 commas + nul).
    Largest number is around +/- 9,000,000,000,000,000,000 (quintillion).

    PROOF:

    value       sl              dest            dl      dl computation

    1           1               1               1       (0 * 4) + 1 = 1
    10          2               10              2       (0 * 4) + 2 = 2
    100         3               100             3       (1 * 4) - 1 = 3
    1000        4               1,000           5       (1 * 4) + 1 = 5
    10000       5               10,000          6       (1 * 4) + 2 = 6
    100000      6               100,000         7       (2 * 4) - 1 = 7
    1000000     7               1,000,000       9       (2 * 4) + 1 = 9
    10000000    8               10,000,000      10      (2 * 4) + 2 = 10
    100000000   9               100,000,000     11      (3 * 4) - 1 = 11
    1000000000  10              1,000,000,000   13      (3 * 4) + 1 = 13

    NOTE: atoll() breaks after 2^30 on 32-bit with some older compilers.
        Auto-verification using atoll on char c[] doesn't always work.
        This function also depends on snprintf getting it right.

    10000000000 11              10,000,000,000  14      (3 * 4) + 2 = 14
*/
#define COMMA_MAX 32

/* static */
void
lltoasc ( char *dest, long long value )
{
        char *s, *b, *d;                /* source and bottom boundary for d */
        int i, k, sl, dl;               /* loops, source len, destination len */
        char c[COMMA_MAX];              /* value in ascii */

        d = dest;

/* Don't want the sign confusing the comma calculation so fix it here. */
        if ( value < 0LL ) {
//              value ^= -1LL;                  /* one */
//              value++;                        /* way */ 
                value = 0LL - value;            /* or another */
/* if still negative, it is largest negative and will not complement. */
                if (value >= 0LL) *d++ = '-';
        }

        snprintf( c, COMMA_MAX, "%lld", value );

        if (value > 999LL) {                    /* commas needed ? */
                b = d;                          /* save stop pointer */
                sl = strlen( c );               /* src len */
                dl = ((sl / 3) * 4) + (sl % 3); /* dest len */
                if ( 0 == ( sl % 3)) dl--;      /* fixup for last , */

                d[dl] = 0;                      /* NUL term */
                dl--;                           /* and back up */

                if ( dl < COMMA_MAX ) {         /* will added commas fit? */

/* copy bytes from s to d in reverse order, adding , to d every 3 bytes */

                        k = sl - 1;             /* loop limit */
                        s = c + k;              /* point: 1's place end of c */
                        d += dl;                /* point: computed end of d */
        
                        for ( i = sl; i > 0; ) {
                            if ( (d < b) || (s < c) ) break;    /* boundary */
                            i--;
                            *d-- = *s--;                /* copy & decrement */
                            if ( (d < b) || (s < c) ) break;    /* boundary */

                            if (0 == ((sl-i) % 3)) *d-- = ',';
                            if (d < b) break;           /* boundary check */
                        }
                } else {
                        astrncpy( d, c, COMMA_MAX ); /* commas won't fit */
                }
        } else {
                astrncpy( d, c, COMMA_MAX );    /* no commas needed */
        }
        return;
}

/* ascii binary to unsigned */
/* NOTE: this is where weekday bits get reversed */
/* static */
unsigned int
abtou ( char *p )
{
        unsigned int i = 0;
        unsigned int b = 0;
    
        if (p == NULL) return 0;
        b = strlen(p);

/* return if nothing to do */
        if (b == 0) return 0;

/* nl removal and return if nothing to do */
        if (p[b-1] == 10) p[b-1] = 0;
        b = strlen(p);
        if (b == 0) return 0;

        while (*p) i |= ( *p++ & 1 ) << --b;
        return i;
}

/* unsigned to ascii binary,
   p is output, b is number of bits, i is value
*/
/* static */
void
utoab ( char *p, unsigned int b, unsigned int i )
{
        unsigned int j = b;
    
        while (j > 0)
                *p++ = 48 + ( (i & 1<<--j) ? 1:0 );

        *p = 0; /* null term string */
}


#ifdef USE_WWW
/* FIXME: should not include port. adjust size back to 16 after port remove */
/* static */
void
uintodot( char *d, unsigned int s )
{
        if (NULL == d) return;
        snprintf( d, 22, "%d.%d.%d.%d:%d",
                0xFF & (s>>24),
                0xFF & (s>>16),
                0xFF & (s>>8),
                0xFF & s,
                0xFFFF & arg_wport );
}

/* returns 0 if address was good */
/* static */
int
dotouint ( unsigned int *d, char *p )
{
        unsigned int ok;
        char *p0, *p1, *p2, *p3;
        int a0, a1, a2, a3;
        char s[256];

        memset( s, 0, sizeof(s) );
        astrncpy( s, p, sizeof(s) );
        ok = ~0;
        if (NULL == s) return -1;
        if (NULL == d) return -1;

        p0 = p1 = p2 = p3 = "";
        p0 = s;
        p1 = strchr( p0, '.' );
        if (NULL != p1) {
                *p1 = 0;
                p1++;
                p2 = strchr( p1, '.');
                if (NULL != p2) {
                        *p2 = 0;
                        p2++;
                        p3 = strchr( p2, '.');
                        if (NULL != p3) {
                                *p3 = 0;
                                p3++;
                                ok = 0;
                        }
                }
        }

        if (0 != ok) return ok;

        *d = 0;
        a0 = atoi( p0 );
        if ((a0 < 0) || (a0 > 255)) return -1;

        a1 = atoi( p1 );
        if ((a1 < 0) || (a1 > 255)) return -1;

        a2 = atoi( p2 );
        if ((a2 < 0) || (a2 > 255)) return -1;

        a3 = atoi( p3 );
        if ((a3 < 0) || (a3 > 255)) return -1;
    
        *d |= a0 << 24;
        *d |= a1 << 16;
        *d |= a2 << 8;
        *d |= a3;
        return 0;
}
#endif

#if 0
/* event truncate isn't doing this right for some reason, but filesystem is
   storing the characters illegibly even if it does match a compare.
*/   

*/
/* Similar to isalnum, but considers chars over 128 to be alpha. */
/* Like isalnum, return non-zer if falls into tested class, zero if not. */
/* This may generate filenames that are difficult to handle from console. */
/* static */
int
isalnum2 ( int c )
{
        if ( ((c >= '1') && (c <= '9'))
         ||  ((c >= 'A') && (c <= 'Z'))
         ||  ((c >= 'a') && (c <= 'z'))
         ||  (c >= 128) ) return ~0;
         return 0;
}
#endif

/* static */
unsigned char
ahex2u( char *p )
{
        unsigned char c, c1, c2;
        c = 0;
        c1 = p[0];
        c2 = p[1];

        if ( (c1 >= 'a') && (c1 <= 'f') ) c1 = 10 + c1 - 'a';
        if ( (c1 >= 'A') && (c1 <= 'F') ) c1 = 10 + c1 - 'A';
        if ( (c1 >= '0') && (c1 <= '9') ) c1 -= '0';

        if ( (c2 >= 'a') && (c2 <= 'f') ) c2 = 10 + c2 - 'a';
        if ( (c2 >= 'A') && (c2 <= 'F') ) c2 = 10 + c2 - 'A';
        if ( (c2 >= '0') && (c2 <= '9') ) c2 -= '0';

        c1 &= 0x0F;
        c2 &= 0x0F;

        c = (c1 << 4) | c2;
        return c;
}

/* build a list of cgi form pointers up to n pointers from string s */
/* s is modified */
/* static */
void
build_form_args( char **p, int n, char *s )
{
        int i;
        char *r, *t;

        for (i = 0; i < n; i++) p[i] = NULL;

        r = s;

/* point to everything following ='s and remove trailing & */
        for (i = 0; i < n; i++) {
                t = strchr( r, '=' );
                if (NULL == t) break;
                t++;
                p[i] = t;
                t = strchr( p[i], '&' );
                if (NULL == t) break;
                *t = 0;
                t++;
                r = t;
        }
}

/* build a list of pointers up to n pointers from string s using delim c */
/* s is modified with NUL terms replacing each delim c */
/* static */
int
build_args( char **p, int n, char *s, char c, char *caller )
{
        int i, j;
        char *r, *t;

        advrlog( LOG_INFO, "%s %s %s", caller, WHO, s);

        for (i = 0; i < n; i++) p[i] = NULL;

        r = s;

        j = 0;
        for (i = 0; i < n; i++) {
                if (0 == *r) break;
                p[i] = r;
                j++;
                t = strchr( r, c );
/* end of list? */
                if (NULL == t) break;
                *t = 0;
                t++;
                r = t;
        }
        return j;
}


/*
 This is called by show clock to set the current time in the program.
 It can be called from other places, for slightly more exact time.
 */
/* static */
void
get_time ( void )
{
        tnow = time( NULL );
        localtime_r( &tnow, &tloc );
        utsnow = (int)tnow;
        utsday = (tloc.tm_hour * SECHR) + (tloc.tm_min * 60) + (tloc.tm_sec);
        utsmid = utsnow - utsday;

/* NOTE: make sure date_now is at least 24 bytes */
        asctime_r( &tloc, date_now );

/* truncate before year */
        date_now[19] = 0;
        utswday = tloc.tm_wday;
}

/* test epgs calls this to figure out when to reload the next EPG.
    Return is staggered 5m by device number starting at 5m after meridian.
*/
int
get_next_meridian( void )
{
        int f, l, m;
        f = l = m = 0;
        get_time();
/* failsafe value is next 3hr meridian */
        m = utsnow + 10799;

/* convert to earliest 3hr meridian */
        m /= SEC3HR;
        m *= SEC3HR;

/* it should already be ahead, correct it if not */
        if (m <= utsnow) m += SEC3HR;

/* stagger by 5m so all 4 instances don't hammer the cpu at once */
        m += 300 + (arg_devnum * 300);

/* stagger cable instances another 5m so they fetch a good epg */
        if (0 != arg_cable) m += 300;
        return m;
}

/* tt is int representation of time_t */
/* d should be 32 bytes, trun should be less than 31 for nul term */
/* static */
void
text_time ( char *d, int tt, int trun ) {
        struct tm taloc;
        time_t tany;

        tany = (time_t)tt;
        localtime_r( &tany, &taloc);
        asctime_r( &taloc, d );

        if (trun < strlen(d)) d[trun] = 0;
}

/* find the most accurate clock and set clock_method global */
/* static */
void
test_clock_res ( void )
{
        struct timespec res;
        int i, j;
        long long r, s;

        j = -1;
        r = 1000000000LL; /* worst case scenario is 1 clock per second */

        for (i = 0; i < RTC_MAX; i++) {

/* is clock res return valid? */
            if (0 == clock_getres( clock_ids[i], &res)) {
                s = res.tv_sec;
                s <<= 32;
/*
                s <<= 16;
                s <<= 16;
*/
                s |= res.tv_nsec;

/* is clock res non-zero? */
                if (0LL != s)
                    if (s < r) {
                        j = i;
                        r = s;
                    }
            }
        }
    
        if (-1 == j) {
            dvrlog( LOG_INFO, "%s has no clock method? check librt", NAME);
            fprintf(stderr, CLS "%s has no clock method? check librt\n", NAME);
            exit(1);
        }

/* use last lowest value in l for the syslog */
        clock_method = clock_ids[j];
        clock_idx = j;
        clock_res = r;
}

/* want this done after banner */
/* static */
void
log_clock_res ( void )
{
        long long r;
        char *s, *t;

        r = clock_res;
        t = clock_text[clock_idx];
/* scale */
        s = "ns";
        if (r > 1000) { s = "us"; r /= 1000; };
        if (r > 1000) { s = "ms"; r /= 1000; };
        if (r > 1000) { s = "s";  r /= 1000; }; /* very slow clock */
        advrlog( LOG_INFO, "using CLOCK_%s %lld %s", t, r, s );
}

/* RRT version reset */
/* static */
void
init_rrt( struct payload_s *p )
{
        p->vn = 0xFF;
}

/* clears entries in mg* */
/* static */
void
reset_mg( void )
{
        memset( mg, 0xFF, sizeof( mg ) );
        memset( mgp, 0xFF, sizeof( mgp ) );
        memset( mgs, 0xFF, sizeof( mgs ) );
}

/* clear all entries in mg* and resets version number */
/* static */
void
init_mg ( void )
{
        memset( mgt_text,  0, sizeof( mgt_text ));

/* TESTME: dont wipe MGT:
    version change overwrites rest with new info from mgt[].payload
 */
/* This breaks EPG. Not sure of the interaction. */
/*    memset( mgt, 0, sizeof( mgt ) ); */

/* overwrite the table lookups with invalid PID flag */
        mgt_vn = 0xFF;
        mg_idx = 0;
        utsmgt = 0;
        init_rrt( &rrt );
        reset_mg();
}

/* static */
void
init_pat_pmt( struct payload_s *a, struct payload_s *m )
{
        int i;
        memset( pa,   0, sizeof( pa ));
        memset( m, 0, VCZ * sizeof( struct payload_s )); /* multi-vc */
        memset( a, 0, sizeof( struct payload_s ));
        a->vn = a->lv = 0xFF;

        for (i=0; i<VCZ; i++) pa[i].vn = 0xFF;
        pat_ncs = 0;
}


/* clear all virtual channel data and set version numbers to invalid */
/* static */
void
init_vct ( struct payload_s *v, char *caller )
{
        int i;
    
        advrlog( LOG_INFO, "%s <- %s", WHO, caller );
        memset( vc,   0, sizeof( vc  ));
        memset( tvct_text,  0, sizeof( tvct_text )); /* reset VCT guide text */
        memset( v, 0, sizeof( vct )); /* reset data buffers */
        v->vn = v->lv = 0xFF; /* set versions to invalid */

        for (i=0; i<VCZ; i++) vc[i].pmtvn = 0xFF;
    
        vc_ncs = vct_ncs = 0;   /* reset virtual channel counts */

        init_pat_pmt( &pat, pmt );
/*    pkt.tvct = pkt.pat = pkt.pmt = 0; / * reset packet counts */
}


/* clear epg and related */
/* static */
void
init_pgm ( void )
{
        int i;

        memset( &epg_locks, 0xFF, sizeof( epg_locks )); /* initially locked */
        memset( epg,    0, sizeof( epg ) );     /* wipe program guide */
        memset( pg,  0xFF, sizeof( pg  ) );     /* wipe program guide index */

        pgm.idx = 0;                    /* reset program guide counts */
        pgm.idt = 0;
        pgm.ett = 0;

        for (i=0;i<PGZ;i++) {   /* reset numbers and version numbers */
            epg[i].eitn = epg[i].eitvn = epg[i].ettn = epg[i].ettvn = 0xFF;
        }
        eit_idx = 0;
        ett_idx = 0;
}

/* channel change resets pid totals for that channel */
/* static */
void
init_pids ( void )
{
        memset( pids, 0, sizeof(pids) );
}


/* ts capture loop calls this at start */
/* static */
void
init_stats ( struct sig_s *s )
{
/* clear packet stats */
        memset( &pkt, 0, sizeof( struct pkt_s ));
        memset( &s->pkt, 0, sizeof( struct pkt_s ));

/* clear continuity and error lookups, and table lookups */
        memset( last_cc,   0xFF, sizeof( last_cc   ));
        memset( cce_pids,     0, sizeof( cce_pids  ));
        memset( psi_pids,     0, sizeof( psi_pids  ));
}

/* clear atsc and related */
/* static */
void
reset_atsc ( void )
{
        int i;

        memset( &stt, 0, sizeof( stt ));
        memset( &rrt, 0, sizeof( rrt ));
        memset( &ctt, 0, sizeof( ctt ));

        memset( eit_vn, 0xFF, sizeof( eit_vn ) );

        ctt.payok = 1;
        stt.payok = 1;
        rrt.payok = 1;                  /* no payload yet */

        for (i=0; i < EIZ; i++) {
                eit[i].vn = 0xFF;       /* set version to invalid */
                ett[i].vn = 0xFF;
                eit[i].payok = 1;       /* no payload yet */
                ett[i].payok = 1;
        }

}

/* init ATSC structures */
/* static */
void
init_atsc ( void )
{
        size_t z, n;
        z = sizeof( struct payload_s );
        n = EIZ;

#ifdef USE_DYNAMIC
#warning using dynamic EIT & ETT allocation
        eit = icalloc( n, z, "EIT 00-7F" ); /* 4k * 128 Event Info Table */
        ett = icalloc( n, z, "ETT 00-7F" ); /* 4k * 128 Event Text Table */
#endif
/* clear the locks and data areas then set table version numbers invalid */
        reset_atsc();
}

/* Free the ATSC tables allocated above */
/* static */
void
free_atsc ( void )
{
#ifdef USE_DYNAMIC
#warning using dynamic EIT & ETT free
        if (NULL != eit)
                ifree( eit, "eit" );/* 4k * 128 Event Info Table */
        eit = NULL;

        if (NULL != ett)
                ifree( ett, "ett" );/* 4k * 128 Event Text Table */
        ett = NULL;
#endif
}

/* Frames and sequences are only allocated on single program capture. */
/* USE_DYNAMIC doesn't matter here. It's big. It should always be dynamic. */
/* static */
void
init_frames ( void )
{
#ifdef USE_DYNAMIC
#warning using dynamic frames[] & sequences[]
        if (0 == arg_frames) return;            /* not -m */
        if (CAP_INFO == cap_now) return;        /* not info cap */
        if (cap_pn < 1) return;                 /* not program cap */

        frames = icalloc( FRAME_MAX, sizeof( short ), "frames[]");
        if (NULL != frames) {
            advrlog( LOG_INFO, "icalloc %d frames",
                    FRAME_MAX * sizeof(short) );
        } else {
/* don't process frames if can't allocate space */
            advrlog( LOG_INFO, "%s failed frames calloc", WHO );
            cap_frames = 0;
        }

        sequences = icalloc( SEQUENCE_MAX, sizeof( int ), "sequences[]");
        if (NULL != sequences) {
            advrlog( LOG_INFO, "icalloc %d sequences", 
                    SEQUENCE_MAX * sizeof(int) );
        } else {
/* don't process sequences if can't allocate space */
            dvrlog( LOG_INFO, "%s failed sequences calloc", WHO );
            cap_frames = 0;
        }
#else
#warning using static frames[] & sequences[]
#endif

        frame_idx = 0;
        sequence_idx = 0;
}

/* Frames and sequences are only needed during capture. */
/* static */
void
free_frames ( void )
{
#ifdef USE_DYNAMIC
        if (NULL != sequences) ifree( sequences, "sequences" );
        sequences = NULL;
        if (NULL != frames) ifree( frames, "frames" );
        frames = NULL;
#endif
}

#if 0
/* This one presents a chicken-and-egg scenario with load config/epg
    because you want to run this before load config, but there is
    no channel list to provide a list of VC & EPG files to remove.
    Replacing make eclean with C code isn't so easy?
    Sure, could do system("rm *.vc *.epg") in out_path directory.
    but not much finesse in that now is there?
*/
/* static */
void
init_files ( void )
{
}
#endif

/*
 clear all the arrays
 set .vn in all the arrays to 255 to prevent version 0 = version 0 no update
*/
/* static */
void
init_arrays ( void )
{
        unsigned char *p;

/* erase pid list for this cap */
        memset( cap_pids, 0, sizeof(cap_pids) );
/* load the null packet */
        memset( nul_buf, 0xFF, sizeof(nul_buf) );
        p = nul_buf;
        *p++ = 0x47;
        *p++ = 0x1F;
        *p++ = 0xFF;
        *p++ = 0x10;

/* TESTME: here or init_mg? seems to break EPG if init_mg */
        memset( &mgt, 0, sizeof( mgt ) );
        init_mg(); /* see above */

/* TESTME: cable should keep using stored guide */
        if (0 == arg_cable) init_pgm();

        init_vct( &vct, WHO );

        init_pids();

/* reset frame counts */
        memset( pict, 0, sizeof(pict));
}



/************************************************************* ffmpeg CRC32 */
/* static */
unsigned int
calc_crc32 ( unsigned char *data, unsigned int len)
{
        unsigned int i;
        unsigned int crc = 0xffffffff;

        if (len > 4096) return ~0;

        for (i=0; i<len; i++)
                crc = (crc << 8) ^ crc_lut[ 0xFF & ((crc >> 24) ^ *data++) ];
        return crc;
}
/************************************************************* ffmpeg CRC32 */

#ifdef USE_MCAST

/************************************************************** UDP MULTICAST
  open socket, 0 if ok, not zero if not ok
 */
/* static */
int
udp_open_socket ( struct udp_s *u )
{
        int yes, no, ok;
        struct ip_mreq mca;
    
        yes = 1;
        no = 0;

/* open socket */
        u->sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
        if (u->sock < 0) {
                dvrlog( LOG_INFO, "socket open error");
                return 1;
        }

        /* set socket reusable (initiator of group has to do this) */
        ok = setsockopt( u->sock,
                        SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes) );
        if (0 != ok) { 
                dvrlog( LOG_INFO, "socket reuse error");
                return 2;
        }

/* set socket multicast loopback off (disables local listen) */
#ifdef MCAST_NOLOOP
        sok = setsockopt( u->sock,
                        IPPROTO_IP, IP_MULTICAST_LOOP, &no, sizeof(no) );
        if (0 != ok) { 
                dvrlog( LOG_INFO, "socket loop disable error");
                return 2;
        }
#endif

/* set socket to multicast address */
        memset( &mca, 0, sizeof( mca ) );
        mca.imr_multiaddr.s_addr = inet_addr( arg_mcaddr );

/* FIXME: multicast should bind to any, but change here if needed */
        mca.imr_interface.s_addr = htonl( INADDR_ANY );

        ok = setsockopt( u->sock,
                        IPPROTO_IP, IP_ADD_MEMBERSHIP, &mca, sizeof(mca) );
        if (0 != ok) {
                dvrlog( LOG_INFO, "socket mcast group error");
                return 3;
        }

/* bind socket */
        memset( &u->addr, 0, sizeof(struct sockaddr));
        u->addr.sin_family = AF_INET;
        u->addr.sin_addr.s_addr = inet_addr( arg_mcaddr );
        u->addr.sin_port = htons( arg_mcport );

        u->bind = bind( u->sock, (struct sockaddr *)&u->addr,
                         sizeof(struct sockaddr));

        if (0 != u->bind) { 
                dvrlog( LOG_INFO, "socket bind error");
                return 4;
        }

/* everything ok once it gets here */
        dvrlog( LOG_INFO, "UDP MCAST %s port %u",
                inet_ntoa( u->addr.sin_addr ),
                ntohs( u->addr.sin_port ) );
        return 0;
}

/************************************************************** UDP MULTICAST
  write a transport packet to a UDP multicast socket
 */
/* static */
int
udp_write_socket ( struct udp_s *u, unsigned char *p )
{
        int sendok = 0;

/* send what */
        sendok = sendto( u->sock, p, 188,
                    0, &u->addr,
                    sizeof(struct sockaddr) );
/* to who */
        return sendok;
}

/* static */
void
udp_close_socket ( struct udp_s *u )
{
        if (u->sock > 2) close( u->sock );
}
#endif


/*********************************************************** HUFFMAN DECODE
 It's a binary tree lookup for common letter combinations, used for
 EIT Event Title and ETT Event Description Text compression modes.
 *d destination, dlen destination max length,
 *s source, slen source length
 comp is 1 for title decode, 2 for description decode
 This was fun to write.
*/
/* static */
void
huffman_decode ( char *d, unsigned char *s,
                int dlen, int slen, int comp)
{
    unsigned char p, c, o, b, *co;
    unsigned int i, j, k, to, zo, z, *bo;

    /* sanity checks */
    if (NULL == d) return;
    *d = 0;                     /* NUL term the destination */

    if (NULL == s) return;      /* no nulls */
    if (comp < 1)  return;
    if (comp > 2)  return;      /* no bogus comp mode */
    if (dlen < 1)  return;
    if (slen < 1)  return;      /* no bogus len */

    p = c = o = 0;              /* first char assumed to be NUL or term char */
    bo = huffman1bo;            /* byte offset of char p tree root */
    co = huffman1co;            /* char p order-1 tree */
    z = TITLE_COZ;              /* default 1 is title/name decode */
    
/* otherwise 2 is extended text decode */
    if (comp == 2) {
        bo = huffman2bo;
        co = huffman2co;
        z = DESCR_COZ;
    }

/* should be pointing to correct tables now */
    for (i=0; i < (slen<<3); i++)
    {
        if (p > 127) { /* sanity check, don't stray outside table */
/* change to advrlog if it gets annoying */
            advrlog( LOG_INFO, "%s BAD Tree Offset %02X", WHO, p);
            return;
        }
        /* get tree offset for char p from order-1 tree byte offset table */
        to = bo[ p ];

/* direction in tree from bit in compressed string */
/* compressed bit sets to left(0) or right(1) for next branch or leaf */
        b = s[ i >> 3 ] & (1 << (~i & 7));

/* force comparison to binary */
        if (b != 0) b = 1;

/* minimum of two linked-list lookups for shortest first order entry 
   such as common following letters, but most will be multiple lookups
*/

        zo = to + (o << 1) + b;
        if (zo > z) { /* sanity check, don't stray outside table */
/* change to advrlog if it gets annoying */
            advrlog( LOG_INFO, "%s BAD Branch Offset %04X", WHO, zo);
            return;         
        }
/* first entry has tree lookup to first order left/right choice tree */
        o = co[ zo ]; /* tree root offset is anchor for branches */

/* top bit set means it's a leaf char. this implies that */
/* branches will loop until it is a leaf char */
        if (0 != (0x80 & o) )
        {
            c = 0x7F & o;

            if ( c == 27 )
            {
/* handle Escape to 8 bit mode */
                i++; /* point to msb of uncompressed byte */
                j = i & 7;
                k = 8 - j;
/* get current byte */
                c = s[ i >> 3 ];
/* shift needed? */
                if (0 != j)
                {
                    c <<= j;
                    b = s[ (i >> 3) + 1];
                    b >>= k;
                    c |= b;
                }
                i += 7; /* skip past lsb of uncompressed byte */
            }

            p = c; /* c leaf becomes new index for order-1 tree root offset */
            o = 0; /* clear offset to order-1 tree */
            *d = c;
            dlen--;

/* out of space gets nul term and exits */
            if (dlen < 1) {
                *d = 0;
                break;
            }

            d++; /* else move to next char */

/* nul term exits */
            if ( c == 0 ) break;
        }
    }
}

#ifdef USE_WWW
/* "Sun, 01 Jan 1995 00:00:00 GMT" */
/* gcc circa 1994 and later only */
/* static */
void
http_text_time( char *d, time_t *t )
{
    struct tm ut;
    gmtime_r( t, &ut );
    strftime( d, 30, "%a, %d %b %Y %T GMT", &ut);
}

#endif

#define USE_SNR_RMS
#ifdef USE_SNR_RMS
/* Root Mean Square the SNR samples stored in the signal history */
/* static */
void
calc_snr_rms( struct sig_s *s )
{
        double rms;                     /* unsigned int for b avoids nan */
        unsigned int i, a,c;            /* i and c counts; a square; b sum */
        unsigned long long b;           /* total on good sig might be > 8g */

        a = b = c = 0;
        if (SIG_PNG_W < 1) return;              /* sanity limit, div/0 avoid */
        for (i = 0; i < SIG_PNG_W; i++)         /* SNR 8.8 samples */
        {
                if (s->rmp[i] < 1) continue;    /* don't count zero readings */
                a = s->rmp[i];
                a *= a;                         /* square */
                b += a;                         /* sum */
                c++;                            /* count */
        }
        if (c > 0) b /= c;                      /* avoid div by 0 error */
        rms = sqrt( (double) b );               /* root of mean squares */
        s->snr_rms = (int) rms;                 /* float doesn't matter? */
        advrlog( LOG_INFO, "SNR RMS %5.2f dB", rms / 256.0 );
}
#endif

/* average the FE locked strength samples stored in the signal history */
/* static */
void
calc_sig_avg( struct sig_s *s )
{
        int i, a, c;

        a = c = 0;

        for (i = 0; i < SIG_PNG_W; i++)
        {
                if (s->smp[i] < 1) continue;    /* don't count zero readings */
                a += s->smp[i];
                c++;
        }

        if (c > 0) a /= c;                      /* avoid div by 0 error */
        s->str_avg = a;
}

/* return index of tsid list with matching tsid and program number, or -1 */
/* static */
short
find_tsidx ( unsigned short id, unsigned short pn, char *caller )
{
        short i;
        struct tsid_s *t;

        for (i = 0; i < tsidx; i++) {
                t = tsids + i;
                if ((id == t->tsid) && (pn == t->pn)) {
                        return i;
                    }
        }
        return -1;
}

/* return index of tsid list with matching ptc and program number, or -1 */
/* static */
short
find_tsid_ptc( int pc, unsigned short pn )
{
        short i;
        struct tsid_s *t;

        for (i = 0; i < tsidx; i++) {
                t = tsids + i;
                if ((pc == t->ptc) && (pn == t->pn)) {
                        advrlog( LOG_INFO, "%s TSID %04X.%d found %d %s %s",
                                WHO, t->tsid, pn, i, t->call, t->sid);
                        return i;
                    }
        }
        advrlog( LOG_INFO, "TSID PTC %03d.%d not found", pc, pn);

        return -1;
}


/* stop capture, set reason and set display to timers */
/* static */
void
stop_capture ( char *caller, int fail )
{
        struct sig_s *s;
        
        if (CAP_NONE == cap_now) return; /* nothing to do */
        s = &ptc[ cap_chan ].sig;
        advrlog( LOG_INFO, "%s stops cap, fail %d", caller, fail);
        if (CAP_TIME == cap_now) timer_rec = -1;
        cap_now = CAP_NONE;
        cap_fail = fail;
        s->cap_fail = fail;
#if 0
/* wait for output fifo flush and thread termination */
        while (0 != pid_o) nanosleep( &console_read_sleep, NULL);
#endif

        display_type = D_TIMERS;
        refresh.timers = 1;
}

/* static */
void
read_cutvol_stats( void )
{
        int ok;
        char e[256] = "";
        cut_free = -1LL;

        ok = statfs( cut_path, &cut_fsp );
        if (0 != ok) {
                strerror_r(errno, e, sizeof(e));
                advrlog( LOG_INFO, "%s statfs returns %d %s", WHO, errno, e);
        } else {
                cut_free = (cut_fsp.f_bsize * cut_fsp.f_bavail) >> 30;
                cut_size = (cut_fsp.f_bsize * cut_fsp.f_blocks) >> 30;
        }
}

/* static */
void
read_capvol_stats( void )
{
        int ok;
        char e[256] = "";
        vol_free = -1LL;

        ok = statfs( out_path, &vol_fsp );
        if (0 != ok) {
            strerror_r(errno, e, sizeof(e));
            advrlog( LOG_INFO, "%s statfs returns %d %s", WHO, errno, e);
        } else {
/* These are binary gigabytes not decimal ones with same for cutvol above. */
            vol_free = (vol_fsp.f_bsize * vol_fsp.f_bavail) >> 30;
            vol_size = (vol_fsp.f_bsize * vol_fsp.f_blocks) >> 30;
        }
/* If timer or manual capture in progress and volume space drops below 1GB,
    there is about 7 minutes left before volume is full. Stop the capture.
    EPG capture should be allowed to finish. It will need at least 3MB free.
*/
        if (CAP_NONE == cap_now) return;
        if (CAP_INFO == cap_now) return;

/* Capture is in progress, will need to abort the capture if below 1G left. */
        if (vol_free < 1) {
/* User needs to know why the capture failed. Drive full is critical. */
                dvrlog( LOG_INFO, "capvol %s is FULL!\n", out_path);
                stop_capture( WHO, FAIL_NOSPC );
        }
}


/* Top level navigation for html with servers, channels, and auto-epg toggles.

 Builds up to and including <body>, caller will need to do </body>.

      instance0  ...  instance3 [cap]
            SID0 SID1 SID2 ... SIDn

    Instance will be atscap0...n-1, where n is WWW_DVBS
    SID will be the hrefs for all guides in config, ABC FOX etc
    If auto EPG, SIDn font+color is large+cyan. Current channel is white.

    flags bitfields:
        bit 0           nz list [cap] [cut] dir href after instance names
        bit 1           nz list epg + signal strength imgs and legend
        bit 2           nz epg html uses rel hrefs, 0 is for index html

    d destinatation address
    z maximum number of bytes for destination
    title is string to use for title text
    caller is string of who called this to put in html comment
    r is refresh value to use if non-zero
*/
/* static */
void
build_head_html3 ( char *d, int z, int flags, char *title, int r, char *caller)
{
        int i, iz, fz, ok;
        struct sig_s *s;
        char *c;                        /* font color */
        c = "";
        fz = 3;
        ok = 0;

/* force 1s delayed update of free space */
        utsvsu = 0;

/* FIXME: should be HTML3.2 header */
        asnprintf(d, z, "%s", DOCTYPE_HTML3);

        asnprintf( d, z, "<!-- %s-%s is %s by %s -->\n",
                        NAME, VERSION, COPYRIGHT, EMAIL );

        asnprintf( d, z, "<!-- %s-%s is released under the %s -->\n",
                        NAME, VERSION, LICENSE );
        if (NULL != caller)
            asnprintf(d, z, "<!-- %s %s -->\n", caller, &date_now[4]);

        {
                asnprintf(d, z, "<html>\n");
        }

        asnprintf(d, z, "<head>\n");

        asnprintf(d, z, "<meta http-equiv=\042%s\042 content=\042%s\042>\n",
                    "Content-Type", "text/html;charset=ISO-8859-1");

        if (0 < r) asnprintf(d, z,
                "<meta http-equiv=\042%s\042 content=\042%d\042>\n",
                    "Refresh", r);

        if (NULL != title) asnprintf(d, z, "<title>%s</title>", title);
        asnprintf(d, z, "</head>\n");

/* <body ...> settings */
        asnprintf(d, z, "<body "
                    "id=\042%s\042 "
                    "bgcolor=\042%s\042 "
                    "text=\042%s\042 "
                    "link=\042%s\042 "
                    "vlink=\042%s\042 "
                    "alink=\042%s\042" 
                    ">\n",
                    "top", WWW_BG, WWW_FG, WWW_HLINK, WWW_VLINK, WWW_ALINK );
        asnprintf(d, z, "<center>\n");

/* top level server navigation. list available atscap instances

    conditional set to 0 is for multi-host single-servers
        4 cards in 4 machines

    conditional set to 1 (default) for single-host multi-server
        4 cards in 1 machine
*/
        for (i = 0; i < www_dvrs; i++) {

/* active server is normal font and green  (assumed true for multi-sever) */
                fz = 3;
                c = "#00FF00";

/* undefine this for one device per server */
#define USE_MULTI_CARD
#ifdef USE_MULTI_CARD
/* this is for multiple cards in one machine, the usual default */
                ok = test_var_procpid(i, 0);
/* inactive server gets smaller font and grey */
                if (0 == ok) {
                    fz = 2;
                    c = "#C0C0C0";
                }

                asnprintf( d, z, "<a href=\042http://%s:%u/%s%d.html\042>",
                        arg_whost, (0xFFFC & arg_wport) + i, NAME, i );
#else
/* this is for multiple machines with one card each */
/* edit your /etc/hosts to give ip addresses to dtv0 dtv1 dtv2 dtv3 */

/* nothing written to test for the other machine being up. Would need to
    fetch the server header from other machine and check for atscap */
                asnprintf( d, z, "<a href=\042http://%s%d:%u/%s%d.html\042>",
                        arg_whost, i, arg_wport, NAME, 0 );
#endif
                if (i == arg_devnum) {
                        fz = 4; c = "#FFFFFF";
                }

                asnprintf(d, z, "<font size=\042%d\042 color=\042%s\042>",
                            fz, c);
                asnprintf(d, z, "%s%d </font>", NAME, i);
                asnprintf(d, z, "</a>\n");
        }

/* volume available indication, cap directory is always available */
        if (1 & flags) {

                asnprintf( d, z, "<a href=\042%s\042>%s </a>\n",
                            "/", "[cap]");

/* show the href if cut directory is available */
                if (-1LL != cut_free)
                        asnprintf( d, z, "<a href=\042%s\042>%s </a>\n",
                                    "/cut/", "[cut]");
        }

        asnprintf( d, z, "<a href=\042/pg/grid%d.html\042>%s </a>\n",
                            arg_devnum, "[grid]");

        asnprintf(d, z, "</center>\n");
        asnprintf(d, z, "<hr />\n");

/* show list of available channels,
   blue and larger for auto-epg set, white for current channel
   signal scan graph listed underneath network id

    user hits refresh to get same result as current channel href.?? deleteme
*/
        if (0 == (2 & flags)) {

            asnprintf(d, z, "<center>\n");
            for (i = 0; i < scan_idx; i++) {
                s = &ptc[scan_list[i]].sig;

/* use rel href */
                if (0 != (4 & flags)) {
                    asnprintf(d,z, "<a href=\042%02d.html\042>", s->chan);
                } else {
                    asnprintf(d,z, "<a href=\042/pg/%02d.html\042>", s->chan);
                }
                
                fz = 3;
                c = "#00FF00";

                if (0 != s->pgto) {
                        fz = 4;
                        c = "#00BFFF";
                }

/* in EPG page, current EPG channel is white */
                if (s->chan == pgm3.chan) {
                        fz = 4;
                        c = "#FFFFFF";

                }
                asnprintf(d, z, "<font size=\042%d\042 color=\042%s\042>",
                            fz, c);
                asnprintf(d, z, "%s </font>", s->sid);
                asnprintf(d, z, "</a>\n");
            }
            asnprintf(d, z, "</center>\n");
        }

/* This flag shows signal strength image graphs for each channel
   a table is needed to get everything to line up properly.  It may
   not look very good for more than 15 channels on 1024 wide browser.

   Options are displayed at bottom along with legend shown or hidden.
*/
        if (0 != (2 & flags)) {

/* table is 100% of browser width */
            asnprintf(d, z, TBL_FMT, TBL_BRD, 0, 0, "center", "100%");

/************************************************ table header and SIDn */
            asnprintf(d, z, " <tr>\n");     

            for (i = 0; i < scan_idx; i++) {
                s = &ptc[scan_list[i]].sig;

                asnprintf(d, z, "  " TH_FMT, "top", "5%");
                asnprintf(d, z, "<a href=\042pg/%02d.html\042>", s->chan);
                fz = 3;
                c = "#00FF00";
                if (0 != s->pgto) {
                        fz = 4;
                        c = "#00BFFF";
                }

/* in server page, current scan channel is white */
                if (s->chan == cap_chan) {
                        fz = 4;
                        c = "#FFFFFF";

                }
                asnprintf(d, z, "<font size=\042%d\042 color=\042%s\042>",
                                fz, c);

/* table entries do not get following spaces. centering handles this */
                asnprintf(d, z, "%s</font>", s->sid);
                asnprintf(d, z, "</a>");
                asnprintf(d, z, "</th>\n");

            }

            asnprintf( d, z, " </tr>\n");


#ifdef USE_DVB_EXPERIMENTAL
/********************************************** tuner frequency drift */
            if (0 != scan_khz) {
                asnprintf(d, z, " <tr>\n");
                for (i = 0; i < scan_idx; i++) {
                    char n[32];
                    s = &ptc[scan_list[i]].sig;
                    snprintf(n, sizeof(n), "%dkc", s->fohz/1000);
                    asnprintf(d, z, "  " TD_FMT, "top", "5%");
                    asnprintf(d, z, "<center>%s</center>", n);
                    asnprintf(d, z, "</td>\n");
                }

                asnprintf(d, z, " </tr>\n");
            }
#endif

/***************************************************** signal SNR RMS */
            if (0 != scan_snr) {
                asnprintf(d, z, " <tr>\n");         
                for (i = 0; i < scan_idx; i++) {
                    char n[32];
                    s = &ptc[scan_list[i]].sig;
                    calc_snr_rms( s );
                    snprintf(n, sizeof(n), "%ddB", 0xFF & (s->snr_rms>>8));
                    asnprintf(d, z, "  " TD_FMT, "top", "5%");
                    asnprintf(d, z, "<center>%s</center>", n);
                    asnprintf(d, z, "</td>\n");
                }
                asnprintf(d, z, " </tr>\n");
            }

/********************************************** signal strength% average */
            asnprintf(d, z, " <tr>\n");     
            for (i = 0; i < scan_idx; i++) {
                char n[32];
                s = &ptc[scan_list[i]].sig;
                calc_sig_avg( s );
                snprintf(n, sizeof(n), "%d%%", s->str_avg);
                asnprintf(d, z, "  " TD_FMT, "top", "5%");
                asnprintf(d, z, "<center>%s</center>", n);
                asnprintf(d, z, "</td>\n");
            }

            asnprintf(d, z, " </tr>\n");

/********************************************** signal strength chart */

/* image size only used in html3 code, html4 + css is fluid */
            iz = 24;
            if (0 != scan_png) iz = 48;

            asnprintf(d, z, " <tr>\n");     
            for (i = 0; i < scan_idx; i++) {
                    char n[16];
                    int v = -1;

                    s = &ptc[scan_list[i]].sig;
                    iz = 50;
                    if (0 == scan_png) iz = 25;
                    
                    snprintf( n, sizeof(n), "pg/%d-%02d.png",
                                arg_devnum, s->chan);

                    asnprintf(d, z, "  " TH_FMT, "middle", "5%");
//                  if ((0 == scan_sig) || (s->chan != cap_chan))

                    v = s->chan;

                    asnprintf(d, z, "<a href=\042/%s%d.html?v=%d\042>",
                        NAME, arg_devnum, v );
                    asnprintf(d, z, IMG_FMT, s->call, n, iz, iz, 0, 0, 1);
                    asnprintf(d, z, "</a>");
                    asnprintf(d, z, "</th>\n");     
            }
            asnprintf(d, z, " </tr>\n");            

/************************************************* auto EPG toggle */
            asnprintf(d, z, " <tr>\n");
            for (i = 0; i < scan_idx; i++) {
                char *n, *a;
                s = &ptc[scan_list[i]].sig;

/* alt text */
                a = "OFF";

/* default image is epg off */
                n = "pg/img/epgoff24.png";
                if (0 != scan_png) n = "pg/img/epgoff.png";

/* image changes if auto epg */
                if (0 != s->pgto) {
                    a = "ON";
                    n = "pg/img/epgon24.png";
                    if (0 != scan_png) n = "pg/img/epgon.png";
/* image size and name. actual size images less jagged than browser resize */
                }

/* live cap shows blue, sig scan shows antenna, else green, variable size */
                if (cap_chan == s->chan) {
/* is cap? */
                    if (CAP_NONE != cap_now) {
                        a = "LIVE";
                        n = "pg/img/epglive24.png";
                        if (0 != scan_png) n = "pg/img/epglive.png";
                    } else {
/* no cap, is sig scan? */
                        if (0 != scan_sig) {
                            a = "SCAN";
                            n = "pg/img/scanon24.png";
                            if (0 != scan_png) n = "pg/img/scanon.png";
                        }
                    }
                }

                asnprintf( d, z, "  " TH_FMT, "top", "5%");
                asnprintf( d, z, "<a href=\042/%s%d.html?e=%02d\042>",
                        NAME, arg_devnum, s->chan );

                asnprintf( d, z, IMG_FMT, a, n, iz, iz, 0, 0, 0 );
                asnprintf( d, z, "</a>");
                asnprintf( d, z, "</th>\n");
            }
            asnprintf(d, z, " </tr>\n");
/************************************************ end of auto epg toggles */

            asnprintf(d, z, "</table>\n");
/************************************************* end of server page table */

/* display options */
            asnprintf(d, z, "<hr />\n");
        
/*********************************************************** legend toggle */
            asnprintf(d, z, "<center>\n");
            asnprintf(d, z, "<a href=\042%s%d.html?l=1\042>",
                            NAME, arg_devnum);
            asnprintf(d, z, "%s", (0 == web_legend) ? "Help":"HELP");
            asnprintf(d, z, "</a> " NBSP " \n");

            asnprintf(d, z, "<a href=\042%s%d.html?f=%d\042>",
                            NAME, arg_devnum, 1 );
            asnprintf(d, z, "%s", "CSS");
            asnprintf(d, z, "</a> \n");

/******************************************************* stats toggle */

#ifdef USE_DVB_EXPERIMENTAL
            asnprintf(d, z, "<a href=\042%s%d.html?q=2\042>",
                            NAME, arg_devnum );
            asnprintf(d, z, "%s", (0 == scan_khz)?"freq":"FREQ");
            asnprintf(d, z, "</a> \n");
#endif

            asnprintf(d, z, "<a href=\042%s%d.html?q=1\042>",
                            NAME, arg_devnum );
            asnprintf(d, z, "%s", (0 == scan_snr)?"snr":"SNR");
            asnprintf(d, z, "</a> \n");

            asnprintf(d, z, "<a href=\042%s%d.html?k=%d\042>",
                            NAME, arg_devnum, (0 == web_stats) ? 1:0 );
            asnprintf(d, z, "%s", (0 == web_stats)?"stats":"STATS");
            asnprintf(d, z, "</a> \n");

#if 0
/* signal chart large or small */
            asnprintf(d, z, "<a href=\042%s%d.html?p=%d\042>",
                            NAME, arg_devnum, (0 == scan_png) ? 1:0 );
            asnprintf(d, z, "%s", (0 == scan_png)?"png":"PNG");
            asnprintf(d, z, "</a> \n");
#endif

/* signal scan start or stop */
            if (CAP_NONE == cap_now) {
                asnprintf(d, z, "<a href=\042%s%d.html?w=%d\042>",
                                NAME, arg_devnum, (0 == scan_one) ? 0:1 );
                asnprintf(d, z, "%s", (0 != scan_one)?"scan":"SCAN");
                asnprintf(d, z, "</a> \n");
            }

/************************************************************** legend */
            if (0 != web_legend) {
                asnprintf(d, z, "<br>\n");
                asnprintf(d, z, "EPG: \n");
                asnprintf(d, z, IMG_FMT, "AUTO", "pg/img/epgon24.png",
                            24, 24, 0, 0, 0 );
                asnprintf(d, z, "Auto\n");

                asnprintf(d, z, IMG_FMT, "OFF", "pg/img/epgoff24.png",
                            24, 24, 0, 0, 0 );
                asnprintf(d, z, "Off\n");

                asnprintf( d, z, " STATUS: ");
                asnprintf(d, z, IMG_FMT, "CAP", "pg/img/epglive24.png",
                            24, 24, 0, 0, 0 );
                asnprintf(d, z, "Cap\n");

                asnprintf(d, z, IMG_FMT, "SCAN", "pg/img/scanon24.png",
                            24, 24, 0, 0, 0 );
                asnprintf(d, z, "Scan\n");
            }
            asnprintf(d, z, "</center>\n");

        }
        asnprintf(d, z, "<hr />\n");
}

/************************************************** end of build_head_html3 */


/************************************************ start of build head html4 */
/*
    flags bitfields:
        bit 0           list [cap] dir href after device names
        bit 1           list epg + signal strength imgs and legend
        bit 2           nz epg html uses rel hrefs, 0 is for index html
        bit 3           nz use XHTML 1.0 header
    d destinatation address
    z maximum number of bytes for destination
    title is string to use for title text
    caller is string of who called this to put in html comment
    r is refresh value to use if non-zero
*/


/* server navigation header */
/* Top level server navigation.

    Some people have multiple machines with 1 device each,
    others have all devices in one machine. Still others
    have some odd mixture that can't be predicted here.
    The default is one capture server with multiple devices.

    conditional compile set to 0 is for multi-host single-servers
        4 cards in 4 machines

    conditional compile set to 1 (default) for single-host multi-server
        4 cards in 1 machine

    checks /var/run/atscap/atscap[0-3].pid against process list
        for active servers. .pid only generated if -w option.

*/
/* snav and cnav are not using CSS */
/* static */
void
build_snav_html4 ( char *d, int z, int flags )
{
        int i, ok;
        char *a;        /* font and color class for href */

        a = "";

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);

        asnprintf(d, z, "<div class=\042%s\042>\n", "snbl f5");
        asnprintf(d, z, "<center>\n");

//      asnprintf( d, z, "<ul class=\042%s\042>\n", "snbul");

/* one device */
        if (1 == www_dvrs) { 
                asnprintf(d, z, "<a class=\042%s\042 "
                                "href=\042/%s%d.html\042>",
                                    a, NAME, arg_devnum );
                asnprintf(d, z, "%s%d ", NAME, arg_devnum);
                asnprintf(d, z, "</a>\n");
        } else {
            for (i = 0; i < www_dvrs; i++) {

#ifdef USE_MULTI_CARD
                ok = test_var_procpid(i, 0);
#endif

//              asnprintf( d, z, "<li class=\042%s\042>", "snbl1");
                a = "snba0";            /* smaller font and grey */
                if (0 != ok)
                        a = "snba1";    /* smaller font and green */

                if (i == arg_devnum)    /* current device? */
                        a = "snba2";    /* bigger font, and white */

/* undefine this for one device per server */
#ifdef USE_MULTI_CARD
/* this is for multiple cards in one machine, the usual default */
                asnprintf(d, z, "<a class=\042%s\042 "
                                "href=\042http://%s:%u/%s%d.html\042>",
                                    a, arg_whost,
                                    (0xFFFC & arg_wport) + i, NAME, i );
#else
/* this is for multiple machines with one card each */
/* edit your /etc/hosts to give ip addresses to dtv0 dtv1 dtv2 dtv3 */
                asnprintf(d, z, "<a class=\042%s\042 "
                                "href=\042http://%s%d:%u/%s%d.html\042>",
                                    a, arg_whost, i, arg_wport, NAME, 0 );
#endif
                asnprintf(d, z, "%s%d ", NAME, i);
                asnprintf(d, z, "</a>\n");
//              asnprintf(d, z, "</li>\n");
            }
        }
//      asnprintf(d, z, "</ul>\n");

//      asnprintf( d, z, "<ul class=\042%s\042>\n", "snbul");
/* volume available indication, cap directory is always available */
        if (1 & flags) {

//              asnprintf(d, z, "<li class=\042%s\042>", "snbl2");
                asnprintf(d, z, "<a class=\042%s\042 "
                                "href=\042%s\042>%s </a>\n",
                                    "snba3", "/", " [cap] ");
//              asnprintf( d, z, "</li>\n");

/* show the href if cut directory is available */
                if (-1LL != cut_free) {
//                      asnprintf(d, z, "<li class=\042%s\042>", "snbl2");
                        asnprintf(d, z, "<a class=\042%s\042 "
                                        "href=\042%s\042>%s </a>\n",
                                            "snba4", "/cut/", " [cut] ");
//                      asnprintf( d, z, "</li>\n");
                }
        }

        asnprintf(d, z, "<a class=\042%s\042 "
                        "href=\042/pg/grid%d.html\042>%s </a>\n",
                        "snba1", arg_devnum, " [grid] ");

//      asnprintf(d, z, "</ul>\n");
        asnprintf(d, z, "</center>\n");
        asnprintf(d, z, "<hr width=\042%s\042 />\n", "100%");
        asnprintf(d, z, "</div>\n");
        asnprintf(d, z, "<br class=\042%s\042 />\n", "br_epgdiv");
}


/* CSS EPG channel navigation header. dump cap log and http index use it too.
   CSS server config page uses a different format.
*/
/* static */
void
build_cnav_html4 ( char *d, int z, int flags )
{
        int i;
        char *a, *c, *i0, *i1;
        struct sig_s *s;

        a = c = i0 = i1 = "";

/* TODO: optimization: move the branch up to save a call */
        if (0 != (2 & flags)) return;

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);
        asnprintf(d, z, "<div class=\042%s\042>\n", "f5");
        for (i = 0; i < scan_idx; i++) {

// Peter Knaggs reports SEGV here where scan_list is corrupted with vc data?
// seems to be OK now?
                s = &ptc[scan_list[i]].sig;

/* channel is not selected for EPG nor current */
                a = "cnbl1";
                c = "cnba0";

/* has an epg */
                if (s->pgx > 0) c = "cnba6";

/* channel has auto EPG */
                if (s->pgto != 0) c = "cnba2";

/* has timesource */
                if (s->ptc == cap_zc) c = "cnba5";

/* is current scan channel */
                if (s->chan == pgm.chan) c = "cnba3";

/* live capture channel */
                if ((CAP_NONE != cap_now) && (s->chan == cap_chan))
                    c = "cnba4";

/* channel is same as the epg at which we're looking.
    for non EPG, it provides a visual anchor back to last EPG viewed
*/
                if (s->chan == pgm3.chan) c = "cnba1";

/* if not at least 500 wide, channel might be dead or in test pattern */
                if (500 > s->hres) c = "cnba7";

                asnprintf(d, z, "<div class=\042%s\042>", c);
/* use rel href */
                if (0 != (4 & flags)) {
                        asnprintf(d, z, "<a class=\042%s\042 "
                                    "href=\042%02d.html\042>",
                                    "cnbt", s->chan);
                } else {
                        asnprintf(d, z, "<a class=\042%s\042 "
                                    "href=\042/pg/%02d.html\042>",
                                    "cnbt", s->chan);
                }

/* italicize current channel if browser colors forced to "use my colors".
   TODO: put it in the style sheet, class cnba3 maybe, but still want colors
*/
                i1 = i0 = "";
                if (cap_chan == s->chan) {
                    i1 = "<i>";
                    i0 = "</i>";
                }
// try callsign instead. nope, too big
//              asnprintf(d, z, "%s%s%s ", i1, s->call, i0);
                asnprintf(d, z, "%s%s%s ", i1, s->sid, i0);
                asnprintf(d, z, "</a>");
                asnprintf(d, z, "</div>\n");
        }
        asnprintf(d, z, "<br class=\042%s\042 />\n", "br_epgdiv");
        asnprintf(d, z, "<hr width=\042%s\042 />\n", "100%");
        asnprintf(d, z, "</div>\n");
}

/* This flag shows signal strength image graphs for each channel
   CSS should allow it to resize better than old table did
*/
/* static */
void
build_sigs_html4 ( char *d, int z, int flags )
{
        int i, iz, v;
        struct sig_s *s;
        char *a, *b, *e, *f, *c, *i0, *i1, hr[64];

        i = iz = v = 0;
        a = "";
        s = NULL;
        b = "sgbl1";
        e = "";
        c = "green";
        f = "f3";
        i0 = i1 = "";

/* epg doesn't use this format, but uses similar */
        if (0 == (2 & flags)) return;

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);

        a = "";
        asnprintf(d, z, "<div class=\042%s\042>\n", "f4");

/* can't get centering to work decently with CSS so far */
//      asnprintf(d, z, "<center>\n");
        for (i = 0; i < scan_idx; i++) {
                s = &ptc[scan_list[i]].sig;

                asnprintf(d, z, "<div class=\042%s\042>\n", "sgbl");

/***************************************************** start of <ul> */
                asnprintf(d, z, "<ul class=\042%s\042>\n", "sgbul");


/*************************************************************** EPG nav */

/* default style */
                c = "cnta0";

/* auto epg style */
                if (0 != s->pgto) c = "cnta2";

/* current channel overrides auto-epg style */
                i0 = i1 = "";
                if (cap_chan == s->chan) {
                        c = "cnta1";

/* TODO: move italics to style sheet once decided what gets italics */
                        i1 = "<i>";
                        i0 = "</i>";
                }

                asnprintf( d, z, "<li class=\042%s\042>"
                                "<a class=\042%s\042 "
                                "href=\042/pg/%02d.html\042>"
                                "%s%s%s</a></li>\n",
                            b, c, s->chan, i1, s->sid, i0 );

/*************************************************** Signal scan control */


/* kc, dB, then strength average % on top of chart */
                f = "f2";

#ifdef USE_DVB_EXPERIMENTAL
/* drift kilocycles */
                if (0 != scan_khz) {
                        asnprintf(d, z, "<li class=\042%s %s\042> %-dkc"
                                        "</li>\n",
                                b, f, s->fohz / 1000);
                }
#endif

                if (0 != scan_snr) {
                        calc_snr_rms(s);
#ifdef USE_DB_PERCENT
/* N.nn instead of N dB */
                        asnprintf(d, z, "<li class=\042%s %s\042> %d.%02d "
                                        "</li>\n",
                                b, f, 0xFF & (s->snr_rms >> 8),
                                ((0xFF & s->snr_rms) * 100) >> 8 );
#else
/* N dB instead of n.nn */
                        asnprintf(d, z, "<li class=\042%s %s\042> %ddB "
                                        "</li>\n",
                                b, f, 0xFF & (s->snr_rms >> 8) );
#endif
                }

/* this value is average of signal strength, reflects graph below it.
    it gets a channel select href if not using png graph
*/
                calc_sig_avg(s);

                snprintf( hr, sizeof(hr)-1, "%d%%", s->str_avg);

                if (0 == scan_png) {
                    snprintf( hr, sizeof(hr)-1,
                                "<a class=\042%s\042"
                                " href=\042%s%d.html?v=%d\042>%d%%</a>",
                                c, NAME, arg_devnum, s->chan, s->str_avg );
                }

                asnprintf(d, z, "<li class=\042%s %s\042> %s </li>\n",
                                b, f, hr);

                v = s->chan;

/* if png graph is enabled it gets href for channel select */
            if (0 != scan_png)
            {
/* no background image */
                a = "SIG";
                e = "img_sig";

/* epg type background image */
                if ((cap_chan == s->chan) && (0 != scan_sig)) {
                        e = "epgsgi";
                        a = "NOSIG";
                }

                asnprintf(d, z, "<li class=\042%s\042>"
                                "<a class=\042%s\042 "
                                "href=\042%s%d.html?v=%d\042>"
                                "<img class=\042%s\042 "
                                "alt=\042%s%02d\042 "
                                "border=\042%s\042 "
                                "src=\042/pg/%d-%02d.png\042 />"
                                "</a></li>\n",
                        b, c, NAME, arg_devnum, v, e, a,
                        s->chan, "1", arg_devnum, s->chan);
            }

/****************************************************** Auto EPG control */
                e = "epgoff.png";
                a = "APG OFF";

                if (0 != s->pgto) {
                        e = "epgon.png"; a = "APG ON";
                }
                if ((CAP_NONE != cap_now) && (cap_chan == s->chan)) {
                        e = "epglive.png";
                        a = "LIVE";
                }

                asnprintf(d, z, "<li class=\042%s\042>"
                                "<a href=\042/%s%d.html?e=%02d\042>"
                                "<img class=\042%s\042 "
                                "alt=\042%s\042 "
                                "src=\042/pg/img/%s\042 />"
                                "</a></li>\n",
                        b, NAME, arg_devnum, s->chan, "img_apg", a, e);


/******************************************************* end of <ul> */
                asnprintf(d, z, "</ul>\n");
                asnprintf(d, z, "</div>\n\n");
        }
//      asnprintf(d, z, "</center>\n");
        asnprintf(d, z, "</div>\n");
}

/* CSS sets the colors */
/* <body ...> settings */
/* build_foot_html should close the <body> bag */
/* static */
void
build_body_html4 ( char *d, int z, int flags )
{
        asnprintf(d, z, "\n<!-- %s -->\n", WHO);
        asnprintf(d, z, "<body id=\042%s\042>\n", "top");
        build_snav_html4(d, z, flags);
        build_cnav_html4(d, z, flags);
        build_sigs_html4(d, z, flags);
}

/* static */
void
build_head_html4 ( char *d, int z, int flags, char *title, int r, char *caller)
{

/* w3c validator needs this to determine how to validate it */
        asnprintf(d, z, "%s", DOCTYPE_HTML4 );

/* force 1s delayed update of free space */
        utsvsu = 0;

        asnprintf( d, z, "<!-- %s-%s is %s by %s -->\n",
                        NAME, VERSION, COPYRIGHT, EMAIL );

        asnprintf( d, z, "<!-- %s-%s is released under the %s -->\n",
                        NAME, VERSION, LICENSE );
        if (NULL != caller)
                asnprintf(d, z, "<!-- %s %s -->\n", caller, &date_now[4]);

        asnprintf(d, z, "<html>\n");

        asnprintf(d, z, "<head>\n");
        asnprintf(d, z, "<meta http-equiv=\042%s\042 content=\042%s\042>\n",
                    "Content-Type", "text/html;charset=ISO-8859-1");

#if 0
/* Don't override refresh settings */
/* This makes it so you can't use atscapN.html page for idle during capture.
   Refresh is SIG_PNG_W because that's all the chart will between refresh.
   If player and mozilla are running at same time, change to cap/cut dir.
*/
        if (CAP_NONE != cap_now) r = SIG_PNG_W;
#endif

        if (r > 0)
                 asnprintf(d, z, "<meta http-equiv=\042%s\042 "
                                "content=\042%d\042>\n",
                                "Refresh", r);

        asnprintf(d, z, "<link rel=\042%s\042 "
                        "href=\042%s\042 "
                        "type=\042%s\042>\n",
                            "stylesheet", "/pg/img/style.css", "text/css");

        if (NULL != title) asnprintf(d, z, "<title>%s</title>", title);
        asnprintf(d, z, "</head>\n");
}
/************************************************** end of build_head_html4 */


/************************************************ start of build_head_xhtml */
/* static */
void
build_head_xhtml( char *d, int z, int flags, char *title, int r, char *caller)
{
        char *t;

/* xhtml wants " />" for end tag on certain things */
        t = " /";
        utsvsu = 0; /* force 1s delayed update of free space */

/* w3c validator needs this to determine how to validate it */
/* this document isn't really xhtml or xml, only fancy html 4.01 */
        asnprintf(d, z, "<?xml version=\042%s\042?>\n", "1.0");

        asnprintf(d, z, "%s", DOCTYPE_XHTML );

        asnprintf( d, z, "<!-- %s-%s is %s by %s -->\n",
                        NAME, VERSION, COPYRIGHT, EMAIL );

        asnprintf( d, z, "<!-- %s-%s is released under the %s -->\n",
                        NAME, VERSION, LICENSE );
        if (NULL != caller)
                asnprintf(d, z, "<!-- %s %s -->\n", caller, &date_now[4]);

        asnprintf(d, z, "<html xmlns=\042http://www.w3.org/1999/xhtml\042 "
                        "xml:lang=\042en\042 lang=\042en\042>\n" );

        asnprintf(d, z, "<head>\n");

        asnprintf(d, z, "<meta http-equiv=\042%s\042 "
                        "content=\042%s\042%s>\n",
                            "Content-Type",
                            "text/html;charset=ISO-8859-1", t);

        if (0 < r)
                 asnprintf(d, z,"<meta http-equiv=\042%s\042 "
                                "content=\042%d\042%s>\n",
                                    "Refresh", r, t);

#ifdef USE_STYLE_EMBED
/* only use this if css styles are in this file */
        asnprintf(d, z, "<meta http-equiv=\042%s\042 "
                        "content=\042%s\042%s>\n",
                            "Content-Style-Type", "text/css", t);
#else
        asnprintf(d, z, "<link rel=\042%s\042 "
                        "href=\042%s\042 "
                        "type=\042%s\042%s>\n",
                            "stylesheet", "/pg/img/style.css", "text/css", t);
#endif
        if (NULL != title) asnprintf(d, z, "<title>%s</title>", title);
        asnprintf(d, z, "</head>\n");
}
/************************************************** end of build_head_xhtml */

/* static void */
void
build_head_html ( char *d, int z, int flags, char *title, int r, char *caller)
{
        if (0 == use_css) {
            build_head_html3( d, z, flags, title, r, caller );
        } else {
            if (0 == (8 & flags)) {
                build_head_html4( d, z, flags, title, r, caller );
            } else {
                build_head_xhtml( d, z, flags, title, r, caller );
            }

/* TODO: should be able to make HTML4 body compatible with XHTML1 */
            build_body_html4( d, z, flags );
        }
}

/* build standard html footer with optional w3c validated imgs */
/* validated is optional because http index_html breaks the html rules
    by using <hr> inside <pre> block, even though it renders OK.
 */
/* static */
void
build_foot_html3 ( char *d, int z, int v )
{

        asnprintf(d, z, "<br>\n");
        asnprintf(d, z, "<hr>\n");
        asnprintf(d, z, "<center>\n");

/* show the log link for this instance */
        asnprintf(d, z, "<a href=\042/%s%d.log\042>", NAME, arg_devnum);
        asnprintf(d, z, " %s-%s\n",NAME, VERSION);
        asnprintf(d, z, "</a> ");
        asnprintf(d, z, "%s %s:%d\n", LASTEDIT, arg_whost, arg_wport);
        asnprintf(d, z, "<br>\n");
        asnprintf(d, z, "<br>\n");

/* show the html 4.01 validator image if it has been validated */
        if (1 == (1 & v))
            asnprintf(d, z, "<img alt=\042%s\042 src=\042%s\042 />\n",
                        "HTML401", "/pg/img/valid-html401-blue.png");

        asnprintf(d, z, "</center>\n");
        asnprintf(d, z, "</body>\n");
        asnprintf(d, z, "</html>\n");
}


/* build standard xhtml footer with optional w3c validated imgs */
/* static */
void
build_foot_html4 ( char *d, int z, int v )
{
        int i;

#if 0
        for (i=0; i < 2; i++) asnprintf(d, z,"<br />");
        asnprintf(d, z, "\n</body>\n");
        asnprintf(d, z, "\n</html>\n");
        return;
#endif

//      *d = 0;

/* some vertical space to show the HTML 4 validation logos */
        for (i=0; i < 30; i++) asnprintf(d, z,"<br />");
        asnprintf(d, z, "\n");

        asnprintf(d, z, "\n\n");
        asnprintf(d, z, "\n<!-- %s -->\n", WHO);
        asnprintf(d, z, "<div id=\042%s\042>\n", "foot");
        asnprintf(d, z, "<br class=\042%s\042 />\n", "br_epgdiv");
        asnprintf(d, z, "<br /><br />\n");
        asnprintf(d, z, "<hr />\n");
        asnprintf(d, z, "<center>\n");

/* show the log link for this instance */
        asnprintf(d, z, "<a class=\042%s\042 "
                        "href=\042/%s%d.log\042>",
                    "green", NAME, arg_devnum);
        asnprintf(d, z, " %s-%s\n",NAME, VERSION);
        asnprintf(d, z, "</a> ");
        asnprintf(d, z, "%s %s %s %s:%d\n", LASTEDIT, LASTDATE, LASTTIME,
                        arg_whost, arg_wport);
        asnprintf(d, z, "<br class=\042%s\042/>\n", "br_epgdiv");
        asnprintf(d, z, "<br class=\042%s\042/>\n", "br_epgdiv");

/* show the html 4.01 validator image if it has been validated */
        if (1 == (1 & v))
            asnprintf(d, z, "<img alt=\042%s\042 src=\042%s\042 />\n",
                        "HTML401", "/pg/img/valid-html401-blue.png");

#ifdef USE_XHTML
        if (2 == (2 & v))
            asnprintf(d, z, "<img alt=\042%s\042 src=\042%s\042 />\n",
                        "XHTML10", "/pg/img/valid-xhtml10-blue.png");
#endif

        if (4 == (4 & v))
            asnprintf(d, z, "<img alt=\042%s\042 src=\042%s\042 />\n",
                        "CSS", "/pg/img/valid-css-blue.png");

#ifdef USE_POWERDOWN
#ifdef USE_POWERDOWN_DEBUG
/* show powerdown status at end bottom */
        if (0 != arg_tmpfs) {
                char tx[64];

                asnprintf(d, z, "<br />\n");
                asnprintf(d, z, "Next:<br />\n");

                text_time(tx, utspdd, 20);
                asnprintf(d, z, "PD %s<br />\n", tx);

                text_time(tx, utswuv, 20);
                asnprintf(d, z, "PV %s<br />\n", tx);

                text_time(tx, utstpg, 20);
                asnprintf(d, z, "PG %s<br />\n", tx);
        }
#endif
#endif

        asnprintf(d, z, "</center>\n");
        asnprintf(d, z, "</div>\n");
        asnprintf(d, z, "</body>\n");
        asnprintf(d, z, "</html>\n");
}

/* static */
void
build_foot_html( char *d, int z, int v )
{
        if (0 == use_css) {
                build_foot_html3( d, z, v );
        } else {
                build_foot_html4( d, z, v );
        }
}

/* Build capture stats as html into string at s, with maximum size z. */
/* TODO: this should be done as a table instead of pre-formatted text */
/* static */
void
build_stats_html3 ( char *d, int z )
{
        time_t t, tu;           /* current time */
        long long tt, te, tp, tb; /* totals: packets, tables, errors, band */
        long long ets, ln;
        int dd,hh,mm,ss;
        int i, j, k;
        char dn[ 32 ], c[256], p[256], uri[256],
                *c0, *c1, *c2, *c3, *c4, *c5, *c6, *c7,
                *u, *up; /* text fields */

        struct sig_s *s;

        s = &ptc[ cap_chan ].sig;

        ets = s->cap_ets;

        if (CAP_NONE != cap_now) {
                ets = (long long)utsets;

/* normally done only at end of cap but want live info now */
                memcpy( &s->pkt, &pkt, sizeof( pkt ));
        }

        if (ets <1) ets = 1;            /* /0 avoid */

        u = "Log";
/*      if (CAP_NONE == cap_now) u = "Save"; */

        tt = te = tp = tb = 0LL;
    
/* average rate starts inaccurate but as sample gets larger, it stabilizes */

        memset( c, 0, sizeof(c));

        c0 = &c[0x00];
        c1 = &c[0x20];
        c2 = &c[0x40];
        c3 = &c[0x60];
        c4 = &c[0x80];

/* spares if needed */
        c5 = &c[0xA0];
        c6 = &c[0xC0];
        c7 = &c[0xE0];

        t = (time_t) utsnow;
        ctime_r( &t, dn );
        dn[19] = 0;

/* header */
        asnprintf( d, z, "<center>\n");

// validator doesn't like this
//      asnprintf( d, z, "<font color=\042%s\042>\n", "#FFFFFF");

        tu = t - utc_up;
        dd = tu / SECDAY;
        hh = (tu / SECHR) % 24;
        mm = (tu / SECMIN) % 60;
        ss = tu % 60;
        
        asnprintf( d, z, "%s, <i>Uptime %dd %02d:%02d:%02d</i><br>", dn, dd, hh, mm, ss);
        asnprintf( d, z, "ATSC and MPEG Transport Stream Statistics<br>\n");
        asnprintf( d, z, "LCN %d %s %s PTC %d.%d TSID %04X<br>\n",
                        cap_chan, s->call, s->sid, s->ptc, s->pn, vc[0].tsid);

        filebase( p, out_name, F_FILE);

/* info cap log html file was last log available? */
        up = "";
        if ((CAP_INFO == cap_now) || (CAP_INFO == cap_prev))
            up = "pg/";

/* FIXME: presumes *p is 0 if info cap
   TODO: don't show blank link
*/
        if (0 != *p) {

            hh = ets / SECHR;
            mm = (ets / SECMIN) % 60;
            ss = ets % 60;

            filebase( uri, p, F_TFILE);
            asnprintf( d, z, "<a href=\042/%s%s.html\042>", up, uri);

            asnprintf( d, z, "%s %s", u, p);

            asnprintf( d, z, "</a>");
            asnprintf( d, z, " ET %02d:%02d:%02d", hh, mm, ss);
        }

        asnprintf( d, z, "<hr width=\042%s\042>\n", "33%");


/* body */

        asnprintf( d, z, "<pre>");

        tt = te = tp = tb = 0LL;
        asnprintf( d, z, "Virtual Channels on PTC %d\n", s->ptc);
        asnprintf( d, z, HR_FMT, "50%");
        asnprintf( d, z, "%s     Tables  Errors      Packets  Rate bits/s  KBytes/s\n",
                        "Virtual Channels");
/* if live, show the rates per VC ES */
//      if (CAP_NONE != cap_now)
        {
            for (i = 0; i < vc_ncs; i++) {

                char *sp = " ";         /* selected program or full cap is all *'s */

/* totals for each vc */
                tt = te = tp = tb = 0LL;

                if (CAP_NONE != cap_now) {
                    if (cap_pn == vc[i].pn) sp = "***";
                    if (-1 == cap_pn) sp = "***";
                } else {
                    if (s->pn == vc[i].pn) sp = "***";
                }

/* one video per vc */

/* video tables are number of payload starts, actually is video frame count */

                ln = (long long) psi_pids[ vc[i].espid[0] ];
                if (CAP_NONE == cap_now) ln = 0;
                tt += ln;
                lltoasc( c0, ln );

/* errors from cce_pids[ vc[i].espid[0] ] */
                ln = cce_pids[ vc[i].espid[0] ];
                if (CAP_NONE == cap_now) ln = 0;
                te += ln;
                lltoasc( c1, ln );

/* packet counts from pids[ vc[i].espid[0] ] */
                ln = (long long) pids[ vc[i].espid[0] ];
                if (CAP_NONE == cap_now) ln = 0;
                tp += ln;
                lltoasc( c2, ln );

/* bit count is packet count * 1504, rate is per ets */
                ln *= 188LL;
                ln <<= 3;
                ln /= ets;
                tb += ln;
                if (CAP_NONE == cap_now) ln = 0;
                lltoasc( c3, ln );
                ln >>= 13;
                if (CAP_NONE == cap_now) ln = 0;
                lltoasc( c4, ln );

/* look up name from tsids. if not found, fallback to vc.cname */
                k = find_tsidx( vc[i].tsid, vc[i].pn, WHO );
                u = vc[i].cname;
                if (k >= 0) u = tsids[k].call;

/* only lines up if component name < 10 chars */
                snprintf( uri, sizeof(uri), "?c=%d", i);
                asnprintf( d, z, "<a href=\042%s\042>%3s %7s</a>", uri, sp, u);
                asnprintf( d, z, " V0: %11s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

/* may have multiple audios */
                for (j = 0; j < vc[i].acn; j++) {
                    sp = " ";
                    if (CAP_NONE != cap_now) {
                        if (cap_pn == vc[i].pn)
                            if (cap_va == j) sp = "***";
                        if (-1 == cap_pn) sp = "***";
                    } else {
                        if (s->pn == vc[i].pn)
                            if (s->va == j) sp = "***";
                    }

/* audio tables are number of payload starts, audio frame count? */
                    ln = (long long) psi_pids[ vc[i].espid[j+1] ];
                    if (CAP_NONE == cap_now) ln = 0;
                    tt += ln;
                    lltoasc( c0, ln );

/* errors from cc[ vc[i].espid[j] ] */
                    ln = (long long) cce_pids[ vc[i].espid[j+1] ];
                    if (CAP_NONE == cap_now) ln = 0;
                    te += ln;
                    lltoasc( c1, ln );

/* counts from pids[ vc[i].espid[j] ] */
                    ln = (long long) pids[ vc[i].espid[j+1] ];
                    if (CAP_NONE == cap_now) ln = 0;
                    tp += ln;
                    lltoasc( c2, ln );

/* bit count is packet count * 1504, rate is per ets */
                    ln *= 188LL;
                    ln <<= 3;
                    ln /= ets;
                    tb += ln;
                    if (CAP_NONE == cap_now) ln = 0;
                    lltoasc( c3, ln );
                    ln >>= 13;
                    if (CAP_NONE != cap_now) ln = 0;
                    lltoasc( c4, ln );

/* audio call not needed, but lang might be useful. eng if lang is blank */
                    u = vc[i].eslang[j+1];
                    if (*u <= ' ') u = "eng";
                    snprintf( uri, sizeof(uri), "?c=%d,%d", i, j);

                    asnprintf( d, z, "<a href=\042%s\042>%3s %7s</a>",
                                uri, sp, u);
                    asnprintf( d, z, " A%d: %11s %7s %12s %12s  %8s\n",
                                j, c0, c1, c2, c3, c4 );
                }

/* only ever 2 transport tables for each program, 1 PAT + 1 PMT */
                lltoasc( c0, tt );
                lltoasc( c1, te );
                lltoasc( c2, tp );
                lltoasc( c3, tb );

/* divide by 8192 not 8000 */
                tb >>= 13;
                lltoasc( c4, tb);

                asnprintf( d, z, "        Totals: %11s %7s %12s %12s  %8s\n",
                                c0, c1, c2, c3, c4 );
// validator doesn't like this
//              asnprintf( d, z, HR_FMT, "70%");
            }
        }


        asnprintf( d, z, HR_FMT, "50%");


        lltoasc( c0, s->pkt.tserrt );
        lltoasc( c1, s->pkt.teiert );
        lltoasc( c2, s->pkt.tsccet );
        lltoasc( c3, s->pkt.synert );
        lltoasc( c4, s->pkt.tscert );

        asnprintf( d, z,"%s", "Transport Errors"
                "     Error Set"
                "    Continuity"
                "     Lost sync"
                "    Scrambled\n");

        asnprintf( d, z, "    %12s  %12s  %12s  %12s  %11s\n",
                c0, c1, c2, c3, c4 );


        asnprintf( d, z, "\n");

        asnprintf( d, z, "<a href=\042%s\042>ATSC Transport</a>", "?c=-3");
    if (0 == s->as) {
        asnprintf( d, z, "\n");
    } else {
        asnprintf( d, z, "       Tables  Errors      Packets  Rate bits/s  KBytes/s\n");

        lltoasc( c0, s->pkt.stt );
        lltoasc( c1, s->pkt.crcstt);
        lltoasc( c2, s->pkt.stt );
        lltoasc( c3, (s->pkt.stt * 1504LL) / ets);

        ln = (long long) s->pkt.stt;
        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->as)
            asnprintf( d, z, "       System Time: %7s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

        lltoasc( c0, s->pkt.mgt );
        lltoasc( c1, s->pkt.crcmgt);
        lltoasc( c2, s->pkt.mgtp );

        ln = (long long) s->pkt.mgtp;
        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->as)
            asnprintf( d, z, "      Master Guide: %7s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

        lltoasc( c0, s->pkt.tvct );
        lltoasc( c1, s->pkt.crctvct);
        lltoasc( c2, s->pkt.tvctp );

        ln = (long long) s->pkt.tvctp;
        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->as)
            asnprintf( d, z, " T Virtual Channel: %7s %7s %12s %12s  %8s\n",
                c0, c1, c2, c3, c4 );

        if (0 != arg_cable) {
                lltoasc( c0, s->pkt.cvct );
                lltoasc( c1, s->pkt.crccvct);
                lltoasc( c2, s->pkt.cvctp);

                ln = (long long) s->pkt.cvctp;
                ln *= 188LL;
                ln <<= 3;
                ln /= ets;
                lltoasc( c3, ln );

                ln >>= 13;
                lltoasc( c4, ln );

                if (0 != s->as)
                    asnprintf( d, z,
                                " C Virtual Channel: %7s %7s %12s %12s  %8s\n",
                                c0, c1, c2, c3, c4 );
                tp += s->pkt.cvctp;
                tt += s->pkt.cvct;    
                te += s->pkt.crccvct;
        }

        lltoasc( c0, s->pkt.eit );
        lltoasc( c1, s->pkt.crceit);
        lltoasc( c2, s->pkt.eitp );

        ln = (long long) s->pkt.eitp;
        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->as)
            asnprintf( d, z, " Event Information: %7s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

        lltoasc( c0, s->pkt.ett );
        lltoasc( c1, s->pkt.crcett);
        lltoasc( c2, s->pkt.ettp );

        ln = (long long) s->pkt.ettp;
        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->as)
            asnprintf( d, z, "     Extended Text: %7s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

        lltoasc( c0, s->pkt.rrt );
        lltoasc( c1, s->pkt.crcrrt);
        lltoasc( c2, s->pkt.rrtp );

        ln = (long long) s->pkt.rrtp;
        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->as)
            asnprintf( d, z, "     Rating Region: %7s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

        tp += s->pkt.mgtp + s->pkt.tvctp + s->pkt.eitp
            + s->pkt.ettp + s->pkt.rrtp + s->pkt.stt;

        tt += s->pkt.mgt + s->pkt.tvct + s->pkt.eit
            + s->pkt.ett + s->pkt.rrt + s->pkt.stt;

        te += s->pkt.crcmgt + s->pkt.crctvct + s->pkt.crceit
            + s->pkt.crcett + s->pkt.crcrrt + s->pkt.crcstt;

        tb = tp;
        tb *= 188LL;
        tb <<= 3;
        tb /= ets;

        lltoasc( c0, tt );
        lltoasc( c1, te );
        lltoasc( c2, tp );
        lltoasc( c3, tb );

/* divide by 8192 not 8000 */
        tb >>= 13;
        lltoasc( c4, tb );

        asnprintf( d, z, "            Totals: %7s %7s %12s %12s  %8s\n",
                 c0, c1, c2, c3, c4 );
        asnprintf( d, z, "\n");
    }

        tt = te = tp = tb = 0LL;


        asnprintf( d, z, "<a href=\042%s\042>MPEG Transport</a>", "?c=-2");
    if (0 == s->ms) {
        asnprintf( d, z, "\n");
    } else {
        asnprintf( d, z, "       Tables  Errors      Packets  Rate bits/s  KBytes/s\n");

        if (0 != s->ms)

        lltoasc( c0, s->pkt.pat );
        lltoasc( c1, s->pkt.crcpat );
        lltoasc( c2, s->pkt.patp );

        ln = (long long) s->pkt.patp;
        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->ms)
            asnprintf( d, z, "     Program Assoc: %7s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

        lltoasc( c0, s->pkt.pmt );
        lltoasc( c1, s->pkt.crcpmt );
        lltoasc( c2, s->pkt.pmtp );

        ln = (long long) s->pkt.pmtp;
        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->ms)
            asnprintf( d, z, "       Program Map: %7s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

        lltoasc( c0, 0LL );
        lltoasc( c1, 0LL ); /* FIXME: walk vc for all video CC */
        lltoasc( c2, s->pkt.vid );
        ln = (long long) s->pkt.vid;
        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->ms)
            asnprintf( d, z, "        MPEG Video: %7s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

        lltoasc( c0, 0LL );
        lltoasc( c1, 0LL ); /* FIXME: walk vc for all audio CC */
        lltoasc( c2, s->pkt.aud );

        ln = (long long) s->pkt.aud;
        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->ms)
            asnprintf( d, z, "        A/52 Audio: %7s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

        ln = (long long) s->pkt.null;
        if (ln > 0LL) ln = 1LL;
        lltoasc( c0, ln );
        ln = (long long) cce_pids[ 0x1FFF ];
        lltoasc( c1, ln );

        ln = (long long) s->pkt.null;
        lltoasc( c2, ln );

        ln *= 188LL;
        ln <<= 3;
        ln /= ets;
        lltoasc( c3, ln );

        ln >>= 13;
        lltoasc( c4, ln );

        if (0 != s->ms)
            asnprintf( d, z, "              Null: %7s %7s %12s %12s  %8s\n",
                        c0, c1, c2, c3, c4 );

        tt = s->pkt.pat + s->pkt.pmt;
        te = s->pkt.crcpat + s->pkt.crcpmt;
        tp = s->pkt.patp + s->pkt.pmtp + s->pkt.vid + s->pkt.aud + s->pkt.null;
        tb = (tp * 1504LL) / ets;

        lltoasc( c0, tt );
        lltoasc( c0, te );
        lltoasc( c2, tp );
        lltoasc( c3, tb );

/* divide by 8192 not 8000 */
        tb >>= 13;
        lltoasc( c4, tb );

        asnprintf( d, z, "            Totals: %7s %7s %12s %12s  %8s\n",
                c0, c1, c2, c3, c4 );

        asnprintf( d, z, "\n");
    }

        asnprintf( d, z, "</pre>\n");
        asnprintf( d, z, HR_FMT, "70%");
        asnprintf( d, z, "</center>\n");
        return;
}


/* Build div + ul + li, up to 7 li items supplied in c.
   ul list header centered, numbers are right justfied, text is left justified
    via the CSS classes for tsl tsul tslir tslil.

   d destination string
   z is max len of destination string
   dc is div class
   uc is ul class
   lc is li class
   c is 8 x 32 strings of 31 bytes each, c[0] is ul list header
     if c[240] non blank, use c[0] for text part of href built from c[240]

   n is number of items in c, including ul list header at c[0]
*/

void
build_stats_dl (char *d, int z, char *dc, char *uc, char *lc, char *c, int n)
{
        int i;
        char *s, *t, *b;
        
        char *div = "<div class=\042%s\042>\n"; 
        char *ul = "<ul class=\042tsul %s\042>\n";
        char *lh = "<li class=\042%s %s\042><b>%s</b></li>\n"; /* li header */
        char *li = "<li class=\042%s %s\042>%s</li>\n";
        char *ah = "<a class=\042%s\042 href=\042/%s\042>%s</a>";

        char hr[256];

        asnprintf(d, z, div, dc);
        asnprintf(d, z, ul, uc);

        b = lc;

        for (i = 0; i < n; i++) {
            lc = b;
            t = s = "";

/* check for href for list title. title is centered. href is at c[224] or \0 */
            if (0 == i) {
                s = c + 0xE0;
                if (0 == *s) {
                    asnprintf(d, z, lh, t, uc, c);
                } else {
                    snprintf(hr, sizeof(hr)-1, ah, "cfsv", s, c);
                    asnprintf(d, z, lh, t, uc, hr );
                *s = 0;
                }
            } else {
                s = c + (i*32);

/* if errors non-zero, change the color */
                if ((CAP_NONE != cap_now) && (2 == i)) {
                    if (0 != atoi(s)) lc = "red0";
                }

/* li is label on left */
                t = "tslil";

/* li is number on right */
                if ((*s >= '0') && (*s <= '9')) t = "tslir";
                asnprintf(d, z, li, t, lc, s );
            }
        }

        asnprintf(d, z, "</ul>\n");
        asnprintf(d, z, "</div>\n\n");

}

/* ATSC Table status */
#define AT_NO 0
#define AT_OK 1
#define AT_ERR 2
#define AT_MAX 3
/* Build capture stats as html into string at s, with maximum size z. */
/* CSS styles: tss tsl tsul tsli0 (normal) tsli1 (red) */
/* static */
void
build_stats_html4 (char *d, int z )
{
        time_t t, tu;           /* current time */
        long long tt, te, tp, tb; /* totals: packets, tables, errors, band */
        long long ets, n;

        int dd, hh, mm, ss;

        int i, j, k, vpn;
        char dt[ 32 ], uri[256], cl[256];
        char *u, *up, *tc[AT_MAX];                      /* text fields */

/* pointers to 32 byte string divisions of c[256] */
        char c[256], *c0, *c1, *c2, *c3, *c4, *c5, *c6, *c7;

        struct sig_s *s;
        struct pkt_s *p;

        s = &ptc[ cap_chan ].sig;

/* no cap shows last cap values, live cap shows current values */
        p = &s->pkt;
        if (CAP_NONE != cap_now) p = &pkt;

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);

        tc[AT_NO] = "black1";           /* table missing */
        tc[AT_OK] = "green1";           /* table normal */
        tc[AT_ERR] = "red1";            /* table error */

        k = AT_NO;                      /* shut up, compiler */

        u = "Log";      /* for Log href if any log available */

        tt = te = tp = tb = 0LL;
    
/* average rate starts inaccurate but as sample gets larger, it stabilizes */
        ets = (long long)utsets;
        if (CAP_NONE == cap_now) ets = (long long)s->cap_ets;
        if (ets < 1) ets = 1;

        memset(c, 0, sizeof(c));

/* 32 bytes per string, c holds 8 strings total */
        c0 = &c[0x00];
        c1 = &c[0x20];
        c2 = &c[0x40];
        c3 = &c[0x60];
        c4 = &c[0x80];
        c5 = &c[0xA0];

/* reserved for future use */
        c6 = &c[0xC0];
        c7 = &c[0xE0];

        t = (time_t) utsnow;
        ctime_r( &t, dt );
        dt[19] = 0;

        if (ets <1) ets = 1;

/* stats header */
        asnprintf(d, z, "<div class=\042%s\042>\n", "tssdiv");
        asnprintf(d, z, "<br class=\042%s\042 />\n", "br_tssdiv");
        asnprintf(d, z, "<br class=\042%s\042 />\n", "br_tssdiv");
        asnprintf(d, z, "<center>\n");

        tu = utsnow - utc_up;
        dd = tu / SECDAY;
        hh = (tu / SECHR) % 24;
        mm = (tu / SECMIN) % 60;
        ss = tu % 60;
        
        asnprintf(d, z, "%s, <i>Uptime %dd %02d:%02d:%02d</i>\n",
                    dt, dd, hh, mm, ss);

//      asnprintf(d, z, HR_FMT, "33%");

        filebase( cl, out_name, F_FILE);

/* info cap log html file was last log available? */
        up = "";
        if ((CAP_INFO == cap_now) || (CAP_INFO == cap_prev))
            up = "pg/";

        asnprintf(d, z, "<br />\n");
        asnprintf(d, z, "ATSC and MPEG Transport Stream Rates %ds\n", ets);
        asnprintf(d, z, "<br />\n");

        vpn = cap_pn;
        if (CAP_NONE == cap_now) vpn = s->pn;

        asnprintf(d, z, "LCN %d %s %s PTC %d.%d TSID %04X\n",
                        cap_chan, s->call, s->sid, s->ptc, vpn, vc[0].tsid);
        asnprintf(d, z, "<br />\n");

/* FIXME: presumes *p is 0 if info cap
   TODO: don't show blank link
*/
        if (0 != *cl) {

            hh = utsets / SECHR;
            mm = (utsets / SECMIN) % 60;
            ss = utsets % 60;

            filebase( uri, cl, F_TFILE);
            asnprintf(d, z, "<a class=\042%s\042 "
                            "href=\042/%s%s.html\042>", "green", up, uri);

            asnprintf(d, z, "%s %s", u, cl);

            asnprintf(d, z, "</a>");
            asnprintf(d, z, " ET %02d:%02d:%02d", hh, mm, ss);
        }


        asnprintf(d, z, HR_FMT "\n", "25%");
        asnprintf(d, z, "</center>\n");

        asnprintf(d, z, "<div class=\042%s\042>\n", "tss");

/* stats error summary */

        k = AT_OK;
        if (0 != p->tserrt) k = AT_ERR;
        snprintf(c0, 31, "TS Errors");
        lltoasc( c1, p->tserrt );
        build_stats_dl(d, z, "tsl", tc[k], "green0", c, 2);

        k = AT_OK;
        if (0 != p->teiert) k = AT_ERR;
        snprintf(c0, 31, "TEI Set");
        lltoasc( c1, p->teiert );
        build_stats_dl(d, z, "tsl", tc[k], "green0", c, 2);

        k = AT_OK;
        if (0 != p->tsccet) k = AT_ERR;
        snprintf(c0, 31, "CC Errs");
        lltoasc( c1, p->tsccet );
        build_stats_dl(d, z, "tsl", tc[k], "green0", c, 2);

        k = AT_OK;
        if (0 != p->synert) k = AT_ERR;
        snprintf(c0, 31, "Sync Errs");
        lltoasc( c1, p->synert );
        build_stats_dl(d, z, "tsl", tc[k], "green0", c, 2);

        k = AT_OK;
        if (0 != p->tscert) k = AT_ERR;
        snprintf(c0, 31, "Scrambled");
        lltoasc( c1, p->tscert );
        build_stats_dl(d, z, "tsl", tc[k], "green0", c, 2);

        asnprintf(d, z, "<br class=\042%s\042 />\n", "br_tssdiv");
        asnprintf(d, z, HR_FMT "\n", "25%");

/* stats table summary */

        tc[AT_OK] = "cyan1";
        snprintf(c0, 31, "ATSC");
        snprintf(c1, 31, "Tables");
        snprintf(c2, 31, "Errors");
        snprintf(c3, 31, "Packets");
        snprintf(c4, 31, "Bits/s");
        snprintf(c5, 31, "Kbytes/s");

        snprintf(c7, 31, "%s%d.html?c=%d", NAME, arg_devnum, -3);
        build_stats_dl(d, z, "tsl", tc[AT_OK], "cyan0", c, 6);

        k = AT_NO;
        if (0 != p->stt) k = AT_OK;
        if (0 != p->crcstt) k = AT_ERR;

        snprintf(c0, 31, "STT");
        lltoasc( c1, p->stt );
        lltoasc( c2, p->crcstt);
        lltoasc( c3, p->stt ); /* table count is same as packet count */
        n = (long long) p->stt;
        n *= 188LL;
        n <<= 3;
        n /= ets;
        lltoasc( c4, n );
        n >>= 13;               /* NOTE: KB is /1024 not /1000 */
        lltoasc( c5, n );

        if ((0 != s->as) && (p->stt > 0))
                build_stats_dl(d, z, "tsl", tc[k], "cyan0", c, 6);


        k = AT_NO;
        if (0 != p->mgt) k = AT_OK;
        if (0 != p->crcmgt) k = AT_ERR;
        snprintf(c0, 31, "MGT");
        lltoasc( c1, p->mgt );
        lltoasc( c2, p->crcmgt);
        lltoasc( c3, p->mgtp );
        n = (long long) p->mgtp;
        n *= 188LL;
        n <<= 3;
        n /= ets;
        lltoasc( c4, n );
        n >>= 13;
        lltoasc( c5, n );

        if ((0 != s->as) && (p->mgtp > 0))
                build_stats_dl(d, z, "tsl", tc[k], "cyan0", c, 6);

        if (0 == arg_cable) {
                k = AT_NO;
                if (0 != p->tvct) k = AT_OK;
                if (0 != p->crctvct) k = AT_ERR;
                snprintf(c0, 31, "TVCT");
                lltoasc( c1, p->tvct );
                lltoasc( c2, p->crctvct);
                lltoasc( c3, p->tvctp );
                n = (long long) p->tvctp;
                n *= 188LL;
                n <<= 3;
                n /= ets;
                lltoasc( c4, n );
                n >>= 13;
                lltoasc( c5, n );

                if ((0 != s->as) && (p->tvctp > 0))
                        build_stats_dl(d, z, "tsl", tc[k], "cyan0", c, 6);
        } else {

                k = AT_NO;
                if (0 != p->cvct) k = AT_OK;
                if (0 != p->crccvct) k = AT_ERR;
                snprintf(c0, 31, "CVCT");
                lltoasc( c1, p->cvct );
                lltoasc( c2, p->crccvct);
                lltoasc( c3, p->cvctp);
                n = (long long) p->cvctp;
                n *= 188LL;
                n <<= 3;
                n /= ets;
                lltoasc( c4, n );
                n >>= 13;
                lltoasc( c5, n );
                tp += p->cvctp;
                tt += p->cvct;    
                te += p->crccvct;
                if ((0 != s->as) && (p->cvctp > 0))
                        build_stats_dl(d, z, "tsl", tc[k], "cyan0", c, 6);
        }

        k = AT_NO;
        if (0 != p->eit) k = AT_OK;
        if (0 != p->crceit) k = AT_ERR;
        snprintf(c0, 31, "EIT");
        lltoasc( c1, p->eit );
        lltoasc( c2, p->crceit);
        lltoasc( c3, p->eitp );
        n = (long long) p->eitp;
        n *= 188LL;
        n <<= 3;
        n /= ets;
        lltoasc( c4, n );
        n >>= 13;
        lltoasc( c5, n );

        if ((0 != s->as) && (p->eitp > 0))
                build_stats_dl(d, z, "tsl", tc[k], "cyan0", c, 6);

        k = AT_NO;
        if (0 != p->ett) k = AT_OK;
        if (0 != p->crcett) k = AT_ERR;
        snprintf(c0, 31, "ETT");
        lltoasc( c1, p->ett );
        lltoasc( c2, p->crcett);
        lltoasc( c3, p->ettp );
        n = (long long) p->ettp;
        n *= 188LL;
        n <<= 3;
        n /= ets;
        lltoasc( c4, n );
        n >>= 13;
        lltoasc( c5, n );

        if ((0 != s->as) && (p->ettp > 0))
                build_stats_dl(d, z, "tsl", tc[k], "cyan0", c, 6);

#if USE_RRT_CSS_STATS
        k = AT_NO;
        if (0 != p->rrt) k = AT_OK;
        if (0 != p->crcrrt) k = AT_ERR;
        snprintf(c0, 31, "RRT");
        lltoasc( c1, p->rrt );
        lltoasc( c2, p->crcrrt);
        lltoasc( c3, p->rrtp );
        n = (long long) p->rrtp;
        n *= 188LL;
        n <<= 3;
        n /= ets;
        lltoasc( c4, n );
        n >>= 13;
        lltoasc( c5, n );

        if ((0 != s->as) && (p->rrtp > 0))
                build_stats_dl(d, z, "tsl", tc[k], "cyan0", c, 6);
#endif


        tp += p->mgtp + p->tvctp + p->eitp + p->ettp + p->rrtp + p->stt;
        tt += p->mgt + p->tvct + p->eit + p->ett + p->rrt + p->stt;

        te += p->crcmgt + p->crctvct + p->crceit + p->crcett
                    + p->crcrrt + p->crcstt;
        tb = tp;
        tb *= 188LL;
        tb <<= 3;
        tb /= ets;
        snprintf(c0, 31, "ATSC");
        lltoasc( c1, tt );
        lltoasc( c2, te );
        lltoasc( c3, tp );
        lltoasc( c4, tb );
        tb >>= 13;
        lltoasc( c5, tb );

        snprintf(c7, 31, "%s%d.html?c=%d", NAME, arg_devnum, -3);

        if ((0 != s->as) && (tp > 0))
                build_stats_dl(d, z, "tsl", "cyan0", "cyan0", c, 6);

//      asnprintf(d, z, "<br class=\042%s\042 />\n", "br_tssdiv");
//      asnprintf(d, z, HR_FMT "\n", "25%");

        tt = te = tp = tb = 0LL;

/* TODO: show video and audio dimensions as 1920x1080i 5.0 */
        snprintf(c0, 31, "MPEG");
        if (CAP_NONE == cap_now) {
            snprintf(c1, 31, "Size");
            snprintf(c2, 31, "Rate");
            snprintf(c3, 31, "Packets");
            snprintf(c4, 31, "Bits/s");
            snprintf(c5, 31, "Kbytes/s");

        } else {
            snprintf(c1, 31, "Tables");
            snprintf(c2, 31, "Errors");
            snprintf(c3, 31, "Packets");
            snprintf(c4, 31, "Bits/s");
            snprintf(c5, 31, "Kbytes/s");
        }


        snprintf(c7, 31, "%s%d.html?c=%d", NAME, arg_devnum, -2);
        build_stats_dl(d, z, "tsl", "green1", "green0", c, 6);

        tc[AT_OK] = "green1";

        k = AT_NO;
        if (0 != p->pat) k = AT_OK;
        if (0 != p->crcpat) k = AT_ERR;
        snprintf(c0, 31, "PAT");
        lltoasc( c1, p->pat );
        lltoasc( c2, p->crcpat );
        lltoasc( c3, p->patp );
        n = (long long) p->patp;
        n *= 188LL;
        n <<= 3;
        n /= ets;
        lltoasc( c4, n );
        n >>= 13;
        lltoasc( c5, n );

        if ((0 != s->ms) && (p->patp > 0))
                build_stats_dl(d, z, "tsl", tc[k], "green0", c, 6);

        k = AT_NO;
        if (0 != arg_cable) {
                if (0 != p->cat) k = AT_OK;
                if (0 != p->crccat) k = AT_ERR;
                snprintf(c0, 31, "CAT");
                lltoasc( c1, p->cat );
                lltoasc( c2, p->crccat );
                lltoasc( c3, p->catp );
                n = (long long) p->catp;
                n *= 188LL;
                n <<= 3;
                n /= ets;
                lltoasc( c4, n );
                n >>= 13;
                lltoasc( c5, n );
                if ((0 != s->ms) && (p->catp > 0))
                        build_stats_dl(d, z, "tsl", tc[k], "green0", c, 6);
        }

        k = AT_NO;
        if (0 != p->pmt) k = AT_OK;
        if (0 != p->crcpmt) k = AT_ERR;
        snprintf(c0, 31, "PMT");
        lltoasc( c1, p->pmt );
        lltoasc( c2, p->crcpmt );
        lltoasc( c3, p->pmtp );
        n = (long long) p->pmtp;
        n *= 188LL;
        n <<= 3;
        n /= ets;
        lltoasc( c4, n );
        n >>= 13;
        lltoasc( c5, n );

        if ((0 != s->ms) && (p->pmtp > 0))
                build_stats_dl(d, z, "tsl", tc[k], "green0", c, 6);

/* FIXME: walk vc for all video and audio CC for errors. PITA */
        k = AT_NO;
        if (0 != p->vid) k = AT_OK;
        snprintf(c0, 31, "VID");
        lltoasc( c1, 0LL );
        lltoasc( c2, 0LL );
        lltoasc( c3, p->vid );
        n = (long long) p->vid;
        n *= 188LL;
        n <<= 3;
        n /= ets;
        lltoasc( c4, n );
        n >>= 13;
        lltoasc( c5, n );

        if ((0 != s->ms) && (p->vid > 0))
                build_stats_dl(d, z, "tsl", tc[k], "green0", c, 6);

        k = AT_NO;
        if (0 != p->aud) k = AT_OK;
        snprintf(c0, 31, "AUD");
        lltoasc( c1, 0LL );
        lltoasc( c2, 0LL ); /* FIXME: walk vc for all audio CC */
        lltoasc( c3, p->aud );
        n = (long long) p->aud;
        n *= 188LL;
        n <<= 3;
        n /= ets;
        lltoasc( c4, n );
        n >>= 13;
        lltoasc( c5, n );

        if ((0 != s->ms) && (p->aud > 0))
                build_stats_dl(d, z, "tsl", tc[k], "green0", c, 6);

        k = AT_NO;
/* only show red title if -n and no nulls found */
        if (0 != arg_nulls) {
                if (0 != p->null) k = AT_OK;
        }
        snprintf(c0, 31, "NULL");
        n = (long long) p->null;
        if (n > 0LL) n = 1LL;
        lltoasc( c1, n );
        n = (long long) cce_pids[ 0x1FFF ];
        lltoasc( c2, n );
        n = (long long) p->null;
        lltoasc( c3, n );
        n *= 188LL;
        n <<= 3;
        n /= ets;
        lltoasc( c4, n );
        n >>= 13;
        lltoasc( c5, n );

        if ((0 != s->ms) && (p->null > 0))
                build_stats_dl(d, z, "tsl", "green1", "grey0", c, 6);

        tt = p->pat + p->pmt;
        te = p->crcpat + p->crcpmt;
        tp = p->patp + p->pmtp + p->vid + p->aud + p->null;
        tb = (tp * 1504LL) / ets;

        snprintf(c0, 31, "MPEG");
        lltoasc( c1, tt );
        lltoasc( c2, te );
        lltoasc( c3, tp );
        lltoasc( c4, tb );
        tb >>= 13;
        lltoasc( c5, tb );

        snprintf(c7, 31, "%s%d.html?c=%d", NAME, arg_devnum, -2);

        if ((0 != s->ms) && (tp > 0))
            build_stats_dl(d, z, "tsl", "green1", "green1", c, 6);

        tt = te = tp = tb = 0LL;

/* The fixme probably isn't as important as being able to select a VC */

/***** FIXME: This is a data collection desync point. It will only show the
   last vc information from last capture, because it's not stored by channel.
   cce_pids, psi_pids, and pids[] have to be stored on per channel basis.
   This will add approximately 12Mbyte to overall ptc[] size. Not a good thing.
   PID list shortening is drastically needed for this to be workable,
   but then you have to spend a few cycles on the list comparison.
*/
/* There shall be at most only one video per virtual channel pgm for ATSC. */
/* Walk vc[] for each virtual channel program. */
        for (i = 0; i < vc_ncs; i++) {

/* selected program and audio, or full cap, has '*' */
                char *sp;       /* unselected program color */
                char hr[256];
                short tf;

                *hr = 0;

                memset( c, 0, sizeof(c));

                sp = "grey1";
//              asnprintf(d, z, "<br class=\042%s\042 />\n", "br_epgdiv");
//              asnprintf(d, z, "<hr width=\042%s\042 />\n", "33%");

                if (0 == vc[i].pn) continue;            /* no 0 program */
                if (65535 == vc[i].pn) continue;        /* no NTSC listing */
                if (0 == vc[i].pmtes) continue;
                if (0 != vc[i].ca) continue;            /* no ca ca ca */

/* shows only the set program stats if capture in progress */
                if ((CAP_NONE != cap_now)
                  && (CAP_INFO != cap_now)) {
                    if ((cap_pn > 0) && (cap_pn != vc[i].pn))
                            continue;
                    sp = "white0";
                }

                if ( (CAP_NONE == cap_now)
                  && ((s->pn == vc[i].pn) || (-1 == s->pn)) )
                        sp = "white0";

/* TESTME: move this higher to legend text too, or leave for visual index? */
//              if (CAP_INFO == cap_now) sp = "grey1";


/* TODO: VC select from stats page */

#if 0
/* try vc name and cname, and fallback to callsign and finally ptc.pn */
                if (0 != vc[i].name)
                    snprintf(c0, 31, "%s", vc[i].name);

/* component name as likely to be wrong on cable or broadcast */
                if (0 != arg_cable)
                    if (0 == *c0)
                        snprintf(c0, 31, "%s", vc[i].cname);

                if (0 == *c0)
                        snprintf(c0, 31, "%s", s->call);
#endif

/* tsid lookup */
                if (0 == *c0) {
                    tf = find_tsidx( vc[i].tsid, vc[i].pn, WHO );
                    if (tf >= 0)
                        snprintf(c0, 31, "%s", tsids[ tf ].call);
                }

                if (0 == *c0) {
                        snprintf(c0, 31, "%d.%d", s->ptc, vc[i].pn);
//                      snprintf(c0, 31, "%04X.%d", vc[i].tsid, vc[i].pn);
                }

#if USE_FULL_TABLES
                snprintf(c1, 31, "Tables");
                snprintf(c2, 31, "Errors");
                snprintf(c3, 31, "Packets");
                snprintf(c4, 31, "Bits/s");
                snprintf(c5, 31, "Kbytes/s");
                build_stats_dl(d, z, "tsl", "white1", sp, c, 6);
#endif

/* totals for each vc */
                tt = te = tp = tb = 0LL;


/* video tables are number of payload starts, actually is video frame count */
#ifdef USE_FULL_TABLES
                snprintf(c0, 31, "VID%d ", i);
#endif
                if (CAP_NONE != cap_now) {
                    n = (long long) psi_pids[ vc[i].espid[0] ];
                    tt += n;
                    lltoasc( c1, n );
/* errors from cce_pids[ vc[i].espid[0] ] */
                    n = cce_pids[ vc[i].espid[0] ];
                    te += n;
                    lltoasc( c2, n );
/* packet counts from pids[ vc[i].espid[0] ] */
                    n = (long long) pids[ vc[i].espid[0] ];
                    tp += n;
                    lltoasc( c3, n );
                    n *= 188LL;
                    n <<= 3;
                    n /= ets;
                    tb += n;
                    lltoasc( c4, n );
                    n >>= 13;
                    lltoasc( c5, n );
                } else {

/* video dimensions and frame rate from SEQ header */
                    snprintf(c1, 31, "%dx%d", vc[i].hres, vc[i].vres);
                    snprintf(c2, 31, "%d.%d", vc[i].vfr/100, vc[i].vfr % 100);
                    strcpy(c3, "0");
                    strcpy(c4, "0");
                    strcpy(c5, "0");
                }

/* http video program select, resets audio to 0 */
                snprintf(c7, 31, "%s%d.html?c=%d", NAME, arg_devnum, i );

                build_stats_dl(d, z, "tsl", "green1", sp, c, 6);

/* There may be more than one audio for each virtual channel pgm for ATSC. */
                for (j = 1; j < vc[i].acn+1; j++) {

                    memset(c, 0, sizeof(c));

/* pre-fill these with something to maintain dl spacing and grid size */
                    strcpy(c0, "Audio");
                    if (2 == j) strcpy(c0, "SAP");
                    strcpy(c1, "0");

                    sp = "grey1";

                    if ( (CAP_NONE != cap_now)
                      && (CAP_INFO != cap_now) ) {

                            if ( (-1 != cap_pn)
                              && (cap_pn == vc[i].pn)
                              && (cap_va != (j - 1)) )
                                    continue;

                            sp = "white0";
                    }

                    if ( (CAP_NONE == cap_now)
                      && (s->pn == vc[i].pn)
                      && (s->va == (j - 1)) )
                            sp = "white0";

                    if ( (CAP_NONE == cap_now)
                      && (-1 == s->pn) )
                            sp = "white0";

                    if (CAP_INFO == cap_now) sp = "grey1";

/* audio number and language */

                    snprintf(c0, 31, "A%d %s", j-1, vc[i].eslang[j] );

/* live cap gets tables and error status */
                    if (CAP_NONE != cap_now) {

/* audio tables are number of payload starts. video is number of pictures. */
                        n = (long long) psi_pids[ vc[i].espid[j] ];
                        tt += n;
                        lltoasc( c1, n );

/* continuity counter errors */
                        n = (long long) cce_pids[ vc[i].espid[j] ];
                        te += n;
                        lltoasc( c2, n );
/* counts from pids[ vc[i].espid[j] ] */
                        n = (long long) pids[ vc[i].espid[j] ];
                        tp += n;
                        lltoasc( c3, n );
                        n *= 188LL;
                        n <<= 3;
                        n /= ets;
                        tb += n;
                        lltoasc( c4, n );
                        n >>= 13;
                        lltoasc( c5, n );
                    } else {

/* idle shows video frame size plus rate and audio channels plus bitrate */
                        if (1 == vc[i].ach[ j ])        strcpy(c1, "1.0 Mono");
                        if (2 == vc[i].ach[ j ])        strcpy(c1, "2.0 Stereo");
                        if (5 == vc[i].ach[ j ])        strcpy(c1, "5.1 Low");
                        if (6 == vc[i].ach[ j ])        strcpy(c1, "5.1 High");

/* limit to 1024k bits per second rate and set reserved rate to 0 */
                        n = 0xFFFFF & vc[i].abr[ j ];
                        if (0xFFFFF == n) n = 0;
                        lltoasc( c2, n );
                        strcpy(c3, "0");
                        strcpy(c4, "0");
                        strcpy(c5, "0");
                    }

/* http video program audio select, only if more than one audio */
                    if (vc[i].acn > 1)
                        snprintf(c7, 31, "%s%d.html?c=%d,%d",
                                NAME, arg_devnum, i, j-1 );

//                  build_stats_dl(d, z, "tsl", "green1", sp, c, 6);
                    build_stats_dl(d, z, "tsl", sp, sp, c, 6);
                }

#if 0
/* only ever 2 transport tables for each program, 1 PAT + 1 PMT except
   cable has 3 but no way to really use the CAT other than to identify
   streams that are NOT encrypted. most are encrypted or non-mpeg
*/
                snprintf(c0, 31, "PGM.%d", vc[i].pn );
                lltoasc( c1, tt );
                lltoasc( c2, te );
                lltoasc( c3, tp );
                lltoasc( c4, tb );
                tb >>= 13;
                lltoasc( c5, tb );
                build_stats_dl(d, z, "tsl", "white1", sp, c, 6);
#endif
        }

        asnprintf(d, z, "</div>\n\n"); /* tss */
        asnprintf(d, z, "</div>\n\n"); /* f5 at top */
        return;
}

/* static */
void
build_html_stats ( char *s, int z )
{
        if (0 == use_css) build_stats_html3(s, z);
        if (0 != use_css) build_stats_html4(s, z);
}

#define CC "class=\042"
#define CC1 "class=\042%s\042 "
#define CC2 "class=\042%s%s\042 "

/* static */
void
build_epg_filter_html4( char *d, int z )
{
        int i, j;
        char r[256], *lt, *a[3], *b[3], *c[2], *s, *f, *h;
        struct pgm_s *p;

        a[0] = "<img class=\042cfgbi\042 alt=\042ON\042 src=\042/pg/img/on24.png\042 />";
        a[1] = "<img class=\042cfgbi\042 alt=\042OFF\042 src=\042/pg/img/off24.png\042 />";

/* button legend image type, no background */
        a[2] = "<img class=\042cfgbli\042 alt=\042%s\042 src=\042%s\042 />";

        b[0] = "cfgbt1"; /* unselected button, grip style bright bg */
        b[1] = "cfgbt0"; /* selected button, grip style dark bg */
        b[2] = "cfgbt2"; /* EPG related style, smooth no bright/dim bg */

        c[0] = "cfgba1"; /* unselected button href, action is opposite */
        c[1] = "cfgba0"; /* selected button href, action is opposite */

        s = " SNR ";    /* SNR in dB RMS last 50 samples */
        f = " Freq ";   /* Frequency drift for arg_extras button */

/* auto-epg/sig button legends (different style for legend button) */
        h = "cfgbl";

        p = &pgm3;

        lt = "div";

        snprintf(r, sizeof(r)-1, "%02d", p->chan);

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);

        asnprintf(d, z, "<div " CC1 ">\n", "cfg");

/* filters for the EPG */
        j = 0;
        if (0 == p->find) j = 1;
        asnprintf(d, z, "<%s " CC "%s %s\042>", lt, "cyan1", b[2] );
        asnprintf(d, z, "<a " CC "%s%s\042 href=\042%s.html?m=%d\042>%s%s</a>",
                            c[j], "", r, j, a[j], " Find " );
        asnprintf(d, z, "</%s>\n", lt);

        j = 0;
        if (0 == p->hide) j = 1;
        asnprintf(d, z, "<%s " CC "%s %s\042>", lt, "grey1", b[2] );
        asnprintf(d, z, "<a " CC1 "href=\042%s.html?h=%d\042>%s%s</a>",
                            c[j], r, j, a[j], " Junk " );
        asnprintf(d, z, "</%s>\n", lt);

        j = 0;
        if (0 == p->age) j = 1;
        asnprintf(d, z, "<%s " CC "%s %s\042>", lt, "magenta1", b[2] );
        asnprintf(d, z, "<a " CC "%s %s\042 href=\042%s.html?o=%d\042>%s%s</a>",
                            c[j], "black", r, j, a[j], " Aged " );
        asnprintf(d, z, "</%s>\n", lt);

        j = 0;
        if (0 == web_config) j = 1;
        asnprintf(d, z, "<div " CC1 ">", b[j]);
        asnprintf(d, z, "<a " CC1 "href=\042%s.html?l=2\042>%s%s</a>",
                        c[j], r, a[j],
                        (0 != j) ? " More " : " Less ");
        asnprintf(d, z, "</div>\n");

        if (0 == web_config) return;

        j = 0;
        if (0 == web_legend) j = 1;
        asnprintf(d, z, "<%s " CC1 ">", lt, b[j]);
        asnprintf(d, z, "<a " CC1 "href=\042%s.html?l=1\042>%s%s</a>",
                  c[j], r, a[j], " Help ");
        asnprintf(d, z, "</%s>\n", lt);

        for (i = 0; i < SGML_FMT; i++) {
                j = 0;
                if (use_css != i) j = 1;
                asnprintf(d, z, "<%s " CC "%s%s\042>", lt, b[2], " grey1");

                asnprintf(d, z, "<a " CC1 " href=\042%s.html?f=%d\042>",
                            c[j], r, i );
                if (1 == j) {
                    asnprintf(d, z, a[j]);
                } else {
                    asnprintf(d, z, "<img class=\042cfgbi black\042 "
                                    "alt=\042OFF\042 "
                                    "src=\042/pg/img/rec24.png\042 />");
                }
                asnprintf(d, z, " %s</a>", sgmls[ (i * 2) ]);

                asnprintf(d, z, "</%s>\n", lt);
        }


        j = 0;
        if (0 == epg_grd) j = 1;

        asnprintf(d, z, "<%s " CC "%s %s\042>", lt, "grey1", b[2]);
        asnprintf(d, z, "<a " CC1
                        "href=\042%s.html?f=4\042>%s%s</a>",
                            c[j], r, a[j], " Fills " );

        asnprintf(d, z, "</%s>\n", lt);

        j = 0;
        if (0 == epg_all) j = 1;

        asnprintf(d, z, "<%s " CC "%s %s\042>", lt, "grey1", b[2]);
        asnprintf(d, z, "<a " CC1
                        "href=\042%s.html?f=16\042>%s%s</a>",
                            c[j], r, a[j], " All " );

        asnprintf(d, z, "</%s>\n", lt);


/* large tiles get scrollbar toggle */
        if (use_css == 1) {
                j = 0;
                if (0 == epg_sb) j = 1;

/* use epg style buttons */
                asnprintf(d, z, "<%s " CC "%s %s\042>", lt, "grey1", b[2]);
                asnprintf(d, z, "<a " CC1
                        " href=\042%s.html?f=8\042>%s%s</a>",
                        c[j], r, a[j], " Scroll ");
                asnprintf(d, z, "</%s>\n", lt);
        }
//      asnprintf(d, z, "</div>\n\n");
}


/* This goes is the server configuration page under the signal charts.
    It has the toggles for various displays on this page.
    Gold sphere is on, black sphere is off.
*/
static
void
build_cfg_buttons_html4( char *d, int z )
{
        int j;
        char *a[3], *b[3], *c[2], *s, *f, *h;
        struct pgm_s *p;

        if (0 == use_css) return;

        a[0] = "<img class=\042cfgbi\042 alt=\042ON\042 src=\042/pg/img/on24.png\042 />";
        a[1] = "<img class=\042cfgbi\042 alt=\042OFF\042 src=\042/pg/img/off24.png\042 />";

/* button legend image type, no background */
        a[2] = "<img class=\042cfgbli\042 alt=\042%s\042 src=\042%s\042 />";

        b[0] = "cfgbt1"; /* unselected button, grip style bright bg */
        b[1] = "cfgbt0"; /* selected button, grip style dark bg */
        b[2] = "cfgbt2"; /* EPG related style, smooth no bright/dim bg */

        c[0] = "cfgba1"; /* unselected button href, action is opposite */
        c[1] = "cfgba0"; /* selected button href, action is opposite */

        s = " SNR ";    /* SNR in dB RMS last 50 samples */
        f = " Freq ";   /* Frequency drift for arg_extras button */

/* auto-epg/sig button legends (different style for legend button) */
        h = "cfgbl";

        p = &pgm3;

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);

//      asnprintf(d, z, "<br " CC1 "/>\n", "br_epgdiv");
        asnprintf(d, z, "<div " CC1 ">\n", "cfg");

/* html text mode gets text instead of spheres for config toggles
   (mostly done, need to add PNG toggle back to html3 mode)
*/


        j = 0;
        if (0 == web_config) j = 1;
        asnprintf(d, z, "<div " CC1 ">", b[j]);
        asnprintf(d, z, "<a " CC1 "href=\042%s%d.html?l=2\042>%s%s</a>",
                        c[j], NAME, arg_devnum, a[j],
                        (0 != j) ? " More " : " Less ");
        asnprintf(d, z, "</div>\n");


        if (0 == web_config) {
            asnprintf(d, z, "</div>\n");
            asnprintf(d, z, "<br " CC1 "/>\n", "br_epgdiv");
            return;
        }

        j = 0;
        if (0 == web_legend) j = 1;
        asnprintf(d, z, "<div " CC1 ">", b[j]);
        asnprintf(d, z, "<a " CC1 "href=\042%s%d.html?l=1\042>%s%s</a>",
                  c[j], NAME, arg_devnum, a[j], " Help ");
        asnprintf(d, z, "</div>\n");

        j = 0;
        if (0 == use_css) j = 1;
        asnprintf(d, z, "<div " CC1 ">", b[j]);
        asnprintf(d, z, "<a " CC1 "href=\042%s%d.html?f=%d\042>%s%s</a>",
                  c[j], NAME, arg_devnum, j, a[j], (0 == j)?" HTML ":" CSS");
        asnprintf(d, z, "</div>\n");

#ifdef USE_DVB_EXPERIMENTAL
/* CUSTOM: Frequency Drift in KHz toggle, is on top so goes first if used */
        if (0 != arg_extras) {
            j = 0;
            if (0 == scan_khz) j = 1;
            asnprintf(d, z, "<div " CC1 ">", b[j]);
            asnprintf(d, z, "<a " CC1 "href=\042%s%d.html?q=2\042>%s%s</a>",
                            c[j], NAME, arg_devnum, a[j], " Freq " );
            asnprintf(d, z, "</div>\n");
        }
#endif

/* Signal Display as SNR or Strength % toggle */
        j = 0;
        if (0 == scan_snr) j = 1;
        asnprintf(d, z, "<div " CC1 ">", b[j]);
        asnprintf(d, z, "<a " CC1 "href=\042%s%d.html?q=1\042>%s%s</a>",
                            c[j], NAME, arg_devnum, a[j], " SNR " );
        asnprintf(d, z, "</div>\n");

/* Transport Stream Statistics with Bitrates */
        j = 0;
        if (0 == web_stats) j = 1;
        asnprintf(d, z, "<div " CC1 ">", b[j]);
        asnprintf(d, z, "<a " CC1 "href=\042%s%d.html?k=%d\042>%s%s</a>",
                        c[j], NAME, arg_devnum, j, a[j], " Stats ");
        asnprintf(d, z, "</div>\n");


// moved to epg pages
//      build_epg_filter_html4(d, z );

/* Signal chart PNG display on/off */
        j = 0;
        if (0 == scan_png) j = 1;
        asnprintf(d, z, "<div " CC1 ">", b[j]);
        asnprintf(d, z, "<a " CC1
                    "href=\042%s%d.html?p=%d\042>%s%s</a>",
                    c[j], NAME, arg_devnum,
                    (0 == scan_png) ? 1:0, a[j], " PNG " );
        asnprintf(d, z, "</div>\n");

/* Signal Scanner for all channels start or stop */
        if (CAP_NONE == cap_now) {
                j = 1;

//              j = 0;
//              if (0 != scan_one) j = 1;

                if (0 != scan_sig) j = 0;
                asnprintf(d, z, "<div " CC1 ">", b[j]);
                asnprintf(d, z, "<a " CC1
                                "href=\042%s%d.html?w=%d\042>%s%s</a>",
                        c[j], NAME, arg_devnum, j, a[j], " Scan " );
                asnprintf(d, z, "</div>\n");
        }

/* legend buttons */
        if (0 != web_legend) {
//              asnprintf(d, z, "<div " CC1 ">\n", "cfgleg");
//              asnprintf(d, z, "<br " CC1 "/>\n", "br_cfgdiv");
                asnprintf(d, z, "<div " CC1 ">", h);
                asnprintf(d, z, a[2], "EPG-", "/pg/img/epgon24.png", 0);
                asnprintf(d, z, " EPG- ");
                asnprintf(d, z, "</div>\n");

                asnprintf(d, z, "<div " CC1 ">", h);
                asnprintf(d, z, a[2], "EPG+", "/pg/img/epgoff24.png", 0);
                asnprintf(d, z, " EPG+ ");
                asnprintf(d, z, "</div>\n");

                asnprintf(d, z, "<div " CC1 ">", h);
                asnprintf(d, z, a[2], "LIVE", "/pg/img/epglive24.png", 0);
                asnprintf(d, z, " Live ");
                asnprintf(d, z, "</div>\n");

                asnprintf(d, z, "<div " CC1 ">", h);
                asnprintf(d, z, a[2], "SCAN", "/pg/img/scanon24.png", 0);
                asnprintf(d, z, " Scan ");
                asnprintf(d, z, "</div>\n");
//              asnprintf(d, z, "</div>\n");
        }

        asnprintf(d, z, "</div>\n");
        asnprintf(d, z, "<br " CC1 "/>\n", "br_epgdiv");

}



/* Main server configuration page:
    Server nav
    Channel nav

    Enable/disable auto-epg for each channel
    Scan each channel or all channels

    Legend
    CSS server option buttons

    footer with valid HTML+CSS imgs
*/

/* static */
void
dump_cfg_html ( char *caller )
{
        FILE *f;
        char d[32768], n[256];
        int z, r;

        if (0 != arg_scan) return;

        z = sizeof(d);

        snprintf( n, sizeof(n), "%s%s%s%d.html",
                out_path, ram_path, NAME, arg_devnum);

        advrlog( LOG_INFO, "%s(%s) %s", WHO, caller, n );

        f = fopen( n, "w");
        if (NULL == f) {
                dvrlog( LOG_INFO, "%s write fail %s", WHO, n);
                return;
        }

/* scan all gets 15s refresh, otherwise don't refresh */
        r = 0;
//      if ((CAP_NONE == cap_now) && (0 != scan_sig) && (0 == scan_one))
        if ((CAP_NONE == cap_now) && (0 != scan_sig))
                r = 5;

        snprintf( n, sizeof(n), "%s%d", NAME, arg_devnum );

/* html 3 header has sig charts, html4 header does not */
        *d = 0;
        build_head_html( d, z, 7, n, r, WHO );
        fprintf( f, "%s", d);

        *d = 0;
        if (0 != use_css) {
                build_cfg_buttons_html4( d, z );
                fprintf( f, "%s", d);
        }

        *d = 0;
        if (0 != web_stats) build_html_stats( d, z );
        fprintf( f, "%s", d);

        *d = 0;
        build_foot_html( d, z, 5); /* HTML validated */
        fprintf( f, "%s", d);

        fclose( f );
        return;
}

/* truncate event name to w significant words limited to c chars
    s points to long event name, d points to truncated name

    FIXME: "Reptiles, The" slipped through as ReptilesThe not Reptiles
            because there is no space following "The". FIXED?
 */
/* static */
void
event_truncate ( char *d, char *s, int w, int c )
{
        unsigned int wc, z, z1;
        char *r, t;
        char e[PNZ];
        char *lang = "spa"; /* FIXME: get lang or blank from caller */
        char *p;

/* sanity checks */
        if ( ( 0 == *s ) || ( w < 1 ) || ( c < 1 )
            || ( NULL == d) || ( NULL == s) )
                return;

        wc = 0;
/*      memcpy( e, s, PNZ); */ /* pknaggs says: no NUL term on long event */
        astrncpy( e, s, PNZ ); /* this should work better for long event */
        p = e;
        r = d;

/* add space to end, if it will fit */
        z = strlen(p);
        if (z < (PNZ-1)) { p[z] = ' '; p[z+1] = 0; }

    while( wc < w ) {

/* ENG */
        if ( 0 == *p ) break; /* stop at end of event string */
        if ( 0 == strncasecmp( p, " "   ,  1 ) ) { p += 1; continue; }
        if ( 0 == strncasecmp( p, "& "  ,  2 ) ) { p += 2; continue; }
        if ( 0 == strncasecmp( p, "a "  ,  2 ) ) { p += 2; continue; }
        if ( 0 == strncasecmp( p, "i "  ,  2 ) ) { p += 2; continue; }
        if ( 0 == strncasecmp( p, "s "  ,  2 ) ) { p += 2; continue; }

        if ( 0 == strncasecmp( p, "as ",   3 ) ) { p += 3; continue; }
        if ( 0 == strncasecmp( p, "at " ,  3 ) ) { p += 3; continue; }
        if ( 0 == strncasecmp( p, "by " ,  3 ) ) { p += 3; continue; }
        if ( 0 == strncasecmp( p, "in " ,  3 ) ) { p += 3; continue; }
        if ( 0 == strncasecmp( p, "is " ,  3 ) ) { p += 3; continue; }
        if ( 0 == strncasecmp( p, "of " ,  3 ) ) { p += 3; continue; }
        if ( 0 == strncasecmp( p, "to " ,  3 ) ) { p += 3; continue; }

        if ( 0 == strncasecmp( p, "and ",  4 ) ) { p += 4; continue; }
        if ( 0 == strncasecmp( p, "for ",  4 ) ) { p += 4; continue; }
        if ( 0 == strncasecmp( p, "the ",  4 ) ) { p += 4; continue; }

        if ( 0 == strncasecmp( p, "from ", 5 ) ) { p += 5; continue; }
        if ( 0 == strncasecmp( p, "with ", 5 ) ) { p += 5; continue; }

/* TODO: spanish and french equivalents to above */
/* use optional compile until stations start sending proper lang code */
#ifdef USE_ASCII_XLATE
        ascii_xlate( c8859_1, (unsigned char *)p );
/* but the spanish stations here send EITs with [eng] for lang! ha! */
        if ( 0 == strncasecmp( lang, "spa", 3 )) {
/* SPA */
          if ( 0 == strncasecmp( p, "a ",    2 ) ) { p += 2; continue; }
          if ( 0 == strncasecmp( p, "y ",    2 ) ) { p += 2; continue; }

          if ( 0 == strncasecmp( p, "de ",   3 ) ) { p += 3; continue; }
          if ( 0 == strncasecmp( p, "el ",   3 ) ) { p += 3; continue; }
          if ( 0 == strncasecmp( p, "en ",   3 ) ) { p += 3; continue; }
          if ( 0 == strncasecmp( p, "es ",   3 ) ) { p += 3; continue; }
          if ( 0 == strncasecmp( p, "la ",   3 ) ) { p += 3; continue; }
          if ( 0 == strncasecmp( p, "lo ",   3 ) ) { p += 3; continue; }
          if ( 0 == strncasecmp( p, "no ",   3 ) ) { p += 3; continue; }
          if ( 0 == strncasecmp( p, "un ",   3 ) ) { p += 3; continue; }

/* interferes with "las vegas" until lang from caller done */
/*        if ( 0 == strncasecmp( p, "las ",  4 ) ) { p += 4; continue; } */

          if ( 0 == strncasecmp( p, "con ",  4 ) ) { p += 4; continue; }
          if ( 0 == strncasecmp( p, "del ",  4 ) ) { p += 4; continue; }
          if ( 0 == strncasecmp( p, "mas ",  4 ) ) { p += 4; continue; }
          if ( 0 == strncasecmp( p, "por ",  4 ) ) { p += 4; continue; }
          if ( 0 == strncasecmp( p, "que ",  4 ) ) { p += 4; continue; }
          if ( 0 == strncasecmp( p, "sin ",  4 ) ) { p += 4; continue; }

          if ( 0 == strncasecmp( p, "para ", 5 ) ) { p += 5; continue; }
        }

/* TODO: get samples to test with */
        if ( 0 == strncasecmp( lang, "fre", 3 )) {
        }
#endif

        z1 = strlen(p);
        for ( z = 0; z < z1; z++ ) {
        /* equal to or past the destination limit? */
            if ( (r-d) >= (c-1) ) {
                *r = 0; /* null term uses one char */
                return;
            }
            t = p[z];
            
            if ( 0 == t ) break; /* term? */
            if ( ' ' == t ) break; /* end of word? */

/* NOTE: There are certain characters you don't want to use for filenames,
  * if you want a hope of using the console. Maybe could filter by those.
  * Skip non alphanumeric. this is where multi-lingual gets screwed up.
  * As long as it screws it up consistently it shouldn't be a real problem,
  * except for people who want their capture names WITH special chars.
  */

/*          if ( 0 == isalnum( p[z]) ) continue; / * isalnum too slow? */
            if (((t < '0') || (t > '9'))
             && ((t < 'A') || (t > 'z'))
             && ((t < 'a') || (t > 'z'))) continue;

            *r = t; /* copy char */
            r++; /* next char */
        }
        p += z; /* next word */
        wc++; /* counts */
    }
    *r = 0; /* term */
}

/* spam event test
    config file /etc/atscap/atscap.spam
    e is pointer to the event to be checked

    Returns:
        -1 is not on spam list
        0-n is spam list index if found
 */
/* static */
int
test_spam_event ( struct event_s *e1 )
{
        int i, j, k;
        char c1, c2;
        struct spam_s *s;
        char en[ SPAM_NAME_MAX ];

        while (EBUSY == pthread_mutex_trylock( &spam_mutex ))
                nanosleep( &atomic_sleep, NULL );

/* Walk the spam list looking for truncated matches between s->name and en */
        event_truncate( en, e1->name, 2, sizeof( en ));

/* lowercase */
        c1 = *en;
        if ((c1 >= 'A') && (c1 <= 'Z')) c1 |= 0x20;     /* set bit 5 */
        k = -1;
        for (i = 0; i < spam_idx; i++) {
                s = &spam_list[i];
                c2 = *s->name;
/* lowercase */
                if ((c2 >= 'A') && (c2 <= 'Z')) c2 |= 0x20; /* set bit 5 */
/* Compare redux to matching first letter, saves calls to strncasecmp. */
                if (c1 != c2) continue;

                j = strncasecmp( s->name, en, s->len );

/* 0 is spam */
                if (0 == j) {

/* keep last time spam matched */
//                      s->st = utsnow;
/* keep last event time that spam matched */
                        s->st = e1->st;

                        k = i;
                        break;
                }
        }

        pthread_mutex_unlock( &spam_mutex );
        return k;
}


/* strip timer or search list flags, : # $ @ . and , */
/* only do this to copies of timer and search names, not the originals */
/* static */
void
strip_timer_flags ( char *n )
{
        char *p;
        p = strchr( n, ':');
        if (NULL != p) *p = 0;
        p = strchr( n, '$');
        if (NULL != p) *p = 0;
        p = strchr( n, '@');
        if (NULL != p) *p = 0;
        p = strchr( n, '.');
        if (NULL != p) *p = 0;
        p = strchr( n, ',');
        if (NULL != p) *p = 0;
}

/* returns search list index that matches t, or -1 if no match */
/* used for search duplicate check and search delete */
/* static */
int
find_search_event ( char *t, int wdb, int chan, char *caller )
{
        struct search_s *s;     
        char n[ SEARCH_NAME_MAX ],
             r[ SEARCH_NAME_MAX ],
             c1, c2;
        int i, j;

        if (NULL == t) return -1;
        if (0 == *t) return -1;
        if (0 == search_idx) return -1;

/* copy before modify */
        astrncpy( r, t, sizeof(r) );
        strip_timer_flags( r );    

        advrlog( LOG_INFO, "%s -> %s %d r %s w %d c %d",
                caller, WHO, search_idx, r, wdb, chan);

        c1 = *r;
        if ((c1 >= 'A' && c1 <='Z')) c1 |= 0x20;

        for (i = 0; i < search_idx; i++) {
                s = &search_list[i];
                c2 = *s->name;
                if ((c2 >= 'A' && c2 <='Z')) c2 |= 0x20;

/* only check if matching first letter */
                if (c1 != c2) continue;

                astrncpy( n, s->name, sizeof(n) );
                strip_timer_flags( n );

/* search on the name without flags, with stripped t limiting length */
                j = strncasecmp( n, r, strlen( r ) );

                advrlog( LOG_INFO, "%s -> %s %d %d %s %s",
                         caller, WHO, i, j, r, n);

/* does the name match? */
                if (0 == j) {

                    advrlog( LOG_INFO, "%s -> %s sidx %d n %s w %d c %d",
                                caller, WHO, search_idx, n, wdb, chan);

/* no weekday or channel limit on the search list entry? */
                    if ((0 == s->days) && (0 == s->chan)) return i;

/* no weekday limit? */
                    if (0 == wdb) {
/* no channel limit? */
                            if (0 == chan) return i;
/* has channel match? */
                            if (chan == s->chan) return i;
                    }

/* weekday limit and at least one weekday bit matches?  */
                    if (0 != (wdb & s->days)) {
/* no channel limit? */
                            if (0 == s->chan) return i;
/* has channel match? */
                            if (chan == s->chan) return i;
                    }
/* name matched, but weekday bits or channel didn't match, try next */
                }
        }
        return -1;
}

/* delete search event is only caller */
/* return index of volatile timer that matches name to t, or return -1 */
/* static */
int
find_event_timer ( char *p )
{
        int i;
        struct qtimer_s *t;
        char n[ TIMER_NAME_MAX ],
             s[ TIMER_NAME_MAX ],
             c1, c2;
        
        if (NULL == p) return -1;
        if (0 == *p) return -1;

/* search name */
        astrncpy( s, p, sizeof(s) );
        strip_timer_flags( s );

        c1 = *s;
        if ((c1 >= 'A' && c1 <='Z')) c1 |= 0x20;

        for (i = 0; i < timer_idx; i++) {
                t = &timer[i];

/* skip current streaming timer */
                if (T_STREAM == t->qstat) continue;

/* skip weekday timer */
                if (0 != t->days) continue;

/* skip search entry */
                if (T_SEARCH == t->qstat) continue;

                c2 = *t->name;
                if ((c2 >= 'A' && c2 <='Z')) c2 |= 0x20;
                if (c1 != c2) continue;

                astrncpy( n, t->name, sizeof(n) );

/* timer name only, not the flags */
                strip_timer_flags( n );

/* return index if match found. timer name length limits match */
                if (0 == strncasecmp( n, s, strlen( s ) )) {
                        advrlog( LOG_INFO, "%s %d %s %s", WHO, i, s, n);
                        return i;
                }
        }

/* no matching volatile timer found */
        return -1;
}

/* return index of search entry match, or -1 if no match */
/* static */
int
find_search_timer ( char *m )
{
        int i, j;
        struct qtimer_s *t;
        char n[ TIMER_NAME_MAX ],
             s[ TIMER_NAME_MAX ],
             c1, c2;

        astrncpy( s, m, sizeof(s) );
        strip_timer_flags( s );

        c1 = *s;

/* first char to lower case */
        if ((c1 >= 'A' && c1 <='Z')) c1 |= 0x20;

        for (i = 0; i < timer_idx; i++) {
                t = &timer[i];

/* skip non search entries */
                if (T_SEARCH != t->qstat) continue;

/* skip if first char doesn't match. tolower() not used, depends on locale */
                c2 = *t->name;

/* first char to lower case */
                if ((c2 >= 'A' && c2 <= 'Z')) c2 |= 0x20;
                if (c1 != c2) continue;

                astrncpy( n, t->name, sizeof(n) );

/* strip any flags from search entry */
                strip_timer_flags( n );

/* search entry name limits match length */
                j = strncasecmp( n, s, strlen( n ));
                advrlog( LOG_INFO, "%s %d %d %s %s %d", WHO, i, j, s, n );
                if (0 == j) return i;
        }
        return -1;
}

/* return timer index if timer matches epg event e, else return -1 */
/* static */
int
find_timer_epg ( struct event_s *e )
{
        int i;
        struct qtimer_s *t;

        if (timer_idx < 1) return -1;   /* nothing to do */
        for (i=0; i<timer_idx; i++) {
                t = &timer[i];

/* skip search entries, non-channel and non-program match */
                if (T_SEARCH == t->qstat) continue;
                if (t->chan != e->chan) continue;
                if (t->pn != e->pn)  continue;

/* fuzzy start time match in case started mid-program */
                if (t->start >= e->st)
                        if (t->start < (e->st + e->ls))
                                return i;
#if 0
/* exact timer match */
                if (t->start != e->st)   continue;
                if (t->len   != e->ls)   continue;
                return i;
#endif
        }
        return -1;
}

/* TESTME: is this redundant? other code elsewhere does the same? */
/* update timer description from epg if timer matches epg event */
/* static */
void
update_timer_epg( void )
{
        int i, j, k;
        struct qtimer_s *t;
        struct event_s *e;

        for (i = 0; i < pgm.idt; i++) {
                j = pg[i];
        
                if (j >= PGZ) continue;

                k = find_timer_epg( &epg[j] );

                if (-1 == k) continue;

                t = &timer[k];
                e = &epg[j];

                if (0 == *t->ename) astrncpy( t->ename, e->name, PNZ);
                if (0 == *t->edesc) astrncpy( t->edesc, e->desc, PDZ);
        }
}

/* parse automatic search timer: name, program, channel and weekday bits
    adds search entry to timer list with qstat set to T_SEARCH
    does not add duplicate search events

    format:
        Aname[.pn][:ch[:days]]
            name is required, .pn is optional for same event on two VCs.
            ch is optional channel filter for same event on two PTCs.
            days is optional weekday filter to avoid weekend re-runs
*/
/* static */
void
parse_search_event ( char *c )
{
        int i, ch, wd, pn;
        char *p[3], *r;
        struct qtimer_s *t;
        struct search_s *s;
        
//      if (0 != arg_dummy) return;

        if (NULL == c) return;
        if (0 == *c) return;

        advrlog( LOG_INFO, "%s %s", WHO, c); 

        if (search_idx >= SEARCH_LIST_MAX) {
                dvrlog( LOG_INFO,"increase SEARCH_LIST_MAX for more searches");
                return;
        }

        if (timer_idx >= TIMER_LIST_MAX) {
                dvrlog( LOG_INFO,"increase TIMER_LIST_MAX for more searches");
                return;
        }

        wd = ch = pn = 0;

/* this one is variable so don't check build_args return */
        build_args( p, 4, c, ':', WHO);

/* need search name at the very least */
        if (NULL == p[0]) return;
        if (0 == *p[0]) return;

/* has program number? */
        r = strrchr( p[0], '.' );
        if (NULL != r) {

/* remove program number from name, extracting program number */
            *r = 0;
            r++;
            pn = atoi( r );
        }

/* rest are optional parameters */
        if (NULL != p[1]) {
            ch = atoi(p[1]);
            if ( (ch < 0) || (ch > (ptc_max-1)) )
                ch = 0; /* silent fail */
        }
        if (NULL != p[2]) wd = 0x7F & abtou(p[2]);

/* search name duplicate check */
        i = find_search_event( p[0], wd, ch, WHO );

        advrlog(LOG_INFO,"%s find %d %s ch %s pn %d, wd %s",
                    WHO, i, p[0], p[1], pn, p[2]);

/* do not add duplicates */
        if (-1 != i) return;

        advrlog( LOG_INFO, "%s adds %s ch %d pn %d wd %d ",
                WHO, p[0], ch, pn, wd);

/* add to search list */
        s = &search_list[ search_idx ];

        memset( s, 0, sizeof(struct search_s) );
        astrncpy( s->name, p[0], SEARCH_NAME_MAX );
        s->chan = ch;
        s->days = wd;
        s->pn = pn;
        search_idx++;
        advrlog( LOG_INFO, "add to search list %s ch %d pn %d wd %d",
                 s->name, s->chan, s->pn, s->days );

/* add to timer list */
        t = &timer[ timer_idx ];

        memset( t, 0, sizeof(struct qtimer_s) );
        astrncpy( t->name, p[0], TIMER_NAME_MAX );
        t->qstat = T_SEARCH;            /* search status */
        t->start = -1;                  /* puts at end of timer sort */
        t->days = wd;
        t->chan = ch;
        t->pn = pn;
        timer_idx++;
        advrlog( LOG_INFO, "%s %s ch %d pn %d st %d wd %d",
                 WHO, t->name, t->chan, t->pn, t->start, t->days );

}       

/* move timers after tq down to replace tq, decrement timer count */
/* this does not need to know if it is a search timer */
/* static */
void
delete_timer ( int i, char *caller )
{
        int m;
        struct sig_s *s;
        struct qtimer_s *t, *u;
        s = &ptc[ cap_chan ].sig;
        if ( (i < 0) || (i >= timer_idx) ) {
                dvrlog( LOG_INFO, "%s -> %s no timer %d",  caller, WHO, i);
                return; /* sanity check */
        }

        t = &timer[i];

/* stop capture if deleting the current timer */
        if ( (CAP_TIME == cap_now) && (i == timer_rec) ) {
                int fail;
                fail = cap_fail;        /* keep the failure reason */
                stop_capture( WHO, fail );
        }

/* don't auto-start another search if user deletes currently active timer 0? */
        s->lzpgt = t->start; /* last zapped timer start for this channel */

        advrlog( LOG_INFO, "%s (%s) %d %s", WHO, caller, i, t->name);

/* if current is not last timer, move next other(s) down on top of current */
        if (i < (timer_idx-1)) {
                for (m = i; m < (timer_idx - 1); m++) {
                        t = &timer[m];
                        u = &timer[m+1];
                        memcpy( t, u, sizeof(struct qtimer_s) );
                }
        }
        timer_idx--;    /* one less timer now */

/* delete needs to redraw list */
        refresh.timers = 1;
        advrlog( LOG_INFO, "timer %d deleted\n", i);
}


/* http uses these two for trunc event name add/remove from search list */

/* add search list entry p, returns 0: ok(or dup), -1 list full
   caller is expected to sort and save the search list config
 */
/* static */
int
add_search ( char *p, int ch )
{
        struct qtimer_s *t;
        struct search_s *s;

        if (SEARCH_LIST_MAX <= search_idx) {
            dvrlog( LOG_INFO, "search list full, increase SEARCH_LIST_MAX");
            return -1;
        }

        s = &search_list[ search_idx ];

/* clear when adding, to reset rest of search struct (ch pn daybits) */
        memset( s, 0, sizeof(struct search_s));
        astrncpy( s->name, p, SEARCH_NAME_MAX );
        s->chan = ch;

        search_idx++;
        if (TIMER_LIST_MAX <= timer_idx) {
            dvrlog( LOG_INFO, "timer list full, increase TIMER_LIST_MAX");
            return -1;
        }

        t = &timer[ timer_idx ];

/* no duplicates */
        if (-1 == find_search_timer( p )) {
            astrncpy( t->name, p, TIMER_NAME_MAX );
            t->chan = ch;
            t->days = 0;
            t->start = -1;
            t->qstat = T_SEARCH;
            timer_idx++;
        }

        return 0;
}

/* delete an entry in search_list array */
/* static */
void
delete_search ( int n )
{
        int i;
        struct search_s *s1, *s2;

        if (0 == search_idx) return;
        if (n >= search_idx) return;

/* not last entry in main search list? */
        if (n < (search_idx - 1)) {

/* move items from next down to overwrite current and next if more than 1 */
            for (i = n; i < (search_idx - 1); i++) {
                s1 = &search_list[i];
                s2 = &search_list[i+1];

/* use memcpy to get all struct elements so doesn't scramble chan/daybits */
                memcpy( s1, s2, sizeof( struct search_s ) );
            }
        }

/* if it was last entry, it's gone now, else rest moved down to cover it */
        search_idx--;
        if (search_idx < 0) search_idx = 0;
}

/* timer[tm] lookup removes timer tm name from search list then removes
    Search event timer tm and then removes any matching volatile timers.
    There are 3 search items:
        search_list[search]
        timer_list[search] (magenta at bottom of console timer list)
        timer_list[found] volatile timer, may be more than one

    Don't remove timer0 if it's active even though it matches, but
    do remove the rest of them. User can delete the active one.
    This is error prevention so user can accidentally remove search,
    but not lose the current capture that matched the search.
*/
/* static */
void
delete_search_event ( int tm, char *caller ) {
        int j;
        char n[32];
        struct qtimer_s *t;

        t = &timer[ tm ];
/* this should only be a search timer not a regular timer */
        if (T_SEARCH != t->qstat) return;

        astrncpy( n, t->name, sizeof(n) );
        n[16] = 0; /* search timer gets truncated to match */

/* remove any search entries that match first letters */
        j = find_search_event( n, 0, 0, WHO );

/* search list entry gets deleted */
        if (-1 < j) delete_search( j );

/* search_list[] done, now do timer[] search match */

/* reset test for multiple search loop, but should really only find one */
        j = 0;
/* remove search event(s) on timer list with matching length */
        while( -1 != j ) {
            j = find_search_timer( n );
            advrlog( LOG_INFO, "find search timer %d", j);
            if (-1 != j) {
                delete_timer( j, "remove search" );
            }
        }

/* reset test for multiple timer search match loop */
        j = 0;

/* timer search entry done, now remove the matching timers,
    but leave timer0 match if it is active */

/* remove matching timer event(s) */
        while( -1 != j ) {
            j = find_event_timer( n );
            advrlog( LOG_INFO, "find event timer %d", j);

/* don't delete active found timer 0 or -1 not found */
            if (j > -1) {
                t = &timer[j];

/* weekday bits means manual timer. only delete if no weekday bits */
                if (0 == t->days) {
                    if (j != 0) {
                        delete_timer( j, "remove volatile" );
                    } else {

/* current timer? use stop or zap (stop + delete) for current timer */
                        if ( T_STREAM != t->qstat )
                            delete_timer( j, "remove volatile" );
                    }
                }
            }
        }

/* want timer list to redraw from top in case user scrolled off page 0 */
        refresh.timers = 1;
        timer_offset = 0;
}

/*********************************************************** PAT PMT VID AUD
 * cap pids are: PAT, PMT, VID, AUD
 * returns 0 if match, -1 otherwise
 */
/* static */
int
find_cap_pid ( unsigned int pid )
{
    int i;

    for (i = 0; i < 4; i++)
        if ( pid == cap_pids[i] )
            return 0;

    return -1;
}

/* build vc text, et al, calls this:
    search all of vc[] until found matching program number
    returns vc[] index or -1 for failed to find a match
*/
/* static */
int
find_vc_pgm ( int pgn, char *caller )
{
        int i;
        for (i=0; i< vc_ncs; i++) if ( pgn == vc[i].pn ) return i;
        return -1;
}

/* find vc# for this Video ES PID */
int
find_vc_vespid ( unsigned short pid )
{
        int i, j;

        for (i=0; i< vc_ncs; i++)
            for (j = 0; j < vc[i].pmtes; j++)
                if (2 == vc[i].estype[j])
                    if (pid == vc[i].espid[j])
                        return i;
        return -1;
}

/* find pa# for this Video ES PID */
int
find_pa_vespid ( unsigned short pid )
{
        int i, j;

        for (i=0; i< pat_ncs; i++)
            for (j = 0; j < pa[i].pmtes; j++)
                if (2 == pa[i].estype[j])
                    if (pid == pa[i].espid[j])
                        return i;
        return -1;
}

#if 1
/* parse PMT calls this:
    Search pa[] until found matching program number.
    Returns pa[] index or -1 for failed to find a match.
    This index will be VC index if no VCT found.
*/
/* static */
int
find_pa_pgm ( int pgn, char *caller )
{
    int i;

    for (i=0; i< pat_ncs; i++) {
        if ( pgn == pa[i].pn ) {
            advrlog( LOG_INFO, "%s finds pa[%d].pn %04X",
                    caller, i, pgn );
            return i;
        }
    }
    return -1;
}
#endif

/* see if pid is a pmt on the program association list, return index or -1 */
/* static */
int
find_pa_pmtpid ( short pid )
{
        int i;
        for (i = 0; i < pat_ncs; i++) if (pid == pa[i].pmtpid) return i;
        return -1;
}


#if 0
/* not used */

/* parse VCT called this, using find_vc_pgm instead:
    search vc[] until found matching program number (may be obsoleted)
    returns vc[] index or -1 for failed to find a match
*/
/* static */
int
find_vct_pgm ( int pgm, char *caller )
{
    int i;

    for (i=0; i< vct_ncs; i++) {
        if ( pgm == vc[i].pn ) {
            advrlog( LOG_INFO, "%s finds vc[%d].pn %04X",
                    caller, i, pgm );
            return i;
        }
    }
    return -1;
}
#endif


/* if single program capture, set the pids based on cap_pn cap_vc cap_va */
/* static */
void
build_cap_pids ( char *caller )
{
        int svp, svc, sva;
        struct sig_s *s;
        s = &ptc[cap_chan].sig;
        svp = cap_pn;
        sva = cap_va;
        if (CAP_NONE == cap_now) {
                svp = s->pn;
                sva = s->va;
        }
        svc = find_vc_pgm( svp, WHO );
        if (-1 == svc) svc = find_pa_pgm( svp, WHO );

        if (0 == vc_ncs) return; /* if this is zero, no pat+pmt or vct found */
        if (-1 == svp) return; /* full cap does nothing */
        if (-1 == svc) return; /* full cap or vc not found yet does nothing */

        if (svp > 0)
            if (-1 == sva)
                sva = 0; /* -1 and zero select audio 0 in VC cap */

/*    advrlog( LOG_INFO, "%s <- %s cap p %d v %d a %d",
                WHO, caller, svp, svc, sva);
*/
        cap_pidx = 0;
/* add PAT to list, PAT is always PID 0000 */
        cap_pids[ cap_pidx++ ] = 0;

/* add PMT to list */
        cap_pids[ cap_pidx++ ] = vc[ svc ].pmtpid; /* add PMT */

/* video always first, after vc ES pid sort enforced with KTRK fix */
        cap_pids[ cap_pidx++ ] = vc[ svc ].espid[ 0 ];

/* audio always after first ES (video) */
        cap_pids[ cap_pidx++ ] = vc[ svc ].espid[ 1 + sva ];
}



/* persistent vc select: called by channel select */
/* cap_chan has current capture channel */
/* static */
void
set_vc ( char *caller )
{
    struct sig_s *s;
    s = &ptc[ cap_chan ].sig;

    if (0 != arg_scan) return;

    if ( (cap_chan < 0) || (cap_chan >= ptc_max) ) {
        advrlog( LOG_INFO, "%s(%s) can't do channel %d",
                WHO, caller, cap_chan);
        return; /* sanity limit */
    }

/* user cap uses current cfg pn and pa setting */
    if (CAP_USER == cap_now) {

/* none and info cap read from the config (show virt changes it)
   user and timer cap can only change cap_va if single program capture
 */
        cap_pn = s->pn;
        cap_vc = find_vc_pgm( cap_pn, WHO );
        cap_va = s->va;

        advrlog( LOG_INFO, "%s1 <- %s ch %d pn %d vc %d va %d",
                WHO, caller, cap_chan, cap_pn, cap_vc, cap_va);

        advrlog( LOG_INFO, "sp %d sv %d sa %d", s->pn, s->vc, s->va);
    }

/* but still need this done even in user/timer cap for audio select */
    build_cap_pids( WHO );
}


/*
 subtract timespec a from timespec b and put result in timespec d
 a should be start time, b should be stop time
 */
/* static */
void
time_diff ( struct timespec *d, struct timespec *a, struct timespec *b)
{
        time_t sec;

/* FIXME: portability issue? only long in the whole program */
        long nsec;
        
        sec = b->tv_sec;
        nsec = b->tv_nsec;
        if (a->tv_nsec > nsec) { /* borrow */
            nsec += 1000000000;
            sec--;
        }
        d->tv_nsec = nsec - a->tv_nsec;
        d->tv_sec  = sec  - a->tv_sec;
}

/*
 here's yet another version of my XenoTerm(c)1980 terminal word wrapper,
 it's nearly as concise in C as it was in Z-80 assembler, 26 years ago.
 used for dump of program guide to text file.
 f is output file, s is output string. cl is column limit of 78
*/
/* static */
void
word_wrap_indent ( FILE *f, char *s )
{
    char *t;
    char indent[80];
    
    int ts, ns, cc, cl, i, i1;

    if (NULL == f) return;

    ts = cc = ns = 0;

    /* column limit, needs to account for non word chars after tab */
    cl = 78;

    memset( indent, 0, sizeof(indent));
    t = strchr( s, '|'); /* first | is tab stop */
    if (t != NULL) {
        ts = t - s;
        memset( indent, ' ', ts );
    }
    
    fprintf( f, "\n" );
    i1 = strlen(s);
    for (i = 0; i < i1; i++) {
        /* if this char not a space, find next space */
        if (s[i] != ' ') {
            t = strchr( &s[i], ' ');
            if (t != NULL) {
                ns = t - &s[i]; /* how many bytes until next space? */
                if ((ns + cc) >= cl) /* does it go over column limit? */
                {
                    fprintf( f, "\n%s|  ", indent); /* newline plus indent */
                    cc = ts+4; /* 4 chars after indent */
                    fprintf( f, "%c", s[i]);
                    continue; /* needed to skip space */
                }
            }
        }    
        fprintf( f, "%c", s[i]);
        cc++; /* bump current column count */
    }
}

/* build pg epg calls this to attempt to organize the list:

NOTE:
        Stations that get the EIT order wrong are not A/65b compliant.
        Sorting these should not be necessary. It is not a perfect world.
        eit locks has other examples of broadcasters [FOX] getting it wrong.
        It would be a Bad Thing to see bad [FOX] practices propagated.

 sort pgx is two functions in one:
    sort pgx by e[pgx].pn to arrange in program order
    sort pgx again by e[n].st to arrange in pgm+chrono order

    This should bunch all pn's together first for non-compliant stations,
     then st's in chronological order, so dump epg day hrefs work correctly.

NOTE: This is somewhat less costly than moving entire event structs.

*/
/* static */
void
sort_pgx (struct event_s *e, struct pgm_s *p, short *pgx, char *caller)
{
    int i, j, k;

/* sort pgx by first order program number */
    for ( i = 0; i < ( p->idx - 1); i++ ) {
        for ( j = i + 1; j < p->idx; j++ ) {
            if ( e[ pgx[ i ]].pn > e[ pgx[ j ]].pn ) {
                k = pgx[j];
                pgx[j] = pgx[i];
                pgx[i] = k;
            }
        }
    }

/* if program number matches, sort pgx by second order start time */
    for ( i = 0; i < ( p->idx - 1); i++ ) {
        for ( j = i + 1; j < p->idx; j++ ) {
            if ( e[ pgx[ i ]].pn == e[ pgx[ j ]].pn ) {
                if ( e[ pgx[ i ]].st > e[ pgx[ j ]].st ) {
                        k = pgx[j];
                        pgx[j] = pgx[i];
                        pgx[i] = k;
                }
            }
        }
    }
}

/* Abstracted pointer version of old build pg epg to be a bit more flexible.
    Builds compressed pgx index from sparse epg in e and filter settings in p.

    Guides that have the full 16 days will not realize any gain, and
    this code may be simplified once all stations send 16 days worth.
    There are enough reserved table id's to send 32 days worth.

    Sets p->idx, p->ett to found counts.

    Event inclusion/exclusion control via p->:
            p->age      Filter aged events
            p->hide     Filter spam events
            p->find     Filter timer name matches

        e points to event_s epg[PGZ]
        p points to pgm_s filters, counters
        idx points to short pg[PGZ] where in epg[] event can be found
        caller points to text of what called this.
*/
/* static */
void
build_pg_epg (struct event_s *e, struct pgm_s *p, short *pgx, char *caller)
{
        int j;
        int letmid = 0; /* last etmid seen */
        struct event_s *e1;

        advrlog( LOG_INFO, "EPG%02d %s ( %s )", pgm.chan, WHO, caller );

        p->idx = 0; /* pgm guide index current select mode hide/age/match */
        p->idt = 0; /* pgm guide index total */
        p->ett = 0; /* pgm guide description count */

/* TODO: sort pgx by start time */

/* create new program count and index every loop */
        for (j = 0; j < PGZ; j++) {
            pgx[ j ] = -1; /* disabled until proven otherwise */
            e1 = &e[j];

/* Async operation on live epg[] skips locked EITs until sort_eit_epg done */
#if 1
            if (CAP_NONE != cap_now) {
                if (p == &pgm) {
                    if (0 != epg_locks[ j / PEZ ])
                        continue;

// TESTME: try a wait instead, it shouldn't be very long?
// FIXME: nope, freezes up, must need a clear somewhere
//                  while (0 != epg_locks[ j / PEZ ])
//                          nanosleep( &atomic_sleep, NULL );
                }
            }
#endif

            if (0 != e1->etmid) {

/* idt has total entries vs current filter list idx */
                p->idt++;

                if ( letmid == e1->etmid ) continue; /* skip duplicates */
                letmid = e1->etmid; /* current for next check */

/* if pn set, and doesn't match event, skip it */
                if ( (p->pn > 0) && (p->pn != e1->pn) ) continue;

/* skip: 0 hidden, 65535 NTSC */
                if ( (0 == e1->pn) || (e1->pn == 65535) ) continue;

/* if hide spam enabled, look for spam to remove from list */
                if (0 != p->hide) 
                    if ( test_spam_event( e1 ) >= 0 ) continue;

/* skip aged out programs */
                if (0 != p->age) {
                        if ( utsnow > (e1->st + e1->ls) ) {
                                continue;
                        }
                }

/* skip what doesn't match timer list, might be a cpu pig if called too much */
                if (0 != p->find) {
                        if ( -1 == find_timer_epg( e1 )) {
                                continue;
                        }
                }

/* count events that passed above tests */
                pgx[ p->idx ] = j;
                p->idx++;

/* count non blank event descriptions too */
                if (0 != *e1->desc) p->ett++;
            }
        }

/* after the above is filtered, send it through pgm + st sort 
    to get it ready for dump epg html and console epg display
*/
        sort_pgx( e, p, pgx, WHO );

/*
        advrlog(LOG_INFO, "EPG%02d %s( %s ) pgm idx %d idt %d",
                pgm.chan, WHO, caller, p->idx, p->idt);
*/
}

/* These always display and always get updated when channel changes. */
/* TODO: Make it use what is in pgm_s array instead of build epg. */
/* static */
void
show_vc_selection ( void )
{
    struct sig_s *s;
    char vcn[4] = "ALL"; /* virtual channel number */
    char vca[4] = "ALL"; /* virtual channal audio number */
    char vcx[32] = "";
    char vcy[32] = "";
    int i, svp, svc, sva;

    if (0 != arg_scan) return;

    if (0 == refresh.vstats) return;
    refresh.vstats = 0; /* one shot output redux */
    s = &ptc[cap_chan].sig;
//    s = &ptc[ scan_pos ].sig;


    build_pg_epg( epg, &pgm, pg, WHO);
    svp = cap_pn;
    sva = cap_va;
    if (CAP_NONE == cap_now) {
        svp = s->pn;
        sva = s->va;
    }
    svc = find_vc_pgm( svp, WHO );

    if (svc > -1) {
        snprintf( vcn, sizeof(vcn), " %1d ", svc );
        snprintf( vca, sizeof(vca), " %1d ", sva );

/* use vct channel name info by default if available */
        if (vct_ncs > 0) {
            snprintf( vcx, sizeof(vcx), "%s", vc[svc].name);
            snprintf( vcy, sizeof(vcy), "%s %2d.%d.%d",
                        s->sid, vc[svc].major, vc[svc].minor, sva );
        }
/* MPEG fallback does not usually have embedded callsigns. resort to cfg */
        if ( (vct_ncs < 1) && (pat_ncs > 0) ) {
            snprintf( vcx, sizeof(vcx), "%s", s->call);
            snprintf( vcx, sizeof(vcx), "%s", s->call);
            snprintf( vcy, sizeof(vcy), "%s %2d.%d",
                        s->sid, s->ptc, svp);
            if (sva > 0)
                snprintf(vcy, sizeof(vcy), "%s %2d.%d,%d",
                            s->sid, s->ptc, svp, sva);
        }
    } else {
        snprintf( vcx, sizeof(vcx), "%s", s->call);
        snprintf( vcy, sizeof(vcy), "%s", s->sid);
    }

    aprintf( stderr, "%s", dca.vstat); /* set curpos */
    aprintf( stderr,
                BG "%-7s %-10s Video: " BC "%s"
                BG " Audio: " BC "%s "
                BW " PIDS: %d.%d " BM CEL,
                vcx, vcy, vcn, vca, s->ptc, s->pn );

    build_cap_pids( WHO );
    if (svc > -1) {
        for (i = 0; i < 4; i++) {
            if (i > 0) {
                if (0 == cap_pids[i]) {
                    aprintf( stderr, "      " );
                } else {
                    aprintf( stderr, "  %04X", cap_pids[ i ] );
                }
            } else {
                aprintf( stderr, " %04X", cap_pids[ i ] );
            }
        }
    } else {
        aprintf( stderr, " ALL");    
    }
}

/* #define USE_RATE */
/* shows subset of ATSC and MPEG Transport packet stats that are counted */
/* static */
void
show_packet_stats ( void )
{
        /* color codes for each packet stat */
        char *ctse, *ctei, *ctsc, *ctss, *cecc; /* transport */
        char *catt, *camg, *cavc, *caei, *caet; /* atsc */
        char *cats, *cvct, *cmgt, *ceit, *cett;
        char *cmpp, *cmpa, *cmpm, *cmvp, *cmap; /* mpeg */

        struct sig_s *s;
        struct pkt_s *p;

#ifdef USE_RATE
        static int ovcv, ovca; /* old values from last time thru */
#endif
        int i, vcv, vca; /* bits per second */

        s = &ptc[cap_chan].sig;
        p = &s->pkt;
        if (CAP_NONE != cap_now) p = &pkt;

/* [s] key off. don't display */
        if (0 == display_stat) return;

/* one shot flip flop hold down */
        if (0 == refresh.pstats) return;
        refresh.pstats = 0;

        ctse = ctei = ctsc = ctss = cecc = BG;

/* non zeros turn red */
        if (p->tserrt > 0) ctse = BR; /* transport error total */
        if (p->synert > 0) ctss = BR; /* transport sync error total */
        if (p->teiert > 0) ctei = BR; /* transport error indicator */
        if (p->tscert > 0) ctsc = BR; /* transport scramble control nz */
        if (p->tsccet > 0) cecc = BR; /* transport sync align error */

/* erase stat area, it is 80x5 */
        for (i = 0; i < 5; i++)
                aprintf( stderr,"\033[%d;1H" CEL, dca.tstatn + i ); 

        aprintf( stderr, BN DCARC 
                        "%sTSER: %9d  "
                        "%sSYN: %9d  "
                        "%sTEI: %9d  "
                        "%sSCR: %9d  "
                        "%s CC: %9d" BN
                        /* "%sALN: %8d\n" / same as synert */
                        , dca.tstatn + 0
                        , (columns - 80) >> 1
                        , ctse, p->tserrt
                        , ctss, p->synert
                        , ctei, p->teiert
                        , ctsc, p->tscert
                        , cecc, p->tsccet
                        /* , caln, p->alignt / same as synert */
                        );
    
/* ATSC packets get cyan unless error. 0 is considered error */
        catt = camg = cavc = caei = caet = BC;
        if (0 == p->atsc) catt = BR;
        if (0 == p->mgt ) camg = BR;
        if (0 == p->tvct) cavc = BR;
        if (0 == p->eit ) caei = BR;
        if (0 == p->ett ) caet = BR;
        aprintf( stderr, BN DCARC
                        "%sATSC: %9d  "
                        "%sMGT: %9d  "
                        "%sVCT: %9d  "
                        "%sEIT: %9d  "
                        "%sETT: %9d" CEL BN
                        , dca.tstatn+1
                        , (columns - 80) >> 1
                        , catt, p->atsc
                        , camg, p->mgt
//                      , cavc, (0==arg_cable)?p->tvct:p->cvct
                        , cavc, p->tvct + p->cvct
                        , caei, p->eit
                        , caet, p->ett
                        );

        cats = cvct = cmgt = ceit = cett = BG;
        if (p->crcats > 0) cats = BR; /* if any atsc packets bad, its red */
        if (p->crctvct > 0) cvct = BR; /* vct is red importance */
        if (p->crccvct > 0) cvct = BR; /* vct is red importance */
        if (p->crcmgt > 0) cmgt = BM; /* MGT gets magenta but maybe red */
        if (p->crceit > 0) ceit = BY; /* EIT are low priority yellow */
        if (p->crcett > 0) cett = BY; /* ETT are same or lower */

        aprintf( stderr, BN DCARC
                        "%s CRC: %9d "
                        "%s      %9d "
                        "%s      %9d "
                        "%s      %9d "
                        "%s      %9d" CEL BN
                        , dca.tstatn+2
                        , (columns - 80) >> 1
                        , cats, p->crcats
//                      , cvct, (0==arg_cable)?p->crctvct:p->crccvct
                        , cvct, p->crctvct + p->crccvct
                        , cmgt, p->crcmgt
                        , ceit, p->crceit
                        , cett, p->crcett
                    );

/* MPEG packets get white */
        cmpp = cmpa = cmpm = cmvp = cmap = BW;
        if (p->mpeg2 == 0) cmpp = BR;
        if (p->pat   == 0) cmpa = BR;
        if (p->pmt   == 0) cmpm = BR;
        if (p->vid   == 0) cmvp = BR;
        if (p->aud   == 0) cmap = BR;

        if (0 != p->pmtrc) cmpm = BR BL;

        aprintf( stderr, BN DCARC
                        "%sMPEG: %9d  "
                        "%sPAT: %9d  "
                        "%sPMT: %9d" BN "  " BW
                        "%sVID: %9d  "
                        "%sAUD: %9d" BN CEL
                        , dca.tstatn+3
                        , (columns - 80) >> 1
                        , cmpp, p->mpeg2
                        , cmpa, p->pat
                        , cmpm, p->pmt
                        , cmvp, p->vid
                        , cmap, p->aud
                    );

#ifdef USE_RATE
/* VC video and audio get green */
        vcv = p->vcvid - ovcv;
        vca = p->vcaud - ovca;
        ovcv = p->vcvid; /* for next time thru */
        ovca = p->vcaud;

        vcv *= 1504;
        vca *= 1504;
#else
        vcv = p->vcvid;
        vca = p->vcaud;
#endif
        
        aprintf( stderr, BG DCARC
                        " CRC: %9d "
                        "      %9d "
                        "      %9d "
#ifdef USE_RATE
/* show current bit rate for single program capture */ 
                        " Vbs: %9d "
                        " Abs: %9d" CEL BN
#else
                        " VCV: %9d "
                        " VCA: %9d" CEL BN
#endif
                        , dca.tstatn+4
                        , (columns - 80) >> 1
                        , p->crcmp2, p->crcpat, p->crcpmt
                        , vcv, vca
                );
}

/* display legends, optional clear screen */
/* static */
void
show_headers ( int clear_console )
{
    char p[256], *s, *t;
    char f[32]; /* cap status field */
    
    if (0 == refresh.headers) return;
    refresh.headers = 0;


    if (0 != clear_console) aprintf( stderr, CLS );

    /* text for failure reason, if any */
    s = ""; /* blank text */
    switch( cap_fail )
    {
        case FAIL_TSYNC:
            s = "SYN "; /* loss of sync, failed test sync */
            break;

        case FAIL_IFIFO:
            s = "IFE "; /* input fifo error, error in loop */

/*
            if (0 != arg_dummy) {
                s = "";
                cap_fail = FAIL_NONE;
            }
*/
            break;

        case FAIL_OFIFO:
            s = "OFE "; /* output fifo error, error in loop */
            break;
        case FAIL_ZAP:
            s = "QOS "; /* transport stream errors too high */
            break;
        case FAIL_NOSPC:
            s = "FUL "; /* volume full */
            break;
        case FAIL_QOS:
            s = "QOS "; /* program guide load failed */
            break;
        case FAIL_AOS:
            s = "AOS "; /* no signal */
            break;
    }

/* put version or last file opened on screen */
    if (0 == strlen(out_name)) {
        aprintf( stderr, HOM "%s" BN CEL, header_version);
    } else {

        /* extract filebase only */
        filebase(p, out_name, F_TFILE);

/*      if (0 != strlen(p))
*/
        {
            /* ok, fail or user zap */
            t = " ";
            if (0 != cap_fail) t = "FAIL: ";
            if (0 != cap_zapped) t = " ";

            snprintf( f, sizeof(f)-1, "%s%s%s", s, t, p);

            /* cyan for last cap good, red for last cap fail */
            /* cap status will handle if cap in progress */
            if (CAP_NONE == cap_now)
                aprintf( stderr, HOM "%s%-32s" BN CEL,
                            (cap_fail==0) ? BC : BR, f );
        }
    }

    if (CAP_NONE == cap_now) {
        if ((D_TIMERS == display_type) || (D_CHANNELS == display_type) ) {
            aprintf( stderr, DCARC CEL, 3, 1);
            aprintf( stderr, "%s%s", dca.hstat, header_channels );
        }
    } else {
        aprintf( stderr, header_capture, dca.hstat, "Left" );
    }

    if (D_EPG == display_type) return;
    if (D_MGT == display_type) return;
    if (D_VCT == display_type) return;

    /* signal header starts on second line */
    if (CAP_NONE == cap_now)
    {   switch( display_sigtype )
        {
            case SIG_STR:
                aprintf( stderr, DCA_SIG " Strength%% ");
                break;

            case SIG_SNR:
                aprintf( stderr, DCA_SIG "    SNR dB  " );
                break;

            case SIG_FMHZ:
                aprintf( stderr, DCA_SIG "   Freq Hz  " );
                break;

            case SIG_WLEN:
                aprintf( stderr, DCA_SIG "  Wavelen\042  " );
                break;

#ifdef USE_DVB_EXPERIMENTAL
            case SIG_FOHZ:
                aprintf( stderr, DCA_SIG " FreqDrift  " );
                break;

            case SIG_BER:
                aprintf( stderr, DCA_SIG "  BitErr1s  " );
                break;
#endif

            default:
                break;
        }
    }

    if ( D_TIMERS == display_type ) {
        aprintf( stderr, DCA_HEAD4 "%s", header_timers);
        aprintf( stderr, BN"%s[?] help", dca.ustat);
    }
}

/* Parse screen size environment variables and set some values from it.
    Falls back to termios if environment variables are not set. */
/* static */
void
test_termsize ( void ) {
    int x;
    char *p;
    struct winsize ttyz;

/* only works when invoked from xterm+bash, not directly invoked */
    p = getenv( "LINES" );

/* has LINES, may have rest */
    if (p != NULL) {
        lines = atoi(p);
        p = getenv( "COLUMNS" );
        if ( p != NULL) {
            columns = atoi(p);
        }
    } else {

/* include <termio.h> defines TIOCGWINSZ */
#ifdef TIOCGWINSZ
#warning using Linux TIOCGWINSZ
/* fall back to non-portable non-POSIX Linux-only ioctl for tty */
        x = ioctl( 1, TIOCGWINSZ, &ttyz );
        if (x == 0) {
            lines = ttyz.ws_row;
            columns = ttyz.ws_col;
        } 
#endif
    }

/* top left is used for capture type and name                           */
/* top middle is timer usage/volume free status                         */
/* top right is wall clock, yellow for DST, normal for non-DST          */
/*         ... (timers, channels, guides) ...                           */
/* bottom middle above last two lines is packet stats                   */
/* bottom above last line is virtual channel info                       */
/* bottom left is how many events on this (virtual) channel             */
/* bottom middle is event mask flags                                    */
/* bottom right is ATSC packet process flags and ATSC system time       */

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

    snprintf( dca.sstat, sizeof(dca.sstat), "\033[1;%dH", (columns>>1) - 8 );

/* unix/wall clock top right */
    snprintf( dca.wstat, sizeof(dca.wstat), "\033[1;%dH", columns - 20 );

/* [?] help goes under clock */
    snprintf( dca.ustat, sizeof(dca.ustat), "\033[4;%dH", columns - 8 );

/* program status position, bottom left */
    snprintf( dca.pstat, sizeof(dca.pstat), "\033[%d;1H", lines );

/* program guide mask flags, left of middle of bottom line */
    snprintf( dca.mstat, sizeof(dca.mstat), "\033[%d;%dH", lines, ((columns>>1)-2) - 5 );

/* atsc status position, bottom right */
    snprintf( dca.astat, sizeof(dca.astat), "\033[%d;%dH", lines, columns - 34 );

/* PID cap status, transport status, ATSC and MPEG status, bottom - 6 */
    snprintf( dca.tstat, sizeof(dca.tstat), "\033[%d;%dH", lines-6, ((columns>>1)-40) );

/* VC cap status, callsign video # audio # and PIDs to cap, bottom - 1 */
    snprintf( dca.vstat, sizeof(dca.tstat), "\033[%d;%dH", lines-1, ((columns>>1)-40) );

/* capture stat position for headers and time/error/pkt status */
    snprintf( dca.cstat, sizeof(dca.cstat), "\033[3;%dH", (columns>>1) - 40 );

/* line 2 headers go to left */
    snprintf( dca.hstat, sizeof(dca.hstat), "\033[2;1H");

/* device name */
    snprintf( dca.zstat, sizeof(dca.zstat), "\033[2;%dH", columns - 5 );

/* compute how many lines are visible for timer and guide */
    dca.tstatn = lines-6;

/* always uses 6 lines, 4 at top 2 at bottom. pkt stats use 5 lines */
    user_lines = (lines - 6) - ((0 != display_stat) ? 5:0);
    user_lines += (D_CHANNELS == display_type) ? 2:0;

    if ( (lines != prow) || (columns != pcol) ) {
        show_headers(1); /* CLS */
        
        set_refresh();
    }
    prow = lines;
    pcol = columns;
}


/* if event e1 is already on timer list, return 0, else return nz */
/* static */
int
search_timers ( struct event_s *e1 )
{
        int i;
        struct qtimer_s *t;
        char en[ TIMER_NAME_MAX], /* truncated EPG name */
             tn[ TIMER_NAME_MAX]; /* truncated timer name */

        if (NULL == e1) return 0;

/* truncate epg name */
        event_truncate( en, e1->name, 2, TIMER_NAME_MAX );

/* step through timer list */
        for (i = 0; i < timer_idx; i++ ) {

                t = &timer[ i ];

/* skip timer entry that is actually a search entry */
                if ( T_SEARCH == t->qstat ) continue;

/* copy timer name for flag removal */
                astrncpy( tn, t->name, sizeof(tn) );

/* remove flags from timer name */
                strip_timer_flags( tn );

/* if trunc timer name doesn't match trunc event name, try next */
                if ( 0 != strncasecmp( tn, en, strlen(tn) ) ) continue;

/* if timer start doesn't match event start, try next */
                if ( t->start != e1->st ) continue;

/* if timer program number doesn't match event program number, try next */
                if ( t->pn != e1->pn ) continue;

/* timer name, start time and program number matches event: 
    copy event name and description to timer entry for caplog */
                if ( 0 != *e1->name ) astrncpy( t->ename, e1->name, PNZ );
                if ( 0 != *e1->desc ) astrncpy( t->edesc, e1->desc, PDZ );

                advrlog (LOG_INFO, "%s found timer %d %s", WHO, i, tn );
                return 0;
        }

/* no timer matches the event */
        return ~0;
}


/* return day of week as day bits for event program guide entry pgo.
    Sunday is b6, Monday is b5 ... Saturday is b0
*/
/* static */
int
get_pgm_wday ( struct event_s *e1 )
{
        unsigned char day;
        time_t start;
        struct tm lt;

        if (NULL == e1) return 0;

        start = e1->st;
        localtime_r( &start, &lt );
        day = lt.tm_wday;

        return (1<<(6-day));
}

/* e1 is pointer to one EPG event_s to use for new timer */
/* static */
void
add_search_event_timer ( struct event_s *e1 )
{
        int i, ch;
        struct sig_s *s;
        struct qtimer_s *t;
        char tn[ 32 ];

        if (NULL == e1) return;         /* sanity check */

/* don't allow new event timer to overflow timer list max */
        if (timer_idx >= TIMER_LIST_MAX) {
                dvrlog( LOG_INFO, "%s %s timers full, increase TIMER_LIST_MAX",
                        WHO, e1->name);
                return;
        }

/* if timer adds itself again at end of capture, it may truncate capture */
        if ( ((e1->st + e1->ls)-60) < utsnow ) {
                advrlog(LOG_INFO, "%s not adding %s", WHO, e1->name);
                return;
        }

        ch = e1->chan;                  /* event channel */
        s = &ptc[ ch ].sig;             /* sig struct for channel */
    
/* stops endless zap when reselect ch and endless [d]elete timer0 loop */
        if (s->lzpgt == e1->st) return;

/* Look for duplicate timers */
        for (i = 0; i < timer_idx; i++) {
                t = &timer[ i ];

/* Skip search entries */
                if (T_SEARCH == t->qstat) continue;

/* TESTME: is this event/timer check needed anymore? yes: for web EPG */
/* Does this event already exist on the timer list? */
                if ( (t->start == e1->st)       /* start time match? */
                  && (t->len   == e1->ls)       /* run length match? */
                  && (t->pn    == e1->pn)       /* program number match? */
                  && (t->chan  == e1->chan) )   /* channel match? */
                {
                        advrlog( LOG_INFO, "dup ev %d.%d %s %s",
                                t->chan, t->pn, t->name, e1->name );

/* Set timer ETMID so EPG volatiles don't show up in build epg timers,
    which should only show volatile timers without EPG entries.
*/
                        t->etmid = e1->etmid;
/* caplog needs full name and full description, if available */
                        *t->ename = 0;
                        *t->edesc = 0;

                        if (0 != *e1->name) astrncpy( t->ename, e1->name, PNZ );
                        if (0 != *e1->desc) astrncpy( t->edesc, e1->desc, PDZ );

/* First duplicate gets out, name doesn't matter */
                        return;
                }
        }

        event_truncate( tn, e1->name, 2, 32 ); /* PG event name two words */
        if (0 == *tn) return; /* should never happen? abort if it does */

/* shorten event name to allow inclusion of @.n */
        tn[16] = 0;

/* Add the timer to the end of of the timer list */
        t = &timer[ timer_idx ];
        timer_idx++;

        *t->edesc = 0;
        *t->ename = 0;

/* add truncated name to timer list w/ mmdd-hhmm format and program number */
        snprintf( t->name, TIMER_NAME_MAX, "%s@.%d", tn, e1->pn );

/* add the timer */
        t->days = 0;            /* no weekday bits for automatic events */
        t->future = 0;          /* no future queue for automatic events */
        t->secdt = 5;           /* AOS delay time is 5s prior to start */
        t->chan = e1->chan;     /* channel */
        t->pn = e1->pn;         /* program */
        t->start = e1->st;      /* start time */
        t->len = e1->ls;        /* length seconds */
        t->qstat = T_FUTURE;    /* show timers might change this */
        t->vc = -1;             /* capture VCT/PMT fills this in? */
        t->va = -1;             /* done from timer name flag not here yet */
        t->etmid = e1->etmid;   /* volatile timer came from EPG data */

/* caplog needs full name and full description, if available */
        *t->ename = 0;
        *t->edesc = 0;
        if (0 != *e1->name) astrncpy( t->ename, e1->name, PNZ );
        if (0 != *e1->desc) astrncpy( t->edesc, e1->desc, PDZ );

        advrlog( LOG_INFO, "add ev %d.%d %s", t->chan, t->pn, t->name );
}

/* if EPG event e1 isn't on timer list, and is on search list,
    add a timer but only if the channel, program and weekday bits match,

        e1 is pointer to one EPG event
        p is pointer to EPG filter (not used? can it be used?)
*/
/* static */
void
search_events ( struct event_s *e1, struct pgm_s *p, char *caller )
{
        int i, j, k, ch, wd, pn;
        char en[32], sn[32], tn[32];

        if (NULL == e1) return;

/* try the obvious disqualify first: the event already has a timer? */
        k = search_timers( e1 );
        if (0 == k) return;

        advrlog( LOG_INFO, "%s %s", WHO, e1->name);

/* truncate event name */
        event_truncate( en, e1->name, 2, 16 );

        for (i = 0; i < search_idx; i++) {

/* search list name, remove any flags */
                astrncpy( sn, search_list[i].name, sizeof(sn) );
                strip_timer_flags( sn );

/* truncated search list name */
                event_truncate( tn, sn, 2, 16 );

/* TESTME: not needed anymore? force names to 16 chars max */
                en[16] = 0;
                tn[16] = 0;

/* shorthand these to reduce pointer confusion in following tests */
                ch = search_list[i].chan;
                wd = search_list[i].days;
                pn = search_list[i].pn;

/* limit compare to length of truncated search list item */
                k = strlen( tn );

/* no name match, try next search list item */
                if ( 0 != strncasecmp(en, tn, k) ) continue;

/* name matches, see if rest of search parameters match */
                advrlog( LOG_INFO, "%s found %s", WHO, tn);

/* if event already on timer list, get out now */
                k = search_timers( e1 );
                if (0 == k) return;

/* timer add status is false until proven true */
                j = 0;

/* 4 conditions can trigger adding the event */
/* 1 condition can reverse the above (pn not matching) */

                if (0 == ch) { /* if not filtered by chan */
                    if (0 == wd) { /* and not filtered by days */
                        j = ~0;
                    } else { /* is filtered by days */
                        if (0 != (wd & get_pgm_wday( e1 )) )
                            j = ~0;
                    }
                }
                
                if (ch == e1->chan) { /* if filtered by channel */
                    if (0 == wd) { /* and not filtered by days */
                        j = ~0;
                    } else { /* if filtered by channel and days */
                        if (0 != (wd & get_pgm_wday( e1 )))
                        j = ~0;
                    }
                }

/* if program match selected, and no match, do not add it */
                if (pn > 0)
                    if (pn != e1->pn)
                        j = 0;

                advrlog( LOG_INFO, "%s add %d name %s ch %d pn %d wd %d",
                        WHO, j, e1->name, ch, pn, wd );

                if (0 == j) return; /* did not pass filter */

                add_search_event_timer( e1 );

/* timer list needs sorting and refresh */
                timer_sort = ~0;
                refresh.timers = 1;
                return;
        }
}


/* these get some abstraction but still depends on vc and pa structures */
/*  load vc and pa structures:
    file format:
    short vct_ncs
    short pat_ncs
    struct vc_s vc
    struct pa_s pa
*/
/* static */
void
load_vct ( char *caller, int ch, int *ncv, struct vc_s *v,
                int *ncp, struct pa_s *p )
{
        FILE *f;                        /* file descriptor for input */
        struct stat fs;                 /* file stat struct */
        char n[256];                    /* file name for input */
        size_t r;
        int ok;
        struct sig_s *s;
        int vcn;

        if (ch > ptc_max) {             /* boundary check */
                dvrlog( LOG_INFO, "%s %d >= ptc max %d",
                        WHO, ch, ptc_max);
                return;
        }
        s = &ptc[ch].sig;

        init_vct( &vct, WHO );

        snprintf( n, sizeof(n), "%s%spg/%02d.vc", out_path, ram_path, ch);
        advrlog( LOG_INFO, "%s %s %s", WHO, caller, n );

/* small file */
        ok = stat( n, &fs );
        if (0 != ok) {

/* this one isn't very important */
                advrlog( LOG_INFO, "%s stat %s error %d", WHO, n, errno );
                return;
        }

        f = fopen( n, "r");
        if (NULL == f) {
                dvrlog( LOG_INFO, "%s read %s has error %d",
                        WHO, n, errno);
                return; /* no vct found */
        }

/* read vct_ncs and pat_ncs */
        r = fread( ncv, sizeof( int ), 1, f);
        if (1 != r) {
                dvrlog( LOG_INFO,"%s error %d rd vctncs %s",WHO,r,n );
                fclose( f );
                return;
        }

        r = fread( ncp, sizeof( int ), 1, f);
        if (1 != r) {
                dvrlog( LOG_INFO,"%s error %d rd patncs %s",WHO,r,n );
                fclose( f );
                return;
        }

/* read vc and pa */
        r = fread( v, sizeof( vc ), 1, f); /* FIXME: vc needs abstraction */
        if (1 != r) {
                dvrlog( LOG_INFO, "%s error %d rd vc %s",WHO,r,n );
                fclose( f );
                return;
        }

        r = fread( p, sizeof( pa ), 1, f); /* FIXME: pa needs abstraction */
        if (1 != r) {
                dvrlog( LOG_INFO, "%s error %d rd pa %s",WHO,r,n );
        }

/* if the program exists in vc, set station hres to last saved pn hres */
        s->hres = 0;
        if (s->pn > 0) {
            vcn = find_pa_pgm( s->pn, WHO );
            if (vcn >= 0) s->hres = pa[vcn].hres;
        }

        fclose( f );
}

/* Open ch.epg file, read indices into i, then read events into e.
     file format:
      pgx[ ... ]                index values for e[], -1 terminates list
      e[ pgx[ ... ] ]           epg entries for each event_s

    ch is channel
    e is event list     event_s, epg[] or copy
    pgx is index list   pg[] or pg3[]
    p is pointer to program mask/status

    p->fail is set to one of these:
        PG_FAIL_NONE            no error
        PG_FAIL_BG              blank guide
        PG_FAIL_GE              guide empty(same as blank?remove me)
        PG_FAIL_NF              not found 
        PG_FAIL_TO              time out (last event start+len is < utsnow)
*/

/* static */
void
load_epg ( int ch, struct event_s *e, struct pgm_s *p, short *pgx, char *who )
{
        FILE *f;                        /* fd for input */
        struct stat fs;                 /* need for file mtime */
        struct event_s *e1, e2;         /* one event */
        size_t r;
        char n[256], g[256];            /* file name for input */
        unsigned short i, j;
        short k, po;
        struct sig_s *s;
        unsigned int et;                /* last event end time */
        int fdn, cdn;                   /* first and last day numbers */

        s = &ptc[ch].sig;


        memset( e, 0, sizeof( epg ));
        p->fail = PG_FAIL_NONE;

        snprintf( g, sizeof(g), "%02d.epg", ch);

        snprintf( n, sizeof(n), "%s%spg/%s", out_path, ram_path, g);

        i = stat(n, &fs);
        if (0 != i) {
                advrlog( LOG_INFO, "%s error stat %s", WHO, n);
                p->fail = PG_FAIL_NF;
                return; /* file problem */
        }

        p->mtime = (int)fs.st_ctime;

        f = fopen( n, "r");
        if (NULL == f) {
                dvrlog( LOG_INFO, "%s error reading %s", WHO, n);
                p->fail = PG_FAIL_NF;
                return; /* file problem */
        }

        j = 0;
        r = ~0;
        while (0 != r) {
                r = fread( &po, sizeof(short), 1, f);
                if (0 == r) break;              /* EOF */
                if (-1 == po) break;

/* broadcast likes the slots to be the same as the broadcast slots. */
                if (0 == arg_cable) {
                        if (j >= PGZ) break;
                        if (po >= PGZ) break;   /* boundary/FFFF check */
                        pgx[ j ] = po;          /* store epg[index] */
                }
                j++;
        }

//      p->idt = j;                             /* event index count */
//      p->idx = j;                             /* event index count */

        if (0 == j) {
                advrlog( LOG_INFO, "%s %s empty", WHO, n );
                fclose( f );
                p->fail = PG_FAIL_GE;
                return;
        }

        e1 = NULL;
        et = 0;
        k = 0;

        fdn = -1;
        cdn = 0;

        for (i = 0; i < j; i++) {
                if (k >= PGZ) break;

/* cable doesn't need to store it in original slots, broadcast does? */
                if (0 == arg_cable) {
                    e1 = &e[ pgx[i] ];
                } else {
                    e1 = &e[ k ];
                }

                r = fread( &e2, sizeof(struct event_s), 1, f );
/* EOF */
                if (0 == r) break;

/* program number translate set? */
                if (s->pnx > 0) {

/* skip if no translate match */
                    if (e2.pn != s->pnx) continue;
                    e2.chan = s->chan;
                    e2.pn = s->pn;
                }

/* set first day number and last day number from epg current day number */
                cdn = e2.stm.tm_yday;
                if (-1 == fdn) fdn = cdn;

/* end time of last event copied */
                et = e2.st + e2.ls;
                memcpy( e1, &e2, sizeof(e2) );

/* look for search event matches and add a timer for any matches */
                search_events( e1, p, WHO );

                k++;
        }

/* if any first day, see if s->yday within range of epg
    if not in range, set s->yday to today
*/
        if (-1 != fdn) {

/* did year meridian occur between first day num and current day num? */
            if (fdn <= cdn) {

/* same year, does day need to be fixed because it's out of range? */
                if ((s->yday < fdn) || (s->yday > cdn)) {
                    s->yday = fdn;
                    advrlog(LOG_INFO, "%s same year fix s->yday %d",
                            WHO, s->yday);
                }
            } else {

/* end of year handling. order is important. do next year test first */

                advrlog(LOG_INFO, "%s same year s->yday %d", WHO, s->yday);
                if ((s->yday > cdn) && (s->yday < fdn)) {
                    s->yday = fdn;
                    advrlog(LOG_INFO, "%s next year fix s->yday %d",
                            WHO, s->yday);
                }

#if 0
                if (s->yday < fdn) {
                        s->yday = fdn;
                        advrlog(LOG_INFO, "%s this year fix s->yday %d",
                            WHO, s->yday);
                    }
                }
#endif

            }
        } else {
            advrlog(LOG_INFO, "%s no fdn, s->yday %d is today",
                            WHO, s->yday);
            s->yday = tloc.tm_yday;
        }

        if (fdn == cdn) s->yday = fdn;
        if (-1 == s->yday) s->yday = fdn;

        advrlog( LOG_INFO, "%s %s ch %d yday %d fdn %d cdn %d",
                WHO, who, s->ptc, s->yday, fdn, cdn);


        p->idt = k;                             /* event index count */
        p->idx = k;                             /* event index count */

        fclose( f );

/* some kind of time should have been set by at least one event */
        if (0 == et) {
/* if no time set, guide is blank */
                p->fail = PG_FAIL_BG;
        } else {
/* last entry read is used for guide expired determination */
                if (et < utsnow)
                        p->fail = PG_FAIL_TO;
        }
        advrlog( LOG_INFO, "%s %s pg idx %d found .%d %d",
                    WHO, n, p->idx, s->pn, k );

/* PG_FAIL_NONE was set above */
}

/* load guide uses same error returns as load epg above */
/* TODO: remove redundant pg fail set code leftover from before load epg */
/* static */
void
load_guide ( int ch, char *caller )
{
        char n[256];                            /* file name */
        struct stat fs;
        struct sig_s *s;
        struct pgm_s *p;
        int i;

/* FIXME: test mode might need this, but don't let it save */
        if (0 != test_mode) return;
        if (0 != arg_scan) return;              /* not needed for -S setup */

        if (ch > ptc_max) {
                dvrlog( LOG_INFO, "%s chan %d > ptc max %d",
                        WHO, ch, ptc_max);
                return;
        }

        s = &ptc[ ch ].sig;
        p = &pgm;
        pkt.feit = 0;
        p->idx = 0;
        p->chan = ch;

        p->fail = PG_FAIL_NONE;
        init_vct( &vct, WHO );
        load_vct( caller, ch, &vct_ncs, vc, &pat_ncs, pa ); /* vct & pat+pmt */

        if (vct_ncs >= pat_ncs) { 
            vc_ncs = vct_ncs;
        } else {
            vc_ncs = pat_ncs;
        }
        init_pgm();

        pkt.feit = PAY_GOOD; /* cheat event status display */
        pgm_done = ~0;

        snprintf( n, sizeof(n), "%s%spg/%02d.epg", out_path, ram_path, ch);

/* stat file to see if it's more than 3 hours past now */
/* file date was set by save guide to last event */
        i = stat( n, &fs);
        if (0 != i) {
                advrlog( LOG_INFO, "EPG%02d %s ( %s ) guide not found",
                        p->chan, WHO, caller);
                p->fail = PG_FAIL_NF;
                return;         /* not found nop */
        }

/* rely on save guide mtime for auto guide time out */
/* mtime is from EIT-01.0 or calculated from failure future retry time */
        s->pgmt = (int)fs.st_mtime;

/* test and fail if empty file size, can use touch as place holder */
        if (0 == fs.st_size) {
                advrlog( LOG_INFO, "EPG%02d %s guide empty", ch, n);
                p->fail = PG_FAIL_GE;
                return;
        }       

/* use 'live' versions, http abstracts them to epg3 pg3 pgm3.idt */
//      load_epg( ch, epg, &pgm, pg, WHO );
        load_epg( ch, epg, &pgm, pg, caller );

        advrlog( LOG_INFO, "EPG%02d load epg %d events", ch, p->idx );
/* is guide blank? */
        if (0 == p->idt) {
                advrlog( LOG_INFO, "EPG%02d %s blank", ch, n);
                p->fail = PG_FAIL_BG;
                return;
        }

        build_pg_epg( epg, &pgm, pg, WHO );

        s->pgx = p->idt;

        advrlog( LOG_INFO, "EPG%02d build pg %d/%d", ch, p->idx, p->idt );


/* build filtered pg from full epg */
        if (0 == p->idx) {
                advrlog( LOG_INFO, "EPG%02d %s %s filtered %d/%d",
                        ch, WHO, caller, p->idx, p->idt );
                return;
        }

/* copy name/description from epg ch+pgm+time match to timer that matches */
        update_timer_epg();

/* want to know if last event in epg has expired time */
        i = epg[ pg[pgm.idx-1] ].st + epg[ pg[pgm.idx-1]].ls;
        if (i < utsnow) {
                p->fail = PG_FAIL_TO; /* too old/time out */
        }

        advrlog(LOG_INFO, "EPG%02d %s ( %s ) idx %d/%d",
                pgm.chan, WHO, caller, pgm.idx, pgm.idt );

        return;
}


/* set physical transmission channel from s->chan
   and virtual channel and audio from s->vc and s->va
 */
/* static */
void
set_channel ( struct sig_s *s, char *caller )
{
        int ir = -1;
        unsigned int f = 0;

/* STD MHz seems to be 1.25MHz from bottom of band, NTSC video carrier. */
/* DVB API wants 3MHz from bottom of band (center), offset 28.615kc. */
/* NOTE: according to driver, the tuner PLL resolution is 62.5kc */
        f = s->freq;

        if (0 == f) {
            dvrlog( LOG_INFO, "%s %d has freq %f", WHO, s->chan, s->freq);
            return;
        }

        if (f == scan_freq) return;     /* don't set if already set */
        advrlog( LOG_INFO, "%s %s f %d scan_freq %d",
                    caller, WHO, f, scan_freq);
        scan_freq = f;

        init_mg();
        init_pids();

        advrlog( LOG_INFO, "%s(%s) %d", caller, WHO, s->chan);
        load_guide( s->chan, WHO );
        set_vc(WHO); /* sets cap_vc and cap_va and builds pid list */

#ifdef USE_POWERDOWN
        if ( (0 != arg_tmpfs) && (fe_file < 3) ) open_device( caller );
#endif
        if ( (0 == test_mode) && (0 == arg_dummy) ) {
                struct timespec ns;
                fe_param.frequency = f;
                if ( -1 != fe_file) {
                        ir = ioctl( fe_file, FE_SET_FRONTEND, &fe_param );
                        if (ir < 0) {
                                dvrlog( LOG_INFO,
                                        "FE %d SET FRONTEND %d Hz %d fail %d",
                                        fe_file, f, s->freq, ir);
                                return;
                        } else {
                                advrlog( LOG_INFO,
                                         "%s FE %d SET FRONTEND %d Hz",
                                         s->call, fe_file, f);
                        }
/* Don't wait too long here because it will makes channel scan slower. */
                        ns.tv_sec = 0;
                        ns.tv_nsec = aos_delay * 1000000;
                        nanosleep(&ns, NULL);

                } else {
                        dvrlog( LOG_INFO, "%s FE %d FILE NOT OPEN?",
                            WHO, fe_file );
                        test_mode = ~0;
                }
                scan_freq = f; /* one shot this */
        }

        refresh.pstats = 1;
        refresh.vstats = 1;
        refresh.estats = 1;
}

/* See if wake-up is expired and wake the drive if it is expired. */
/* This should only be called by test timer with current now timer. */
/* static */
void
test_timer_wakeup_devices ( struct qtimer_s *t )
{

        FILE *f;
        struct sig_s *s;
        char n[256];


/* no -E? */
        if (0 == arg_tmpfs) return;

/* is awake already ? */
        if (-1 == utswuv) return;
/* is not idle? */
        if ((CAP_NONE != cap_now) && (CAP_INFO != cap_now)) return;
/* no timer yet? */
        if (t->qstat == T_SEARCH) return;
/* not within 30s of timer yet? */
        if ((t->start - 30) > utsnow) return;
        if (utswuv > utsnow) return;

/* first time through, or after capture done ? */
        if (0 == utswuv) {
                utswuv = t->start - 30;
                advrlog( LOG_INFO, "utswuv %d in %d", utswuv, utswuv - utsnow);
                return;
        }

        s = &ptc[t->chan].sig;

/* One-shot test wakeup until capture stops and clears the flip-flop. */
        utswuv = -1;

/* Make a filename in a directory on the volume that needs to wake up. */
        snprintf( n, sizeof(n), "%s%s%d.wakeup", out_path, NAME, arg_devnum);

/* is enough to wake up the drive? */
        f = fopen( n, "a" );
        if (NULL == f) {

/* does the delay cause an error? lets see it, if so */
            dvrlog( LOG_INFO, "hdd wakeup error %d %s", errno, strerror(errno) );
            return;
        } else {

/* may need to actually write something other than dirent to spin-up */
            fprintf(f, "%s", "awaken");
            fflush(f);
            fclose(f);

/* Maybe this will stall somewhat synchronously to drive spin-up, but it's
   wishful thinking. It's already in kernel write cache. Find another way
   wait until drive is spun up.
*/
            remove(n);
        }

#ifdef USE_POWERDOWN
/* Wake up DVB device BEFORE ts capture. */
/* NOTE: make sure USE_POWERDELAY isn't shorter than 30s, or else
   device will power off after wakeup but before capture starts.
*/
        if ((0 == arg_dummy) && (in_file < 3)) {
                scan_freq = 0;          /* force new freq select */
                set_channel( s, WHO );  /* set channel will open device */
                dvrlog( LOG_INFO, "awoke dvb, set ch %2d", s->chan);
        }
#endif
}


/*
 check given timer q to see if it's current
 return -1 if not current, or q if current
 */
/* static */
int
test_timer ( int q )
{
    struct qtimer_s *t;
    int tstart, tstop, istop;
    
    if (0 == timer_idx) return -1;              /* no timers on list */
    if (q >= timer_idx) return -1;              /* sanity boundary check */
    if (T_SEARCH == timer[q].qstat) return -1;  /* no search events */
    if (T_DONE == timer[q].qstat) return -1;    /* timer to be removed */

    t = &timer[q];
    get_time();

    if (0 == q) test_timer_wakeup_devices( t );
    
    tstop = t->start + (t->len - t->secdt); /* len adjust for delete time */
    istop = t->start - 5; /* info cap kick out 5s before timer */
    tstart = t->start - 3; /* AOS starts 3s before timer */

/* info cap should kick out 5 seconds before next timer start */
    if (CAP_INFO == cap_now) {
        if (utsnow >= istop) {
/* normal info cap exit so the guide will save */
            stop_capture( WHO, FAIL_NONE );
                return -1;
        }
    }

/* if now is past time for AOS pre-timer check */
/* FIXME: problem location for the double start on back-to-back timers */
/* FIXED: only allow timer 0 to become active, rest have to calc status */
    if (0 == q) {
        if ( (utsnow >= tstart) && (utsnow < tstop) )
            return q; /* this timer might be active */
    }
    return -1;
}

/* add up all the weekdays and lengths for each timer, return # of sec */
/* static */
int
total_timers ( void )
{
    int i, j, k, s, t;

    s = t = 0;
        
    for (i=0; i< timer_idx; i++)
    {
        if (T_SEARCH == timer[i].qstat) continue;

        /* count actual usage, not time that isn't used */
        k = timer[i].len - timer[i].secdt;      
        if (timer[i].days != 0)
        {
            char *tn = timer[i].name;
            char tx = tn[strlen(tn)-1];

            /* only add weekday timers if $ or # at end of name
              NOTE: both are guesses at usage for this week only */
            if ( (tx == '#') || (tx == '$') )
            {
                for (j = 0; j< 7; j++)
                {
                    if ( ( timer[i].days & (1<<j) ) != 0 )
                    {
                        s += k;
                        t++;
                    }
                }
            /* no $ or #, must be overwriting, so add one timer only */
            /* makes timers look wrong if any $ or #, but they are correct */
            } else {
                s += k;
                t++;
            }
        /* no weekdays, only a single timer that does not reschedule */
        } else {
            s += k;
            t++;
        }
    }

    /* total number of timers */    
    if (0 != arg_capture)
    {
        /* no timer, but some time to calc for usage */
        timer_tot = 0;
        return arg_capture; /* -s # of seconds */
    } else {
        /* got number of timers and number of seconds used */
        timer_tot = t;
        return s; /* computed number of seconds from all timers and days */
    }
}

/* look at timer[r] .days and .start and figure out how many seconds
   until the next reschedule time. return this value.
   PLUS silly math tricks:
    tm_wday is 0(sunday)...6(saturday), numerical for single day
    .days is bit6 is sunday, bit0 is saturday, for multiple days
 */
/* static */
int
calc_future_date ( int r )
{
    int i, j, k, t;
    
/* sanity check, 0 means nothing gets added since no bits set */
    if (0 == timer[r].days) return 0;
    if (T_SEARCH == timer[r].qstat) return 0;

/* don't reschedule future items that are already rescheduled */
    if (timer[r].start > utsnow) {
        if (timer[r].future > timer[r].start) {
            return 0;
        }
    }

/* don't loop on this once timers are a week ahead from start time
    if ( timer[r].start > (utsmid + (14*SECDAY)) ) return 0;
 not needed now, endless reque loop problem fixed, but keep in case needed.
*/
    /* reschedule attempts begin with start time, not today's time */
    trec1 = timer[r].start;
    memcpy( &tloc1, localtime( &trec1 ), sizeof( tloc1 ) );
    
    /* at least one bit is set, so at least one day for rescheduling */
    t = SECDAY;

    k = ( tloc1.tm_wday + 1 ) % 7; /* starting from start time weekday */
    
    /* only look 6 days into future? */
    /* start time + 1 day, test bitfields for seven days, mod7 */
    for (i=k; i < k+7; i++)
    {
        j = 6 - (i % 7); /* adjust for backwards weekday bit notation */

        /* stop adding days when you find a day */
        if ( timer[r].days & ( 1 << j) )
            break;
        
        t += SECDAY; /* add a day */
    }

    return t;
}

/* compute next weekday timer start time from now */
/* store result in timer[r] */
/* static */
void
calc_first_weekday( struct qtimer_s *t )
{
        int i, j, b;
        struct tm f;            /* current event or future start */
        time_t s;

        if (T_SEARCH == t->qstat) return;
        if (0 == t->days) return;


/* start at current day meridian */
        t->start = utsmid;

/* parse weekday timer sets h and m */
        t->start += (t->h * SECHR) + (t->m * SECMIN);

/* start at current weekday */
        j = tloc.tm_wday;

/* find first start day */
        for (i = 0; i < 7; i++) { /* 8 days should find first/last overlap */
                b = 1 << (6 - j);       /* daybit to compare against timer */

/* daybit matches b. if event is still current, use this for t->start, else
   it won't be valid until the 8th time through, if only 1 weekday bit set
*/
                if (0 != (b & t->days)) {
                        if (utsnow < (t->start + t->len))
                                break;
                }

/* add a day, try next day bit and keep within weekday bit shift range */
                t->start += SECDAY;
                j++;
                j %= 7;

/* fall through means it was today and got rescheduled 1 week */
/* break is where it found the day matched and wasn't expired */
        }

/* t->start should have correct time unless DST change occurred between */
        s = (time_t) t->start;

        localtime_r(&s, &f);

/* most of the year, the dst value won't change */
        if (tloc.tm_isdst == f.tm_isdst) return;

/* spring forward */
        if (0 == tloc.tm_isdst) {
                t->start += 3600;
        } else {
/* fall back */
                t->start -= 3600;
        }
}

/* sort search list */
void
/* static */
sort_searchlist ( void )
{
    int i,j, k, z;
    struct search_s search_tmp;

    if (search_idx < 2) return;

    z = sizeof(struct search_s);
    for (i = 0; i < (search_idx - 1); i++) {
        for (j = i + 1; j < search_idx; j++) {
            k = strncasecmp( search_list[i].name, search_list[j].name,
                             SEARCH_NAME_MAX-1 );
            if (k > 0) {
                memcpy( &search_tmp,     &search_list[i], z );
                memcpy( &search_list[i], &search_list[j], z );
                memcpy( &search_list[j], &search_tmp,     z );
            }
        }
    }
}

/* sort spamlist, st is sort type 0 for name, nz for date */
void
/* static */
sort_spamlist ( int st )
{
    int i,j, k, z;
    struct spam_s spam_tmp;

    if (spam_idx < 2) return;

    z = sizeof(struct spam_s);
    for (i = 0; i < spam_idx; i++) {
        for (j = i + 1; j < spam_idx; j++) {
            if (0 == st) {
                k = strncasecmp( spam_list[i].name,
                                 spam_list[j].name,
                                 SPAM_NAME_MAX-1 );
            } else {
                k = spam_list[j].st - spam_list[i].st;
            }
            if (k > 0) {
                memcpy( &spam_tmp,     &spam_list[i], z );
                memcpy( &spam_list[i], &spam_list[j], z );
                memcpy( &spam_list[j], &spam_tmp,     z );
            }
        }
    }
}

/* Sort timers by start date. This could be faster with pointers.
   It's slow because it's swapping whole structures. Bubble sort isn't
   the fastest, either, but it's good enough for < 1000 items.
   See program guide sort for bubble with pointers for > 1000 items.

    unsigned int -1 for start time keeps search events always at end
 */
/* static */
void
sort_timers ( void )
{
    int i, j, k, s, z;
    struct qtimer_s tmp;

    if (timer_idx < 2) return;

    advrlog( LOG_INFO, "%s", WHO );

    z = sizeof(struct qtimer_s);
    s = 0;

/* don't sort timer0 if it's active, regardless of volatile/weekday */
    if ((T_STREAM == timer[0].qstat) || (T_ACTIVE == timer[0].qstat)) s = 1;

    for (i=s; i < (timer_idx - 1); i++)
    {
        /* start j from i+1 to move forward in list */
        for (j = i + 1; j < timer_idx; j++)
        {

/* swap flag, 0 is no swap, 1 is swap */
            k = 0;

/* less than loops here to avoid more branch prediction */
            if (timer[i].start < timer[j].start ) continue;

/* equal to can swap depending on: search name or no daybits */
            if ( timer[i].start == timer[j].start ) {

/* no daybits volatile sets precedence over weekday timers */
                if ( (T_SEARCH != timer[i].qstat)
                  && (T_SEARCH != timer[j].qstat) )
                {
                    if ( (0 != timer[i].days) && (0 == timer[j].days) ) {
                        k = 1;
                    }
                }

/* alphabetic order sets precedence for search timers */
                if ( (T_SEARCH == timer[i].qstat)
                  && (T_SEARCH == timer[j].qstat) )
                {
                    k = strncasecmp( timer[i].name,
                                     timer[j].name,
                                     TIMER_NAME_MAX);
                    if (0 < k) {
                        k = 1; /* flag it for swap */
                    } else {
                        k = 0;
                    }
                }
            }

/* finally make sure search timers get swapped with non search timers */
            if ( (T_SEARCH == timer[i].qstat)
              && (T_SEARCH != timer[j].qstat) )
                k = 1;

/* greater than always sets flag for a swap */
            if ( timer[i].start > timer[j].start ) k = 1;

/* only swap if flag is non-zero */
            if (k > 0) {
                memcpy( &tmp,      &timer[i], z );
                memcpy( &timer[i], &timer[j], z );
                memcpy( &timer[j], &tmp,      z );
            }
        }
    }

    timer_sort = 0; /* one shot this */
}


/*
 binary ascii to weekday
 wecma has 32 bytes for weekdays,
    and 2x8 ansi color codes for highlight
*/
/* static */
void
batowd ( int tq )
{
        int i, z, today = 0;
        char *d, *s, *wt = "SMTWTFS";
    
        d = wecma;
        z = sizeof(wecma);
        *d = 0;
    
        for ( i=0; i < 7; i++) {
                today = 0;
                if ( ( timer[ tq ].start >= utsmid)
                   & ( timer[ tq ].start < utsmid + SECDAY )
                   & ( tloc.tm_wday == i ) )
                            today = 1;

/* highlight current day of week */
                if ( today != 0 ) asnprintf( d, z, BY );

                s = " ";
                if ( bascii[ i ] & 1 ) s = wt + i;
                asnprintf( d, z, "%c", *s);

/* unhighlight */
                if ( today != 0 ) asnprintf( d, z, BK );
        }
}

/* close the atsc device(s) */
/* static */
void
close_device ( char *caller )
{
        if (in_file < 3) {
            dvrlog( LOG_INFO, "*** %s device %s already closed",
                    caller, in_name);
            return;
        }

        scan_sig = 0;
        scan_one = ~0;
        scan_freq = 0;

/* in reverse order of open */
        if ( dvr_file > 2 ) close( dvr_file );
        if ( dmx_file > 2 ) close( dmx_file );
        if (  fe_file > 2 ) close(  fe_file );

        advrlog( LOG_INFO,"*** %s closed device %s fd %d", caller, in_name, in_file);
        in_file = dvr_file = dmx_file = fe_file = -1;

        if (0 == arg_scan)
            aprintf( stderr, HOM BR "CLOSED %-24s" BN, in_name);
}

/* put the console back to a usable state */
/* static */
void
console_reset ( void )
{
        struct termios modes;
        int f;
    
/* no stdio in detached mode or it will block */
        if (0 != arg_detach)
                return;
    
        f = 0;
        fcntl( 0, F_GETFL, &f );
        f &= ~O_NONBLOCK;
        fcntl( 0, F_SETFL, f );

/* indicate the console will need init before nonblock nonecho use */
        console_init = 1;
        if ( tcgetattr( 0, &modes ) < 0 )
                advrlog( LOG_INFO, "c_reset tcgetattr" );

        modes.c_lflag |= ICANON;
        modes.c_lflag |= ECHO;
        if ( tcsetattr( 0, TCSAFLUSH, &modes ) < 0 )
            advrlog( LOG_INFO, "c_reset tcsetattr" );
}


/* sum the largest static tables and report to user */
/* static */
long long
show_mem_static ( void )
{
        long long i, t, m, v;
        int c;
        char d[32];

        i = t = 0;

        aprintf( stdout, BG "Static memory:\n" );

        i =  sizeof(epg);
        i += sizeof(pg) + sizeof(pg1) + sizeof(pg2);
        i += sizeof(pgm) + sizeof(pgm1) + sizeof(pgm2);
#ifdef USE_WWW
        i += sizeof(pg3);
        i += sizeof(pgm3);
#endif
        lltoasc( d, i );
        aprintf( stdout, " %20s %16s (%d events x %u)\n",
                    "EPG + helpers", d, PGZ, sizeof(struct event_s) );
        t += i;

        i = sizeof(mgt) + sizeof(vct);          /* 2 more payload_s */
        i += sizeof(stt) + sizeof(rrt);         /* 2 more payload_s */
        v = sizeof(vc);
        i += v;                                 /* vc helper is pretty big */

/* TODO: shrink these to one or two, kind of big at 81920 bytes each */
        m = sizeof(mg);
        m += sizeof(mgp);               /* kind of large */
        m += sizeof(mgs);               /* dynamic now */
        i += m;
#ifdef USE_DYNAMIC
/* VCT MGT STT RRT tables static, EIT and ETT tables dynamic */
        c = 4;
#else
/* VCT MGT STT RRT EIT ETT tables static */
        c = 260;
        i += sizeof(eit);
        i += sizeof(ett);
#endif
        lltoasc( d, i );
        aprintf( stdout, " %20s %16s (%d tables + vc %lld + mg* %lld)\n",
                 "ATSC + helpers", d, c, v, m );
        t += i;

        i = sizeof(pat) + sizeof(cat);          /* 3 payload_s */
        i += sizeof(pmt);
        v = sizeof(pa);                         /* pa helper is pretty big */
        i += v;

        m = sizeof(last_cc);                    /* plus PID trackers, 104k */
        m += sizeof(cce_pids);
        m += sizeof(psi_pids);
        m += sizeof(pids);
        i += m;

        lltoasc( d, i );
        aprintf( stdout, " %20s %16s (%d tables + pa %lld + pids %lld)\n",
                 "MPEG + helpers", d, 3, v, m );
        t += i;

        i = sizeof(cap_text) + sizeof(cap_stats);
        lltoasc( d, i );
        aprintf( stdout, " %20s %16s (%u text %u errlog)\n",
                "Capture Stats", d, sizeof(cap_text) , sizeof(cap_stats) );
        t += i;

        i = sizeof(dvrlog_list) + sizeof(tvct_text) + sizeof(mgt_text);
        lltoasc( d, i );
        aprintf( stdout, " %20s %16s\n", "Text + helpers", d );
        t += i;

        i = sizeof(ptc) + sizeof(timer);
        lltoasc( d, i );
        aprintf( stdout, " %20s %16s\n", "Chans & Timers", d );
        t += i;

        i = sizeof( spam_list ) + sizeof( search_list );
        lltoasc( d, i );
        aprintf( stdout, " %20s %16s\n", "Search & Spam", d );
        t += i;

#ifndef USE_DYNAMIC
        i = sizeof( fifo_buffer );
        lltoasc( d, i );
        aprintf( stdout, " %20s %16s\n", "Capture FIFO", d );
        t += i;

        i = sizeof( frames );
        lltoasc( d, i );
        aprintf( stdout, " %20s %16s\n", "frames[]", d );
        t += i;

        i = sizeof( sequences );
        lltoasc( d, i );
        aprintf( stdout, " %20s %16s\n", "sequences[]", d );
        t += i;
#endif
        lltoasc( d, t );
        aprintf( stdout, " %20s " BW "%16s bytes\n", "Total static:", d);

        return t;
}




/* sum the dynamic tables in use and report to user */
/* static */
long long
show_mem_dynamic ( void )
{
        long long i, t;
        char d[32];
        int j;

        i = t = 0;

        aprintf( stdout, BC "Dynamic memory:\n" );

        for (j = 0; j < ALLOC_LIMIT; j++) {
            if ( NULL == alloc_list[j].p ) continue;
            i = alloc_list[ j ].z;
            lltoasc( d, i );
            aprintf( stdout, " %20s %16s\n", alloc_list[ j ].n, d );
            t += i;
        }

        lltoasc( d, t);
        if (t > 0)
         aprintf( stdout, " %20s " BW "%16s bytes\n"BN, "Total dynamic:", d );
        return t;
}

/* static */
void
show_mem_use ( void )
{
        long long t;
        char d[32];

        t = show_mem_static();
        t += show_mem_dynamic();
        lltoasc( d, t );
        aprintf( stdout, BW "%-21s %16s bytes\n" BN , "Total memory:", d );
}



/* need to intercept sigterm to handle better shutdown and flushing */
/* use this in place of exit() to (usually) reset console to usable state */
/* static */
void
console_exit ( int errorcode )
{
        struct timespec ns;
        char n[64];

        memcpy( &ns, &signal_long_sleep, sizeof(ns) );
        ns.tv_nsec *= (1 + arg_devnum); /* one second delay per instance */
        nanosleep( &ns, NULL );

        if (out_file > 2) close( out_file );

/* don't do this here, you want to keep all files if exit called */
/*    remove_renamed(); */


#ifdef USE_MMAN
        munlockall(); /* clean exit */
#endif

#ifdef USE_MCAST
        if (0 != arg_mcport) udp_close_socket( &udp );
#endif

#ifdef USE_WWW
/*      if (0 != arg_www) http_close_sockets(); */
#endif

        nanosleep( &msg_sleep, NULL);

        dvrlog( LOG_INFO, "console_exit ec %d en %d bc %lld es %s",
                errorcode, errno, outbc,
                (errorcode == 0) ? "": strerror( errno ) );

        if (0 == arg_detach) {

/* once works usually, but twice works better */
                console_reset();
                console_reset();
                aprintf( stderr, "%s\n", BN);
        }

/* copy config, epg dirs, append /dtv/ram/atscap[0-3].log to /dtv/ version */
        close_device( WHO );
        free_fifo( &ts_fifo );
        if (0 == arg_dummy) {
                save_config( WHO );
                if (0 == arg_detach) {

/* looks better */
                        if (0 == arg_scan) /* don't move cursor in case -S makes long list */
                                aprintf( stderr, BN SCV "\033[21;1H" CCE "\n");
/*                              aprintf( stderr, "\033[0q"); */ /* reset? */
//                      show_mem_use();
                        aprintf( stderr, "\nExit code %d\n\n", errorcode );
                }
            save_tmpfs( WHO );
        }

        snprintf(n, sizeof(n), "/var/run/%s/%s%d.pid", NAME, NAME, arg_devnum);
        remove(n);

        exit( errorcode );
}


/* The problem with this is the possible race condition between instances,
   due to spamlist being separated from card config. Will think on it
   because the result is very nasty with a corrupted spam list.

    One possible solution is it only updates when user adds/removes
    spam entry, then let other instances figure out reload time. This
    assumes only one user at a time which should be the usual case.
*/
/* static */
void
save_spamlist ( char *caller )
{
        int i;
        FILE *f;
        char n[256];
        char o[80];
        struct stat fs;
        struct tm t;
        time_t *st;

        while (EBUSY == pthread_mutex_trylock( &spam_mutex ))
                nanosleep( &atomic_sleep, NULL );

//      WHOAMI;

/* spam list by time so user can easily find aged spam events */
        sort_spamlist( 1 );

        advrlog( LOG_INFO, "%s has %d entries", WHO, spam_idx);

        snprintf( n, sizeof(n), "%s%s.spam", cfg_path, NAME );
        f = fopen( n, "w");
        if (NULL == f) {
            dvrlog( LOG_INFO, "%s can't write %s", WHO, n);
            pthread_mutex_unlock( &spam_mutex );
            return;
        }

        fprintf( f, "# atscap%d spamlist[%d] %s %s %d\n",
                    arg_devnum, spam_idx, caller, date_now, utsnow);

        for (i = 0; i < spam_idx; i++) {

                st = &spam_list[i].st;
                localtime_r( st, &t );
                snprintf( o, sizeof(o), "%s:", spam_list[i].name);

#if 1
/* human readable date after # is ignored by load spamlist */
                fprintf( f, "%-17s%10d # %04d%02d%02d-%02d:%02d\n",
                            o, (int)spam_list[i].st,
                            t.tm_year+1900, t.tm_mon+1, t.tm_mday,
                            t.tm_hour, t.tm_min);
#endif
        }

        fflush( f );
        fclose( f );
        i = stat( n, &fs );
        if (0 == i) {

/* set cf spam mod time into future 1s to prevent loop on load */
                cf_smt = fs.st_mtime + 1; // + (time_t) arg_devnum;
                advrlog( LOG_INFO, "%s %s new mt %d", WHO, caller, cf_smt);
        }

/* spam list by name to speed up search */
        sort_spamlist( 0 );
        pthread_mutex_unlock( &spam_mutex );
}

/* save channels and timers to a file */
/* static */
void
save_config ( char *caller )
{
        FILE *o;
        struct stat st;
        struct qtimer_s *t;
        char ba[16];            /* binary to ascii output string */
        char fn[256];
        int i, j, ch;
        struct sig_s *s;

        if (0 != test_mode) return; /* prevent accidents */
        if (0 != arg_scan) return;

/* don't overwrite with blank if control c before load config */
        if (0 != cf_no) return;

        snprintf( fn, sizeof(fn)-1, "%s%s", cfg_path, cfg_name );
        advrlog( LOG_INFO, "%s(%s) %s", WHO, caller, fn);
    
        o = fopen( fn, "w" );
        if ( NULL == o )
        {
                fprintf( stderr, CLS "Can't open %s for write --", fn);
                dvrlog( LOG_ERR, "can't write config %s", fn); 
                perror(0);
                console_exit(0);
                return;
        }

        chmod( fn, 0660 );
        get_time();
        fprintf( o, "# Configuration %s created %s\n#\n", fn, date_now);
        fprintf( o,
         "#  You may edit this file but only valid settings are kept.\n#\n"
        );

#if 1
        fprintf( o,
"#  SYNOPSIS: [optional]\n"
"#\n"
"#       The order of these parameters is important. You want search event\n"
"#      A-lines before C-lines so when it loads the EPG, it finds an event.\n"
"#      You also want F-line frequency table selected before first C-line.\n"
"#      If you omit the F-line it will default to 8-VSB ATSC broadcast mode.\n"
"#\n"
"#       nameX is event name and [optional #/@ flags] and [.program number].\n"
"#      After the '.program', ',1' can sometimes be specified for SAP.\n"
"#\n"
"#       For V and W lines, nameX with #/@ will append -weekday/-mmdd.\n"
"#\n"
"#       days are 1111111 for SMTWTFS, 0 = no cap that day.\n"
"#\n"
"#       LCN = logical channel number, is C-line load order starting with 0.\n"
"#\n"
"# AnameX:channel:days\n"
"#       Search for name[.pgn] [on logical channel] [for match on days]\n"
"#\n"
"# Frequency table (F0 - F5, default is F0 ATSC bcast)\n"
"#       You can try -Fn -S option a few n's for optimal cable frequencies.\n"
"#      If you need different frequencies, edit the source for table n.\n"
"#      This sets the frequency table to one of the following definitions:\n"
"#        0       8-VSB ATSC bcast     1       QAM EIA-IRC\n"
"#        2       QAM EIA-HRC          3       QAM Std-IRC\n"
"#        4       QAM Std-HRC          5       QAM us-cable\n"
"#\n"
"# Saddr:port\n"
"#       If C-line cable optional parameters are specified for remote EPG\n"
"#      this address and port are used for the remote atscap EPG server.\n"
"#      You can use a name and put it in /etc/hosts. You will need to\n"
"#      co-ordinate to the remote server for your C-line rpgn/repg values.\n"
"#\n"
"# I lines, user interface settings. Can be omitted. Updates on next save.\n"
"#\n"
"# Cptc:call:net:auto:program:audio[:rpgn:repg]\n"
"#      ptc is offset in F[0-5] frequency table; call is 7 chars; \n"
"#      net is 3 chars; auto is non-zero to get EPGs every 3hrs\n"
"#      program is MPEG program number; audio is 0 or 1 (SAP)\n"
"#       [cable option: get bcast EPG program rpgn from remote EPG repg]\n"
"#\n"
"# Vchannel:yyyymmdd:hh:mm:len:nameX\n"
"#      channel = LCN index, date and start time, len in minutes\n"
"#       It is converted to this when the config is saved:\n"
"#       Vchannel:epochseconds:len:nameX\n"
"3        where epoch starts at 00:00:00 1-Jan-1970\n"
"#\n"
"# Wchannel:hh:mm:len:days:nameX\n"
"#     channel = LCN index, daily start time, len in minutes, days to cap\n"
"#\n"
"# Zname or Zptc[:drift] (PTC not LCN) time service configuration\n"
"#     Zname will use ntpdate to fetch time from ntp server 'name'.\n"
"#      I know ntpdate is deprecated, but it is working well enough here.\n"
"#\n"
"#     Z0 will disable any time adjustments. This is the default, because.\n"
"#      most people already have ntpd running and also because most stations\n"
"#      are still sending useless timestamps in the ATSC STT. It is possible\n"
"#      you will find 1 good ATSC STT source on bcast or cable. If you find\n"
"#      one that works, but has stable offset, use :drift offset (seconds).\n"
"#\n"
"#     Zhost runs ntpdate to host every 3 hours or use broadcast time with:\n"
"#     Zptc = offset in F[0-5] frequency table that has working ATSC STT\n"
"#      drift = ATSC STT drift, use +/- offset seen on console bottom right.\n"
"#\n"
"#  SEE ALSO:\n"
"#              atscap_conf(5)\n"
"#\n\n"
            );
#endif

/* if cable, use EPG server line for broadcast to cable matching */
        if (0 != arg_frtable) fprintf( o, "F%d\n\n", arg_frtable);
        if (0 != *epg_srv) fprintf( o, "S%s\n\n", epg_srv);

#ifdef USE_WWW
/* save web user interface config */
        fprintf( o, "I%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d\n\n",
                web_config,
                web_legend,
                web_stats,
                scan_png,
                scan_snr,

                pgm3.find,
                pgm3.hide,
                pgm3.age,

                epg_grd,
                epg_sb,
                use_css
        );
#endif

/* save automatic search list */
//      fprintf( o, "# Search events\n");
        for (i=0; i<search_idx; i++) {
            fprintf( o, "A%s", search_list[i].name );
            memset( ba, 0, sizeof(ba));
            if (search_list[i].chan >= 0) {
                fprintf( o, ":%02d", search_list[i].chan);
                if (search_list[i].days > 0) {
                    utoab( ba, 7, search_list[i].days );
                    fprintf( o, ":%s", ba );
                }
            }
            advrlog( LOG_INFO, "%s auto search %s:%d:%7s", WHO,
                    search_list[i].name, search_list[i].chan, ba);
            fprintf( o, "\n");
        }
        if (search_idx > 0) fprintf( o, "\n");

/* save channels on the scan list */
        for (i=0; i<scan_idx; i++) {
            ch = scan_list[i];
            s = &ptc[ ch ].sig;

/* old style */
            fprintf( o, "C%02d:%s:%s:%d:%d:%d:%d:%d\n",
                    s->ptc, s->call, s->sid, s->pgto, s->pn, s->va,
                    s->pnx, (s->pnx < 1)?0:s->pnxf );

#if 0
/* new style */
            fprintf( o, "D%02d:%d:%d:%s:%s",
                    s->ptc, s->pn, s->va, s->call, s->sid);

            if (0 != s->pgto) {
                    fprintf( o, ":%d", s->pgto);
                    if (0 != s->pnx)
                        fprintf( o, ":%d:%d",
                                s->pnx, (s->pnxf < 0)?ch:s->pnxf );
            }
            fprintf( o, "\n" );
#endif

/* save timers that match the channel */
            for (j = 0; j < timer_idx; j++) {
                t = &timer[j];

                if (T_SEARCH == t->qstat) continue;
                if (-1 == t->start) continue;
                if (scan_list[i] != t->chan) continue;

/* volatile timers, kept until expired */
                if (   (-1 != t->start) /* !search */
                    && ((t->start + t->len) > utsnow) /* !expired */
                    && (0 == t->days) /* !daily/weekly */
                    )
                {

/* Save volatile timer */
                    fprintf( o, "V%02d:%010d:%03d:%s\n",
                                t->chan, t->start, t->len/60, t->name );

                    advrlog( LOG_INFO, "%s vtimer V%02d:%010d:%05d:%s\n",
                                WHO,    t->chan, t->start, t->len, t->name );
                    continue;
                }               

/* Arrival here means it's a weekday timer */

                memset( ba, 0, sizeof(ba));
                utoab( ba, 7, t->days );
            
                fprintf( o, "W%02d:%02d:%02d:%03d:%s:%s\n",
                        t->chan,
                        t->h,
                        t->m,
                        t->len / 60,
                        ba,
                        t->name );

                advrlog( LOG_INFO, "%s wtimer W%02d:%02d:%02d:%03d:%s:%s",
                        WHO,
                        t->chan,
                        t->h,
                        t->m,
                        t->len / 60,
                        ba,
                        t->name );
            }
            fprintf( o, "\n");
        }
        fprintf( o, "\n");

/* Save Time source */
        fprintf( o, "# Zch gets time from PTC ch. Zhost gets time from ntpd\n");
        if (cap_zc > 0) {
            fprintf( o, "Z%d", cap_zc);
            if (0 != cap_zd) fprintf( o, ":%d", cap_zd);
        } else {
            if (0 != *ntp_name) {
                fprintf( o, "Z%s", ntp_name);
            } else {
                fprintf( o, "Z0");
            }
        }
        fprintf( o, "\n\n");

        fflush( o );
        fclose( o );

/* make configuration auto-reload not trigger, no need for it */
        i = stat( fn, &st ); /* get file time AFTER close */

/* no error? */
        if (i == 0) {
/* global cf file time is now, more or less */
            cf_mt = (int)st.st_mtime;
        }

        advrlog( LOG_INFO, "saved config %s", fn);
}

/*  if timer[q] has weekday bits, add schedule interval to timer[q].start
    otherwise delete the volatile timer and sort the timer list.
*/
/* static */
void
reschedule_timer ( int q, char *caller )
{
    if ((q < 0) || (q >= timer_idx)) return; /* sanity check */

    if (T_SEARCH == timer[ q ].qstat) return; /* nop search events */

    advrlog( LOG_INFO, "%s -> timer[%d] %s",
            caller, WHO, q, timer[q].name);

    if (0 != timer[ q ].days) { /* weekday bits? */
        timer[ q ].start += timer[ q ].future;
        timer[ q ].future = calc_future_date( q );

/* clear event name and description */
        timer[ q ].ename[0] = 0;
        timer[ q ].edesc[0] = 0;

/* config does not change for weekday timers, only start time */
/*      timer_sort = ~0;        */ /* caller should do this */
        refresh.timers = 1;

    } else {                    

/* no rescheduling possible for volatile timer, only delete */
        delete_timer ( q, WHO );

/* config does change, save it */
        save_config( WHO );
        refresh.timers = 1;
    }
}

/* show all timers currently in the timer list.
 it also checks current time against timer for timer events.
 show clock calls this once per second to trigger timers.
 */  
/* TODO: split apart and simplify */
/* static */
void
show_timers ( void )
{
    int i, k, j;
    int timer_check = 0; /* -1 if current time not within timer range */
    int oldstatus;
    int tl = 0;
    char *sc, *tc, *rc; /* status, timer, reschedule colors */
    char chan_rec[16];
    char len_rec[16];
    char dst;
    struct qtimer_s *t;
    
    /* hold down while config reloads */
    if (0 != timer_lock) return;

    memset( date_rec, 0, sizeof(date_rec));
    memset( date_fut, 0, sizeof(date_fut));
    memset( chan_rec, 0, sizeof(chan_rec));
    memset(  len_rec, 0, sizeof( len_rec));

    k = 4; /* default for everything except channel list */
    if ( D_CHANNELS == display_type ) k = 2;

/* should fix using g p v from channel list */
    if ( D_TIMERS == display_type )
        snprintf( csp, sizeof(csp)-1, "%s", "\033[3;1H");
    
    /* no timers, nothing to do except erase timer[0] 'DONE' display */
    if ( 0 == timer_idx )
    {
        /* only do this once refresh flag set, then reset the flag */
        if ( (0 != refresh.timers) && ( D_TIMERS == display_type ) )
        {
            for (i = 0; i < user_lines; i++)
                aprintf( stderr, "\033[%d;1H" CEL, k+i+1 );
            refresh.timers = 0; /* nothing to refresh */
        }

        /* stop an existing timer capture if one in progress */
        /* in case config file reload erased the current one */
        if ( CAP_TIME == cap_now )
            stop_capture( "show_timers stopped last timer 0", FAIL_NONE );
        return; /* nothing left to do, no more timers */
    }

        
/* debug pause each update of timer list
    if ( CAP_NONE == cap_now) while ( console_getch() == 0 );
 */
    
    /* STATUS:  TODAY FUTURE ACTIVE STREAM IGNORE DONE,
                FUBAR! if not handled for whatever reason
     */


    /* one-shot re-sort every time this called */
    if (timer_sort != 0) {
        advrlog( LOG_INFO, "%s triggers sort_timers", WHO );
        sort_timers();
        /* set up one-shot re-draw */
        refresh.timers = 1;
    }

/* check timer 0 for active, returns -1 if not currently active */
    timer_check = test_timer( 0 );

#if 1
/* FIXME: this is where the double-start of back-to-back timers occurs */
/* timer0 not within current time. was timer cap that is now over */
    if (-1 == timer_check) {
        if (CAP_TIME == cap_now) /* was timer cap, now over */
            stop_capture( "show_timers timer_check == -1", FAIL_NONE );
    }
#endif

    /* display status for each timer, set/clear cap_now */
    for (j = 0; j < user_lines; j++)
    {

/* scrolling EPG, then exit to timer list makes timer #'s go negative */
        if (timer_offset < 0) timer_offset = 0;

/* default is space, but will chg to - or + for timer DST overlap */
        i = j + timer_offset;
        
/* end of list blanks the rest of screen  then turns off refresh until needed
        if ( i >= timer_idx) break; // list done yet?
*/
        if ( i >= timer_idx)
        {
            if (0 != refresh.timers)
            {
                if ( D_TIMERS == display_type )
                {
/* annoying: blanks pkt stat display until 1s refresh timeout */
/*                  aprintf( stderr, "\033[%d;1H%s", j+k+1, CCE); */
                    aprintf( stderr, "\033[%d;1H%s", j+k+1, CEL);
/*                  refresh.timers = 0;  */
                }
            }
            continue;
        }

        t = &timer[i];

/* if this changes, timer refresh is set for list update */
        oldstatus = t->qstat;
        
        sc = tc = rc = BN;

        snprintf( chan_rec, sizeof(chan_rec)-1, "%2d", t->chan); 

/* search timers have optional chan and wd but no dates or lengths */
/*    advrlog( LOG_INFO, "%s check %s %s", WHO, t->name, st_a[t->qstat] ); */
            
    if (T_SEARCH == t->qstat) {
        t->tcol = sc = BM;
        date_rec[0] = 0;
        date_fut[0] = 0;
        len_rec[0] = 0;
        if (0 == t->chan) chan_rec[0] = 0;

/*      advrlog( LOG_INFO, "%s T_SEARCH0 %s", WHO, t->name); */

    } else {

        /* weekday bits set? */
        if (t->days != 0)
        {
            dst = ' ';
            trec2 = t->start + t->future;
            memcpy( &tloc2, localtime( &trec2 ), sizeof( tloc2 ) );

/* indicate timer future dst status differs from timer start */
            if (tloc2.tm_isdst != tloc.tm_isdst )
            {
                if (tloc2.tm_isdst != 0) {
                    dst = '+'; /* spring forward */
//                  trec2 -= SECHR;
                } else {
//                  trec2 += SECHR;
                    dst = '-';  /* fall back */
                }
                /* fix display time */
                memcpy( &tloc2, localtime( &trec2 ), sizeof( tloc2) );
            }

            snprintf( date_fut, 17, "%s", asctime( &tloc2 ) );
            /* date_fut[16] = 0; */
            date_fut[10] = dst;
        } else {
            date_fut[0] = 0; /* no future date, no text to display */
        }

        timer_check = test_timer( i ); /* returns -1 or i */
        
/* reschedule done weekday timer, or remove if volatile timer */
        if (-1 == timer_check) {
            if (timer_idx > 0) {
                if (timer[0].qstat == T_DONE) {
                    reschedule_timer( 0, WHO );
                }
            }
        }
        /* see if timer needs to start or be ignored */
        if ( i == timer_check )
        {
            /* check cap now flag to see if start or ignore */
            switch( cap_now )
            {
                /* no cap in progress, ok to activate */
                case CAP_NONE:
                    sc = BR;
                    tc = BG;
                    
                    t->qstat = T_ACTIVE; /* only visible until AOS done */
                    advrlog( LOG_INFO, "%s T_ACTIVE0 %s", WHO,
                            t->name);

                    cap_chan = t->chan;
                    timer_rec = i; /* set the current cap queue */
                    cap_now = CAP_TIME;

                    display_type = D_TIMERS; /* 0 */
                    break;

                /* manual cap already in progress, ignore this timer */
                case CAP_USER:
                    t->qstat = T_IGNORE;
                    advrlog( LOG_INFO, "%s T_IGNORE0 %s", WHO,
                            t->name);
                    /* force list update, manual timer ignored */
                    /* refresh.timers = 1; */
                    break;

/* triggers after ACTIVE, which displays until cap starts */
                case CAP_TIME:
                    if (i == timer_rec)  /* if i == 0 should do same */
                    {
                        t->qstat = T_STREAM;
                        advrlog( LOG_INFO, "%s T_STREAM0 %s", WHO,
                                t->name);
                        cap_chan = t->chan;
                        sc = BW;
                        tc = BW; /* current active timer is bright white */
                    } else {
                        t->qstat = T_IGNORE;
                        advrlog( LOG_INFO, "%s T_IGNORE1 %s", WHO,
                                t->name);
                    }
                    break;

/* info cap needs to stop when timer activates */
                case CAP_INFO:
                    t->qstat = T_ACTIVE;
                    advrlog( LOG_INFO, "%s T_ACTIVE1 %s", WHO,
                            t->name);
                    stop_capture( "show timers2", FAIL_NONE);

/* this isn't working? maybe needs a hold down until cap stopped */
                    /* return; */
                    break;

                default:
                    break;
            }
        }

        /* if stop time is in the past, see if can queue for future */
        if ((t->start+(t->len-t->secdt)) < utsnow)
        {
            /* note: changes from this too quick to see this */
            t->qstat = T_DONE;
            advrlog( LOG_INFO, "%s T_DONE0 %s", WHO,
                            t->name);
            sc = BW;
            tc = BW;

            display_type = D_TIMERS; /* 0 */

            /* if this timer has weekday bits, reschedule it */
            if ( t->days != 0 ) {
                /* fix start to next re-queue time */

                advrlog( LOG_INFO, "weekday timer calc future date %s",
                    t->name);

                t->future = calc_future_date( i );
                t->start += t->future;

                /* list needs resorting since it's aged to bottom */
                timer_sort = ~0;
                refresh.timers = 1;
/* otherwise this is a volatile timer that needs removal */
            } else {
/* don't remove search timer entry with start -1 */
                if (-1 != t->start) {

/* remove timer, should call delete_timer() instead? */
/* shouldn't need sorting */
                    int m;

                    advrlog( LOG_INFO, "%s volatile timer %s deleted",
                            WHO, t->name);

                    /* not last timer in list? */
                    if (i < (timer_idx - 1) ) {
                        for (m=i+1; m < timer_idx; m++)
                            memcpy( &timer[m-1],
                                    &timer[m],
                                    sizeof(struct qtimer_s) );
                    }
                    timer_idx--;
                    refresh.timers = 1;

/* update config to remove the expired timer */
                    save_config( WHO);

/* volatile got deleted, see if next on list is search timer */
                    if (T_SEARCH == t->qstat) {
#if 0
                        t->tcol = sc = BM;
                        date_rec[0] = 0;
                        date_fut[0] = 0;
                        len_rec[0] = 0;
                        if (0 == t->chan) chan_rec[0] = 0;
                        advrlog( LOG_INFO, "%s T_SEARCH0 %s", WHO,
                                t->name);
#endif
                        refresh.timers = 1;                 
/* loop needs to restart or else it will corrupt the first search entry */
                        return;

                    }
                }
            }
        }

        /* start time in future? */
        if (t->start > utsnow)
        {
            /* less than 0000 hours tomorrow means it's a timer for today */
            if ( t->start < (utsmid+SECDAY) ) {
                t->qstat = T_TODAY;
                advrlog( LOG_INFO, "%s T_TODAY0 %s", WHO, t->name);
                sc = BG;
                rc = BN;
                tc = BN;

                t->future = calc_future_date( i );
                if (i > 0) {
                    struct qtimer_s *t0 = &timer[i-1];
                    struct qtimer_s *t1 = &timer[i];

                    if ( (t1->start >= t0->start)
                      && (t1->start < t0->start+t0->len) ) {
                            t->qstat = T_IGNORE;
                            advrlog( LOG_INFO, "%s T_IGNORE2 %s", WHO,
                                    t->name);
                        }
                }
            } else {
                t->qstat = T_FUTURE;

/*              advrlog( LOG_INFO, "%s T_FUTURE0 %s", WHO, t->name); */

                tc = rc = sc = BN;
                t->future = calc_future_date( i );
            }

            /* if weekday reschedule bits set */
            if ( t->days != 0 ) {
                /* does timer start after 23:59:59 today? */
                if ( t->start >= (utsmid + SECDAY) ) {
                    t->qstat = T_FUTURE;

/*                  advrlog( LOG_INFO, "%s T_FUTURE1 %s", WHO, t->name); */

                    tc = rc = sc = BN;
                }
            }

/* if more than 1 timer */
            if (i > 0) {
                struct qtimer_s *u;
                u = &timer[i-1];

/* if timer overlaps previous, set ignore */
                if ( (t->start >= u->start)
                  && (t->start < (u->start + u->len)) )
                {
                    t->qstat = T_IGNORE;
                    tc = rc = sc = BR;
                }
            }

/*      blink red when within 30 minutes of activation
        red is within 1 hour
        yellow is 1-6,
        cyan is 6-12,
        green is 12+ (default)


TODO: Change timer line colors to:
        brite white blink for cap
        brite white for within 30m
        brite cyan within 1 hr
        brite yellow within 3 hours
        brite green within 12 hours
        brite red ignored timer
        normal is search name or more than 12 hours in future 

    Timer status colors:
        brite white streaming
        brite magenta search
        brite green today
        brite red ignore
        normal future
*/
            if ( (t->start) < (utsnow + SECDAY) )
            {
                tc = BG; /* start at green and work upwards */

/* tc should be constant for the compiled file */
                if (t->start < (utsnow + (SECHR * 12)))  tc = BC;
                if (t->start < (utsnow + (SECHR * 6)))   tc = BY;
                if (t->start < (utsnow + SECHR))         tc = BR;
                if (t->start < (utsnow + (SECMIN * 30))) tc = BR BL;
                if (T_IGNORE == t->qstat) rc = tc = BN;

/* if timer color is different, trigger timer redraw */
                if (t->tcol != tc)
                {
                    refresh.timers = 1;
                    t->tcol = tc;
                }
            }
        }
        snprintf( chan_rec, sizeof(chan_rec)-1, "%2d", t->chan);

/* round timer len up to nearest minute */
        tl = t->len / 60;
        if ( (t->len % 60) >= 1) tl++;
        snprintf( len_rec, sizeof(len_rec)-1, "%3d", tl);
    }
        
        /* if status changed, redraw all timers */
        if (oldstatus != t->qstat) refresh.timers = 1;

        if ( 0 != refresh.timers )
        {
            /* convert weekday bits to ascii bits */
            utoab( bascii, 7, t->days );

            /* if it was all 0, don't display it */
            if (t->days == 0) bascii[0] = 0;
            
            trec1 = t->start;
            memcpy( &tloc1, localtime( &trec1 ), sizeof( tloc1 ) );

            dst = ' ';

            /* indicate current DST status is different from timer DST status */
            if (tloc1.tm_isdst != tloc.tm_isdst)
            {
                if (tloc1.tm_isdst != 0) {
                /* subtract hour for correct display time */
//                  trec1 -= SECHR;
                    dst = '+'; /* spring forward */
                } else {
                    /* add hour for correct display time */
//                  trec1 += SECHR;
                    dst = '-'; /* fall back */
                }
                /* start time display corrected for DST; fix tloc1 same */
                memcpy( &tloc1, localtime( &trec1 ), sizeof ( tloc1 ) );
            }

/* date_rec gets time string after DST fix if any */
            if (T_SEARCH != t->qstat) {
                snprintf( date_rec, 17, "%s", asctime( &tloc1 ) );
                date_rec[10] = dst;
            }
            if (T_IGNORE == t->qstat) sc = BR;

/* show timer */
            if ( D_TIMERS == display_type ) {

                aprintf( stderr, "\033[%d;1H" BN
                /*      tn   stat   ch   name    */
                        "%3d %s%s %s%2s %-19s ",
                        j+k+1, i, sc, st_a[t->qstat], tc, chan_rec, t->name);

/* turn off blink with BN */
                aprintf( stderr, "%16s %3s "BN , date_rec, len_rec);

                if (0 != t->days) {

/* build weeday ECMA-48 highlighted string */
                    batowd( i );
                    aprintf( stderr,  BK "%s %s%16s" BN,
                        wecma,
                        rc,
                        date_fut );

                } else {
/* volatile timer will try to fill in with partial episode description */
                    char d[PDZ];
                    int cm;
                    cm = columns - 55;
                    if (cm < 0) cm = 24;
                    if (cm > sizeof(d)) cm = PDZ - 1;

                    astrncpy( d, t->edesc, cm);

                    aprintf( stderr, "%s%s", BN, d );
                }
                aprintf( stderr, CEL );
            }
        }
    }

    /* one-shot output redux */
    refresh.timers = 0;
}


/* delete renamed file, gets called more than once */
/* static */
void
remove_renamed ( void )
{
    char f[256];
    int rmdone;

    rmdone = 0;

    /* this is a one shot */
    if ( 0 != *del_name ) {

        /* if path, point past it */
        filebase( f, del_name, F_FILE);

        /* CR instead of NL to overwrite same line */
        aprintf( stderr, CR "remove %s" CEL, f);
        advrlog( LOG_INFO, "remove1 %s", f );

        /* dummy doesn't do remove, and neither does -o */
        if (0 == test_mode)
            if ( 0 == *arg_ofile )
                remove( del_name );
        
        rmdone = 1;

        /* del_name is a one shot, so clear it */
        *del_name = 0;
    }

/* removed the renamed del_name file, now check for zap remove too */


/* user hits z to remove the previous and current files */
    if (0 != cap_zap) {
        filebase( f, out_name, F_FILE );
        advrlog( LOG_INFO, "ZAP%02d %s", cap_chan, f );
        if ( out_file > 2 ) {

/* if path, point past path */

/* CR instead of NL to overwrite same line */
            aprintf( stderr, CR "zap %s" CEL, f ); 

/* not dummy? */
            if (0 == test_mode) {

/* not cli single capture? */
                if ( 0 == *arg_ofile ) {

/* order of removal is important to web ui, so refresh doesn't show log href */
                    filebase( f, out_name, F_PFILE );

/* remove transport stream log file */
                    snprintf( del_name, sizeof(del_name), "%s.html", f);
                    remove( del_name );
                    advrlog( LOG_INFO, "removed %s", del_name);

/* remove transport stream sequences and frames file */
                    if (0 != arg_frames) {
                        snprintf( del_name, sizeof(del_name), "%s.tsx", f);
                        remove( del_name );
                        advrlog( LOG_INFO, "removed %s", del_name);
                    }

                    *del_name = 0;

/* big file last so web ui refresh looks correct */
                    remove( out_name );
                    advrlog( LOG_INFO, "removed %s", out_name);
                }
            }
        }

/* zap is also a one shot, so clear it */
        cap_zap = 0;
        cap_zapped = ~0;
        rmdone = 1;
    }
}

#ifdef USE_SIGNALS
/* want to close the device properly if possible */
/* static */
void
signal_test ( void )
{
        if (0 == sig_val) return; /* nothing to do? */
        if (sig_val < 32)
                advrlog( LOG_INFO, "received SIG%s", sig_text[sig_val] );

        switch( sig_val )
        {

/* these three indicate user requested program terminate */
        case SIGINT:
        case SIGTERM:
        case SIGQUIT:
                sig_kill = ~0;
                dvrlog( LOG_INFO, "exiting on signal %d", sig_val);
                stop_capture( WHO, FAIL_NONE );
                break;

/* GNU screen changed the term size, or xterm was resized */
        case SIGWINCH:
                dvrlog( LOG_INFO, "%s tty dimension changed", WHO);
                test_termsize();
                break;

        case SIGPIPE:
                dvrlog( LOG_INFO, "%s broken pipe or socket", WHO);
                break;

/* even with SEGV still want to try to close device properly if possible */
        case SIGSEGV:
                sig_kill = ~0;
                break;

        default:
                if (sig_val < 32)
                    dvrlog( LOG_INFO, "%s signal %s ignored",
                        WHO, sig_text[sig_val] );
                break;
        }
        sig_val = 0;
}

#endif

/* proto this one rather than esc handling below */

/* non-blocking non-echoing single-char stdin, from mzplay.c */
/* static */
int
console_getch ( void ) {
    unsigned c = 0;

#ifdef USE_SIGNALS
    signal_test();      /* any flags worth noticing? */
    if (0 != sig_kill) console_exit(0);
#endif
    if (0 != arg_detach) return 0;

    if (console_init) {
        struct termios modes;
        int f;

        console_init = 0;

        if ( tcgetattr(0, &modes) < 0 )
            advrlog( LOG_ERR, "c_getch tcgetattr" );

        modes.c_lflag &= ~ICANON;
        modes.c_lflag &= ~ECHO;

        if ( tcsetattr(0, TCSAFLUSH, &modes) < 0 )
            advrlog( LOG_ERR, "c_getch tcsetattr" );

        f = 0;
        fcntl( 0, F_GETFL, &f );
        f |= O_NONBLOCK;
        fcntl( 0, F_SETFL, f );
    }
    if ( read( 0, &c, 1 ) < 1 ) c = 0;

/* sleep is not always good, can miss keys */
/*    nanosleep( &console_read_sleep, NULL); */
    return c;
}

/*
 when console scan gets ESC, look for [ and if so do these
 make easier to use with following keys: up/dn/lt/rt/hm/in/dl/en/pu/pd
*/
/* static */
void
console_scan_esc ( unsigned char *kb )
{
    unsigned char k;
    int arrow;

    *kb = console_getch();      /* get char after ESC */
    if (0 == *kb) return;       /* nothing pending from function keys */
    if ('[' != *kb) return;     /* no [ means no arrows or function keys */


/*    utstpg = utsnow + PROGRAM_GUIDE_TIMEOUT; */

/*    nanosleep( &console_read_sleep, NULL); */
    *kb = console_getch();      /* get what follows ESC [ */

    /* should be cursor/arrow keys */
/*    dvrlog( LOG_INFO, "ESC[ %02X", *kb); */

    arrow = 0;
    /* "ESC [" and 4 choices for arrows are A B C D */
    switch( *kb ) {
        /* no chars to clear after these */
        case 'A':
            *kb = KB_UP;        /* UP ARROW */
            arrow = ~0;
            break;

        case 'B':
            *kb = KB_DN;        /* DOWN ARROW */
            arrow = ~0;
            break;

        case 'C':
            *kb = KB_RT;        /* RIGHT ARROW */
            arrow = ~0;
            break;

        case 'D':
            *kb = KB_LF;
            arrow = ~0;
            break;

        case 'H':
            *kb = KB_HM;        /* HOME */
            arrow = ~0;
            break;

        case 'F':
            *kb = KB_EN;        /* END */
            arrow = ~0;
            break;

    }

    /* have an arrow so get out, no need for ~ term */
    if (arrow != 0) return;
    
    /* checked for arrows, kb still has numeric, so check for ~ term char */
    k = console_getch();
    if (0 == k)   { *kb = 0; return; } /* it's incomplete so abort */
    if ('~' != k) { *kb = 0; return; } /* no ~ term char so abort */
    
    /* check char after ESC [ again */
    switch ( *kb ) {

        case '7':               /* newer aterm doing this? */
        case '1':
            *kb = KB_HM;        /* HOME */
            break;

        case '2':
            *kb = KB_IN;        /* INSERT */
            break;

        case '3':
            *kb = KB_DL;        /* DELETE */
            break;

        case '8':               /* newer aterm doing this? */
        case '4':
            *kb = KB_EN;        /* END */
            break;

        case '5':
            *kb = KB_PU;        /* PAGE UP */
            break;
        case '6':
            *kb = KB_PD;        /* PAGE DOWN */
            break;
        default:
            *kb = 0; /* try to prevent false triggers if no conditions met */
            break;
    }

    return;
}

/* wrapper to return keyboard special keys as single byte */
/* static */
void
console_getch_fn ( unsigned char *kb )
{
/*      nanosleep( &console_read_sleep, NULL ); */
        *kb = console_getch();

#ifdef USE_POWERDOWN
/* any key resets dvb power down time */
        if (0 != *kb) utspdd = utsnow + USE_POWERDELAY;
#endif

        if (0x1B != *kb) return; /* let normal keys slide */
        console_scan_esc( kb ); /* try to parse function keys */
}


/* REMOVEME: this is now obsolete because s->chan is scan_list offset */
/* this will break on cable. what calls it? */
/* return scan list index of channel, if not found, return 0 (ch 2) */
/* static */
int
get_scanlist_offset ( unsigned int channel )
{
        int i;
        for (i=0; i<scan_idx; i++)
                if (scan_list[i] == channel)
                        return i;
        return 0;
}

/*
 timed signal lock check

 return 0 if no lock, 1 if lock, channel is provided in sig_s s*

 If caller wants avgs, s->*_sum = 0; then do math after (x) calls.
  s->lock_sum is what you use for math against other s->*_sum

 It usually takes a few of these, if not already tuned in, because of
  tank stabilization and AGC adjustments. You can actually see the
  AGC kick in on HD2/3000 after a few calls on a weaker station.

 This also times get signal and puts the inverse of time difference
  into scan_rate for tracking number of scans doable in one second.
*/
/* static */
void
get_signal_lock ( struct sig_s *s )
{
        int ir = 0;
        struct timespec sig_start = { 0, 0 };
        struct timespec sig_stop =  { 0, 0 };
        struct timespec sig_diff =  { 0, 0 };

/* want to keep track of how many scans per second can be done */
        clock_gettime( clock_method, &sig_start );

/* PORTABILITY:
    Set channel enforces at least a 250ms delay on frequency change. It's
   probably better to use 500ms but the console seems sluggish with that.
   Delay after tuning should be enforced by device driver and not by user.

   HD3000 driver is zeroing the min_delay_ms. What do other drivers do?
*/
        set_channel( s, WHO );

        s->lock = 0;
        s->strength = 0;

#undef SIG100
#ifdef SIG100
        s->lock = 1;
        s->strength = 100; /* leave color normal to alert it's fake */
        scan_rate = 10; /* was 9 */
        return;
#endif

/* dummy */
        if (test_mode != 0) {
                clock_gettime( clock_method, &sig_stop );
                return;
        }

/* new method from ideas in dvb-atsc-tools and Peter Knaggs */
        if ( (0 == test_mode) && (0 == arg_dummy) )
        {
                s->strength = 0;        /* if the ioctl fails, */
                s->freqr = s->freq;     /* want freqret same as freqset */
                s->fohz = 0;            /* and offset 0 hz */

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

/* NOTE: latest patched driver reads all the raw data with read status, then
    read SNR and read signal strength work on data collected by read status.
    This is to reduce i2c chatter on the unreliable HD3000 i2c bus, which
    could probably be fixed with 1uF coupling cap on i2c clock and data lines.
    This should be compatible with older drivers as well, but the i2c
    chatter will be 3x higher than with my v4l-dvb-HD3000-ATSC-0.3 driver.
*/
                ir = ioctl( fe_file, FE_READ_STATUS, &fe_status );
                ir = 0;                         /* dummy the status check */

                if (ir < 0) {
                        dvrlog( LOG_INFO, "FE READ STATUS fail %d", ir);
                        return;
                }
                advrlog( LOG_INFO, "%s FE READ STATUS 0x%04X %s", s->call, fe_status,
                        (fe_status & FE_HAS_LOCK)?"FE_HAS_LOCK":"");

                s->lock = (fe_status & FE_HAS_LOCK) ? 1:0;

                if (0 == s->lock) return;

                ir = ioctl( fe_file, FE_READ_SIGNAL_STRENGTH, &fe_strength);
                s->strength = fe_strength/655;

                advrlog( LOG_INFO, "%s FE READ STRENGTH %04X %02d%% ",
                         s->call, fe_strength, s->strength);
                if (ir < 0) {
                        dvrlog( LOG_INFO, "FE READ STRENGTH PTC %02d FAILED %d",
                                s->chan, ir);
                        return;
                        console_exit(EIO);
                }

                ir = ioctl( fe_file, FE_READ_SNR, &s->snr);
                advrlog( LOG_INFO, "%s FE READ SNR dB %2d.%02d ",
                         s->call,
                         0xFF & s->snr>>8,
                         (0xFF & s->snr * 100) >> 8 );

                if (ir < 0) {
                        dvrlog( LOG_INFO, "FE READ SNR PTC %02d FAILED %d",
                                s->chan, ir);
                        return;
                        console_exit(EIO);
                }

#ifdef USE_DVB_EXPERIMENTAL
/* This is a new option for or51132.c. It won't work with stock driver. */
/* Save frequency offset for display with [w] key. */
                ir = ioctl( fe_file, FE_GET_FRONTEND, &fe_param );
                if (0 == ir) {
                        s->freqr = fe_param.frequency;
                        s->fohz = s->freqr - s->freq;   
                }

                ir = ioctl( fe_file, FE_READ_BER, &fe_ber );
                s->ber = 0;
                if (0 == ir) s->ber = fe_ber;
#endif
        }

        if (s->strength > 100) s->strength = 100; /* clamp to 100% */
/* color the signal even without the lock, colors are 0 to 7 */

        s->sig_col = &bc[ 7 & (s->strength / 13)][0];   /* sanity limit */
        s->smp[ s->smx ] = s->strength;
        s->rmp[ s->smx ] = s->snr;
        s->smx++;

        s->smx %= SIG_PNG_W;
// might be faster to use below to avoid a branch?
//      if (s->smx >= SIG_PNG_W) s->smx = 0;

        clock_gettime( clock_method, &sig_stop );

        time_diff( &sig_diff, &sig_start, &sig_stop );

#if 0
/* demoth time delay on signal scan acquisition time */
        dvrlog( LOG_INFO, "ss %ld.%09ld se %ld.%09ld sd %ld.%09ld", 
                sig_start.tv_sec, sig_start.tv_nsec,
                sig_stop.tv_sec, sig_stop.tv_nsec,
                sig_diff.tv_sec, sig_diff.tv_nsec);
#endif

        scan_rate = 10; /* 10 scans/second max */
        /* anything over one second is bogus, avoid divide by zero */
        if ( (sig_diff.tv_sec == 0) && (sig_diff.tv_nsec != 0) )
        {
                struct timespec scan_sleep;
                scan_rate = 999999999/sig_diff.tv_nsec;
/*              advrlog( LOG_INFO, "sig scan rate %d/s period %d nS",
                        scan_rate, (int)sig_diff.tv_nsec );
*/
                if (scan_rate < 1) scan_rate = 1; /* no zero allowed */
                if (scan_rate > 20) scan_rate = 20;

                scan_sleep.tv_sec = 0;
                scan_sleep.tv_nsec = 5000000; // * scan_rate;

//              nanosleep(&scan_sleep, NULL);
        } else {
                if (test_mode == 0)
                        advrlog( LOG_INFO, "%s: signal scan rate bogus", WHO );
        }
        return;
}

/*
manual timer validate
    check list of current timers for tstart to tstart+tlen
    return:
        0 if no error
        1 if time overlap with existing timer
note:
 it will be a valid result only if all start timers don't match
 it doesn't check against future time nor weekday bits
*/
/* static */
int
validate_timer ( int tstart, int tlen )
{
    int i, tstop;
    struct qtimer_s *t;

    return 0;

/* FIXME: not implemented yet because I can move intersecting timers */

    for (i=0; i < timer_idx; i++) {
        t = &timer[i];
        /* first check for tstart intersecting a timer */
        if ( (tstart >= t->start)
          && (tstart <= (t->start + t->len) ) )
            return 1;

        /* then check for tstop intersecting a timer */
        tstop = tstart + tlen;
        if ( (tstop >= t->start)
          && (tstop <= (t->start + t->len) ) )
            return 1;
    }
    /* if the sets do not intersect, return no error */
    return 0;
}

/* clear all the timers */
/* static */
void
reset_timers ( void )
{
/* faster  */
    memset( timer, 0, sizeof(timer) );
    timer_idx = 0;
/* reset does not save list in case user screwed up, but next addition will */
}




/*
 user input of timer # to reque. allows range, same as delete
 is actually copy of get timer delete with names changed
 */
/* static */
void
get_timer_reschedule ( void )
{
    char req_in[16];
    char *warn = BW;
    char req_r[8];
    unsigned int req_r1;
    unsigned int req_r2;
    char *p;
    int i;
    
    /* turn echo and blocking back on, get input */
    while ( 1 )
    {
        aprintf( stderr, SCV BL
                    "%s%sReschedule which timer(s) (0-%d) ?"BN" " CEL,
                    dca.hstat, warn, timer_idx-1 );
        console_reset();
        req_in[0] = 0;
        
        fgets( req_in, sizeof(req_in)-1, stdin );

        /* dummy read to reset back to nonblock/nonecho */
        console_getch();
        
        /* redraw header and return if <ENTER> */
        if ( req_in[0] == 10 ) {
            show_headers(0);
            /* aprintf( stderr, "%s%s" CEL, dca.hstat, header2 ); */
            return; 
        }

        /* remove any terminating NL */
        if ( req_in[ strlen( req_in ) - 1 ] == 10 )
            req_in[ strlen( req_in ) - 1 ] = 0;
            
        warn = BR; /* 2nd or more try at input */

        if (strlen(req_in) > 7)
            continue; /* junk, try again */

        sscanf( req_in, "%7s", req_r );

        req_r1 = atoi( req_r );
        req_r2 = req_r1;

        p = strchr( req_r, '-' ); /*  - means range */
        if (NULL != p) {
            *p++ = 0;
            req_r2 = atoi( p );
        }               

        /* user input error check */
        if  (  (req_r1 >= timer_idx)
            || (req_r2 >= timer_idx)
            || (req_r2 < req_r1)
            ) continue;

        break;  
    }

    /*
     reschedule can re-arrange it anywhere, so prevent sort until done,
     unlike delete where it only makes sense to remove the first one
     as the others bump upwards
     */
    timer_sort = 0;
    refresh.timers = 0;

    for (i = req_r1; i <= req_r2; i++)
        reschedule_timer( i, WHO );

    advrlog( LOG_INFO, "get timer reque triggers timer sort and list" );
    refresh.timers = 1; /* need to redraw */
    timer_sort = ~0; /* need to resort */
    show_headers(0);
    show_timers();
/* reque does not need to save list, uses same daybits
    save_config( WHO );
*/
}

/* console 'r' key, remove or reschedule timer.
    it does not remove the capture file if active timer 0
*/
/* static */
void
timer_reschedule( void )
{
        struct sig_s *s;

        if (CAP_TIME == cap_now) {

/* prevent add search event timer endless loop */
            if (-1 != timer[0].etmid ) {
                s = &ptc[ cap_chan ].sig;
                s->lzpgt = timer[0].start;
            }
        }

        get_timer_reschedule();
}

/* conzole 'z' key, zap stops any cap but also stops test epg looping.
    it also deletes the capture file for the current capture.
*/
/* static */
void
timer_zap( void )
{
        struct sig_s *s;

        if (CAP_NONE == cap_now) return; /* no cap no zap */
/* tell ts capture to remove the files when capture terminated */
        cap_zap = ~0;

        if (CAP_INFO == cap_now) {
            stop_capture( "info zap", FAIL_NONE);

/* if zap aborts epg_test it should set next test epg 30 seconds ahead */
            if (0 != epg_test) utstpg = utsnow + 30;

/* tell test epgs to stop looping */
            epg_test = 0;

            return;
        }

/* don't allow it to restart unless user adds via console or web ui */
        if (CAP_TIME == cap_now) {
            if (-1 != timer[0].etmid ) {
                s = &ptc[ cap_chan ].sig;
                s->lzpgt = timer[0].start;
            }
/* it can be presumed that timer0.qstat is always T_STREAM here? */
            if (T_STREAM == timer[0].qstat)
                reschedule_timer(0, WHO);
        }

        stop_capture( WHO, FAIL_NONE );
}

/* interactive user input of timer:
        ch hh mm len daymask label

    ch  2 - 69 channel
    hh  0 - 23 start hour
    mm  0 - 59 start minute
    len 1-360 program length
    daymask is binary, e.g. SMTWTFS=0111110 to do monday to friday only
    label is [not?] optional filename to save as, blank uses mmdd-hhmm-ch

OLD BUGS FINALLY FIXED:
    27-mar-2006
    when daybits prior to today, and same as today but timer has passed,
    it would get the start time wrong and require load config to correct it.

    19-Aug-2007
    when putting in a volatile timer, with no daybits set, if the time given
    has passed, the timer is ignored instead of being set for tomorrow.
*/
/* static */
void
get_timer_add ( void )
{
        int i, c, h, m, r;
        char timer_in[64];      /* timer input string */
        char nbuf[32];  /* timer name buffer */
        char wdbuf[16];
        unsigned int wd;
        char *warn = BW;
        int ttime, ttlen, ttchan;
        int wdo, wdu;

        wdbuf[0] = 0;
        nbuf[0] = 0;

        if (timer_idx == TIMER_LIST_MAX) {
                aprintf( stderr, BL BR
                        "%s TIMER MAX REACHED. Delete before adding more."
                        CEL BN, dca.hstat );
                nanosleep( &msg_long_sleep, NULL );     
                show_headers(0);
                return;
        }

/* turn echo and blocking back on, get input */
        while ( 1 )
        {
                aprintf( stderr, SCV BL
                             "%s%sCh Hh Mm Len Wd Name or +Search:Ch:Wd >"
                            BN" " CEL, dca.hstat, warn );
                console_reset();
                fgets( timer_in, sizeof(timer_in)-1, stdin );

/* dummy read to reset back to nonblock/nonecho */
                console_getch();
        
/* do nothing if <ENTER> */
                if ( timer_in[0] == 10 ) {
                        show_headers(0);
/* aprintf( stderr, "%s%s", dca.hstat, header2); */
                        return; 
                }

        /* remove the NL */
                if ( 10 == timer_in[ strlen( timer_in ) - 1 ] )
                        timer_in[ strlen( timer_in ) - 1 ] = 0;
            
                warn = BR; /* 2nd or more try at input */

/* TODO: try to leverage parse search for this, but not really important
   since user can edit the config for the same effect
 */
/* check for +search event */
                if ('+' == timer_in[0]) { /* add if doesn't already exist */
                        advrlog( LOG_INFO, "add search timer");

                        parse_search_event( &timer_in[1] );
                        sort_searchlist();
                        save_config( WHO );
                        timer_sort = ~0;
                        refresh.timers = 1;
                        show_headers(0);
                        return;
                }

                if (strlen(timer_in) < 5) continue; /* junk, try again */

                sscanf( timer_in, "%d %d %d %d %s %s",
                        &c, &h, &m, &r, wdbuf, nbuf );

                if ( strlen(nbuf) < 1 ) continue;

                wd = 0;
/* try to convert ascii binary to weekday value */
                if ( ('0' == *wdbuf) || ('1' == *wdbuf) ) wd = abtou( wdbuf );

/* range check: h 0-23, m 0-60, r 1-360, c 0-ptcmax */
                if ( (h >= 0) && (h < 24)
                  && (m > -1) && (m < 60)
                  && (r > 0)  && (r < 360) /* 6 hours */
                  && (c >= 0)  && (c < ptc_max) /* channel range check */
                  && (wd < 0x80)
                )
/* loop until a good value is input, or [ENTER] to exit */
                        break;
        }

        if (0 == wd) {
                dvrlog( LOG_INFO, "add volatile timer");

        } else {
                dvrlog( LOG_INFO, "add weekday timer");
        }

/* number of seconds from 0000 hours when timer starts */
        ttime = (SECHR * h) + (60 * m);

/* number of seconds in timer */
        ttlen = (60 * r);

/* current scan/cap channel */
        ttchan = c;

/* make sure it's only 7 bits */
        wd &= 0x7F;

#if 0
/* NO: use IGNORE status to warn user. */
/* make sure no timers in list conflict */
        int ok;
        ok = validate_timer( ttime, ttlen ); /* nop for now */
        if (ok != 0) return;
#endif

    
        if (timer_idx >= TIMER_LIST_MAX) {
                dvrlog( LOG_INFO, "%s recompile with larger TIMER_MAX", WHO);
                return;

        }

/* fix midnight if it wrapped during input */
        get_time();
        wdo = wdu = 0; /* volatile for today has 0 offset */

/* silly math tricks, find how many weekdays from now if not today,
    wdo will be: 0 to 6 * SECDAY
*/
#if 1
        if (wd != 0) {
                for (i=6; i>=0; i--) if (wd & (1 << i)) break;
                wdu = 6 - i; /* back to localtime 0 sunday ... 6 saturday */
                wdo = wdu - tloc.tm_wday; /* 0 is today, positive is future */
                if (wdo < 0) wdo += 7; /* negative is not useful? */
                wdo *= SECDAY; /* number of seconds per day */
        } else {

/* If it's a volatile, and the timer is expired, add 24 hours to it.
    The presumption being the user is trying to enter a volatile timer for:
    a) an event before midnight but after now, b) an in-progress event, or
    c) an event occurring tomorrow but current time is past timer hh:mm+len.
*/
                int et;
                et = utsmid + ttime + ttlen;

/* This adds logic path c).  Logic paths a) and b) already done. */
                if (utsnow > et) wdo = SECDAY;
        }
#endif

        timer[timer_idx].start = utsmid + wdo + ttime;
        timer[timer_idx].len   = ttlen;
        timer[timer_idx].chan  = ttchan;
        timer[timer_idx].days  = wd;
        timer[timer_idx].qstat = T_FUTURE;
        timer[timer_idx].secdt = 5; /* minimum AOS time */

        if (wd != 0) {
                timer[timer_idx].future = calc_future_date( timer_idx );

#if 0
/* prevent user from seeing expired timer change to correct timer.
   user should see only the corrected timer.
*/
                if (utsnow > timer[timer_idx].start) {
                    timer[timer_idx].start = timer[timer_idx].future;
                    timer[timer_idx].future = calc_future_date( timer_idx );
                }
#endif
        }

        astrncpy( timer[timer_idx].name, nbuf, TIMER_NAME_MAX );
        timer_idx++;

        if (timer_idx > 0) {
                /* make the list look neat */
                advrlog( LOG_INFO, "timer add triggers timer sort and list");
                timer_sort = ~0; /* defer sort until display */
                refresh.timers = 1; /* make display happen */
        }
        save_config( WHO ); /* add saves list */
        show_headers(0);
        show_timers();
}


/* user input to remove timer */
/* static */
void
get_timer_delete ( void )
{
    char del_in[16];
    char *warn = BW;
    char del_r[8];
    unsigned int del_r1;
    unsigned int del_r2;
    char *p;
    int i;
    
    /* turn echo and blocking back on, get input */
    while ( 1 )
    {
        aprintf( stderr, SCV BL
                    "%s%sDelete which timer(s) (0-%d) ?"BN" " CEL,
                    dca.hstat, warn, timer_idx-1 );
        console_reset();
        del_in[0] = 0;
        
        fgets( del_in, sizeof(del_in)-1, stdin );

        /* dummy read to reset back to nonblock/nonecho */
        console_getch();
        
        /* redraw header and return if <ENTER> */
        if ( del_in[0] == 10 ) {
            show_headers(0);
            /* aprintf( stderr, "%s%s" CEL, dca.hstat, header2 ); */
            return; 
        }

        /* remove any terminating NL */
        if ( del_in[ strlen( del_in ) - 1 ] == 10 )
            del_in[ strlen( del_in ) - 1 ] = 0;
            
        warn = BR; /* 2nd or more try at input */

        if (strlen(del_in) > 7) /* 3 digits - 3 digits */
            continue; /* junk, try again */

        sscanf( del_in, "%7s", del_r ); /* 3 digits - 3 digits */

        del_r1 = atoi( del_r);
        del_r2 = del_r1;
        p = strchr( del_r, '-'); /* - means range */
        if (NULL != p) {
            *p++ = 0;
            del_r2 = atoi( p );
        }               

        /* user input error check */
        if  (  (del_r1 >= timer_idx)
            || (del_r2 < del_r1)
            || (del_r2 >= timer_idx)
            ) continue;

        break;  
    }

/* keep removing the same timer because the list bumps up */
/* the problem here is delete search events screws up timer idx */

    for (i = del_r1; i <= del_r2; i++) {
        if (T_SEARCH == timer[ del_r1 ].qstat) {
            advrlog( LOG_INFO, "%s del_r1 %d", WHO, del_r1);
            /* remove search + events */
            delete_search_event( del_r1, WHO );
            break; /* only one because timer idx changed and r2 is useless */
        } else {
            delete_timer( del_r1, "range remove" ); /* remove events */
        }
    }
    advrlog( LOG_INFO, "timer delete triggers timer list" );
    refresh.timers = 1; /* need to redraw */
    timer_sort = 0; /* sort not needed if list is already sorted */
    show_headers(0);

    /*    show_timers(); */
    /* use status update, but it feels slower that way? */

    /* delete saves list but does it have to ? */
    save_config( WHO );
    /* yes, but prob only if deleted one with weekday bits */
}

/*
 move a single volatile or a single weekday timer # tm to config file # tc
 assumes parsing for sanity been done
 i.e.
      do not write to same cfg file this instance uses
      do not write non-existent timer
 timers are removed from local config after move to other config
*/
/* static */
void
move_timer ( int tm, int tc )
{
    FILE *f;
    char fo[256];
    char ba[8];
    char o[80];
    
    if (T_SEARCH == timer[tm].qstat) return; /* see move search event */
    
    snprintf( fo, sizeof(fo)-1, "%s%s%d.conf", cfg_path, NAME, tc);
    advrlog( LOG_INFO, "moving timer %s %d to %s", timer[tm].name, tm, fo);
    /* open for append: timer line of text at end of file */
    f = fopen( fo, "a");


    if ( NULL != f ) {                          /* only if open worked */
        trec1 = timer[tm].start;                /* set up time */
        memcpy( &tloc1, localtime( &trec1 ), sizeof(tloc1) );

        if (timer[tm].days != 0) {              /* is manual weekday event? */
            utoab( ba, 7, timer[tm].days ); /* set up weekday bit string */
            ba[7] = 0;

            snprintf( o, sizeof(o)-1, "W%02d:%02d:%02d:%03d:%s:%s",
                    timer[tm].chan,
                    tloc1.tm_hour,
                    tloc1.tm_min,
                    timer[tm].len / 60,
                    ba,
                    timer[tm].name );
        } else {                                /* handle volatile timers */

            snprintf( o, sizeof(o)-1, "V%02d:%010d:%05d:%s",
                    timer[tm].chan,
                    timer[tm].start,
                    timer[tm].len,
                    timer[tm].name );
        }
        dvrlog( LOG_INFO, "%s %s %s", WHO, fo, o );
        fprintf( f, "%s\n", o );
        delete_timer( tm, "move timer"); /* remove the timer after moving */
        fclose( f );

    } else {
        dvrlog( LOG_INFO, "error appending %s", fo);
    }
    save_config( WHO );
    refresh.timers = 1;
}

/* moves search timer entry and all matching events */
/* static */
void
move_search_event ( int tm, int tc )
{
    FILE *f;
    char fo[256];
    char tn[32];
    char wd[8];
    char o[1024]; /* want at least 16 entries of 64 chars for move */
    char *p;

    int i, tf; /* counter, timer found */

    p = o;
    
    /* only moving search events */
    if (T_SEARCH != timer[tm].qstat) return;

    snprintf( tn, sizeof(tn)-1, "%s", timer[tm].name);
    snprintf( fo, sizeof(fo)-1, "%s%s%d.conf", cfg_path, NAME, tc);
    advrlog( LOG_INFO, "moving search %s %d to %s", tn, tm, fo);
    /* open for append: timer line(s) of text at end of file */
    f = fopen( fo, "a");

    if (NULL != f) {
        tf = 0; /* no event search or event timer found */

        /* copy search event */
        snprintf( p, 1 + SEARCH_NAME_MAX, "A%s", tn);
        p = o + strlen(o);
        if (0 != timer[tm].chan) { /* channel limit */
            p = o + strlen(o);
            snprintf( p, 4, ":%02d", timer[tm].chan);
            if (0 != timer[tm].days) { /* weekday limit */
                utoab( wd, 7, timer[tm].days );
                wd[7] = 0;
                p = o + strlen(o);
                snprintf( p, 9, ":%7s", wd );
            }
        }

        advrlog( LOG_INFO, "%s", o); /* first one uses o, rest use p */
        p = o + strlen(o);
        snprintf( p, 2, "\n");
        p = o + strlen(o);

        /* copy any volatile timers that match search event */
        for (i = 0; i < timer_idx; i++) {
            tf = 0;
            if (p >= ( o + sizeof(o) ) ) break; /* limit string build */

            /* don't move other search events */
            if (T_SEARCH == timer[i].qstat) continue;

            if (0 == strncasecmp( timer[i].name, tn, strlen(tn) ) ) tf = ~0;

            /* if match found, copy the timer */
            if (0 != tf) {
                trec1 = timer[i].start;
                memcpy( &tloc1, localtime( &trec1 ), sizeof(tloc1) );

                if (0 == timer[i].days) {
                /* is not weekday event, handle volatile event, len seconds */
                    snprintf( p, 64, "V%02d:%010d:%05d:%s\n",
                            timer[i].chan,
                            timer[i].start,
                            timer[i].len,
                            timer[i].name );
                    advrlog( LOG_INFO, "%s", p);
                }

/* don't want to repunch this. for now, don't move weekdays w/ search */
#if 0
                if (0 != timer[i].days) {
                /* is weekday event, set up weekday bit string, len minutes */
                    utoab( wd, 7, timer[i].days );
                    wd[7] = 0;

                    snprintf( p, 64, "T%02d:%02d:%02d:%03d:%s:%s\n",
                            timer[i].chan,
                            tloc1.tm_hour,
                            tloc1.tm_min,
                            timer[i].len / 60,
                            wd, 
                            timer[i].name );
                    advrlog( LOG_INFO, "%s", p);
                }
#endif

                p = o + strlen(o); /* move to end of string */
            }
        }

/* one fell swoop to prevent race condition from corrupting load config
   on the target. daybits confusion should now be fixed, too
 */
        fprintf( f, "%s", o);
        fclose( f );

        advrlog( LOG_INFO, "delete search event %d %s", tm, tn);

/* maybe needs to delete more than one search event? still deciding.
   as in the case of search for CSI, CSIMiami, CSINY, CSICrime
   this is only an issue if you use multiple CSI* entries instead of only CSI
 */
        delete_search_event( tm, WHO );
        /* latest dvrlog stops at first NL, so convert NL to space for log */
        for (i=0; i< strlen(o); i++) if ('\n' == o[i]) o[i] = ' ';
        advrlog( LOG_INFO, "%s %s\n%s", WHO, fo, o );

    } else {
        dvrlog( LOG_INFO, "error appending %s", fo);
    }
    save_config( WHO);
    refresh.timers = 1;
}

/*
 move timer to another configuration file, only useful for multicard.
 nothing damaged w/o multicard, but does append to destination config
 to create a junk timer file you could look at later.
*/
/* static */
void
get_timer_move ( void )
{
    char timer_in[8];
    char *warn = BW; /* no warn color first time */
    int tm = 0;
    int tc = 0;

    /* turn echo and blocking back on, get input */
    while ( 1 )
    {
        aprintf( stderr, SCV BL
                    "%s%sMove timer nn to config n <tt c> ?"BN" " CEL,
                    dca.hstat, warn );
        console_reset();
        timer_in[0] = 0;
        
        fgets( timer_in, sizeof(timer_in)-1, stdin );

        /* dummy read to reset back to nonblock/nonecho */
        console_getch();
        
        /* redraw header and return if <ENTER> */
        if ( timer_in[0] == 10 ) {
            show_headers(0);
            return; 
        }

        /* remove any terminating NL */
        if ( timer_in[ strlen( timer_in ) - 1 ] == 10 )
            timer_in[ strlen( timer_in ) - 1 ] = 0;
            
        warn = BR; /* 2nd or more try at input */

        /* need 3 chars min, TIMER [SPACE] DESTCFG */
        if ( strlen( timer_in ) < 3 )
            continue; /* junk, try again, not enough chars */

        sscanf( timer_in, "%2d %1d", &tm, &tc );

        if ( (tm < 0) || (tm > timer_idx) )
            continue; /* junk, try again, use valid timer this time */

        if ( (tc > 3) || (tc < 0) || (tc == arg_devnum) )
            continue; /* junk, try again, sanity limit on confile file write */

/* volatiles are allowed to be moved now
        if ( timer[tm].days == 0)
            continue; / junk, not moving FTO temp timers
*/          
        /* if you get this far, input might be useful, so get out of loop */
        break;  
    }

    if (T_SEARCH != timer[tm].qstat) {
        move_timer( tm, tc );
    } else {
        move_search_event( tm, tc );
    }
    

/* NO: it's sorted before move, and therefore after, too
    advrlog( LOG_INFO, "get timer move setting sort timer" );
    timer_sort = ~0;
*/
    timer_sort = 0;
    refresh.timers = 1;
    show_headers(0);
/*    save_config( WHO ); */ /* move saves list */
}


/* parse chan, call and id's from config file Cx lines
     *p is pointer to string to parse for channel # and id strings
    data stored in ptc[chan]sig.sid & sig.call
    scan_list is populated and scan_idx set to number of channels found.
    duplicates are discarded, so only the first one counts
  CPTC:CALL:SID:GTO:PN:PA:PX:XN
  px is program xlate. non zero means do the xlate on this in load_epg.
     it requires the source (remote) epg to have same ch.epg name file.
  xf use this number .epg file for xlate if specified
     make sure it gets set to -1 so it doesn't keep trying to get 00.epg
     also the remote fetch should use this number and save as NN.epx
*/
/* static */
void
parse_channel ( char *t )
{
        FILE *f;
        struct sig_s *s = NULL; /* sig_s member of ptc */
        struct utimbuf ut;
        char *p[8], tf[256];            /* parameters, touch file */
        int ch, i;

        if (NULL == t) return;
        if (0 == *t) return;

        advrlog( LOG_INFO, "%s (%s)", WHO, t);

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

/* TESTME: load cfg may exclude this? */
        if (scan_idx >= ptc_max) {
                dvrlog( LOG_INFO, "%s scan_idx %d exceeds list limit of %d",
                        WHO, scan_idx, ptc_max );
                return; /* not fatal */
        }

        build_args( p, 8, t, ':', WHO );

        if (NULL == p[0]) return;
        if (0 == strlen(p[0])) return;

        ch = atoi( p[0] );

/* discard bogus channel if over maximum allowed channels */
        if ( (ch < 1) || (ch >= ptc_max) ) {
                /* let user know what the problem is */
                dvrlog( LOG_INFO, "parse channel %d error: range is 1 to %d",
                        ch, ptc_max-1);
                return;
        }

/* discard bogus frequency from bogus channel */
        if ( (0 == frequencies[ch]) || (-1 == frequencies[ch]) ) {
            dvrlog( LOG_INFO, "%s PTC %d has -F%d entry = %d",
                    WHO, ch, arg_frtable, s->freq);
            return;
        }

        i = scan_idx;
        scan_idx++;

/* save index in scan_list and increment, starting at logical ch 0 */
        scan_list[i] = i;
// was = ch for physical channel numbering, can't revert it easily now

        s = &ptc[ i ].sig;
        s->freq = frequencies[ ch ];

/* set defaults in case parse fails */
        s->chan = i;
        s->ptc = ch;
        s->pn = -1;
        s->vc = -1;
        s->va = -1;
        s->pnx = 0;
        s->pnxf = -1;
        s->lzpgt = 0;
        s->pgmt = 0;
        s->pgto = 0;

        memset( s->call, 0, 8);
        memset( s->sid, 0, 4);

/* s->chan is offset into scanlist (logical channel number) */

        snprintf( s->call, 8, "C%03d", s->chan ); /* 7 char callsign */
        if (NULL != p[1]) snprintf( s->call, 8, "%s", p[1] );

        snprintf( s->sid, 4, "%03d", s->ptc);   /* 3 char network id */
        if (NULL != p[2]) snprintf( s->sid, 4, "%s", p[2] );

/* auto guide time-out */
        if (NULL != p[3]) s->pgto = atoi( p[3] ); /* any non zero to enable */
        if (0 != s->pgto) s->pgto = 1; /* 1 to enable auto EPG */

/* TODO: move these to [1],[2], after PTC */
        if (NULL != p[4]) s->pn = atoi( p[4] ); /* program number */
        if (NULL != p[5]) s->va = atoi( p[5] ); /* audio number */

        if (NULL != p[6]) s->pnx = atoi( p[6] );
        if (NULL != p[7]) s->pnxf = atoi( p[7] );

/* this might be irritating to the web user if it resets itself
    constantly. reset it only if the day is passed.
*/
//      if ((s->yday >=0) && (s->yday < tloc.tm_yday))

        s->yday = tloc.tm_yday;

/* old vc 0 sets full cap to make user set the new program # */
        if (s->pn < 1) s->pn = s->vc = s->va = s->yday = -1;

/* pre-load pgmt from existing EPG mod time, if any */
        if (0 != s->pgto) {
                struct stat st;
                char n[256];
                int ok;

                snprintf( n, sizeof(n)-1, "%s%spg/%02d.epg",
                        out_path, ram_path, s->chan );
                ok = stat( n, &st);
                s->pgmt = 0;
                if (0 == ok) s->pgmt = (int)st.st_mtime;
                advrlog( LOG_INFO, "stat %s %d %d", n, ok, s->pgmt);
        }

/* load the guide to do an auto search on the event names */
        load_guide( s->chan, WHO );

/* guide may not have loaded. try to set the vc anyway? */
        s->vc = find_vc_pgm( s->pn, WHO ); /* -1 is ok */

        advrlog( LOG_INFO, "%s sp %d sv %d sa %d",
                WHO, s->pn, s->vc, s->va);

/* touch .html file in case it's missing */
        snprintf( tf, sizeof(tf), "%s%spg/%02d.html",
                    out_path,ram_path, s->chan);
        f = fopen( tf, "a");
        if (NULL == f) {
                dvrlog( LOG_INFO, "can't open %s", tf);
        } else {
                fclose(f);
        }
        
/* reset .epg modtime so test guides will refresh it after load config */
        snprintf( tf, sizeof(tf), "%s%spg/%02d.epg",
                    out_path, ram_path, s->chan);
        ut.modtime = (time_t)(0L);
        utime( tf, &ut);


#ifdef USE_PNG
/* touch .png file in case it's missing */
        snprintf( tf, sizeof(tf), "%s%spg/%d-%02d.png",
                    out_path, ram_path, arg_devnum, s->chan);
        f = fopen( tf, "a");
        if (NULL == f) {
                dvrlog( LOG_INFO, "can't open %s", tf);
        } else {
                fclose(f);
        }
#endif

        advrlog( LOG_INFO, "%s %d stop", WHO, ch );
        advrlog( LOG_INFO, "\n");
}

#ifdef USE_WWW
/* -w name:netmask:port:threads
   example:
    -w 1.2.3.8:24:80:5
    24 is netmask as number of ms bits to set
    80 is port, defaults to 80 + arg_devnum if not specified
    5 is thread count for server instance 
*/
/* static */
void
parse_www_bind( char *o )
{
        char p[256], host[256], root[256], *p1, *p2, *p3, *p4, *p5;
        unsigned int addr, mask;
        unsigned short port;
        int pt, i, j;
        struct stat64 fs;

        if (NULL == o) return;
        if (0 == *o) return;

        advrlog( LOG_INFO, "%s (%s)", WHO, o);

        p1 = p2 = p3 = p4 = p5 = NULL;
        addr = 0;                               /* 0 triggers INADDR_ANY */

        mask = WWW_MASK;
        port = WWW_PORT + arg_devnum;   /* each instance defaults to new port */
        pt = WWW_THREADS;

        memset( p, 0, sizeof(p));
        memset( host, 0, sizeof(p));
        memset( root, 0, sizeof(p));

        astrncpy( host, WWW_IP, sizeof(host) );
        astrncpy( root, out_path, sizeof(root) );
        astrncpy( p, o, sizeof(p) );

        j = -1;

/* address required, 0.0.0.0 is INADDR_ANY */
        p1 = p;
        p2 = strchr( p1, ':');
        if (NULL != p2) {
                *p2++ = 0;

/* host name or IP address */
                astrncpy( host, p1, sizeof(host) );

/* netmask optional 0-32 or dotted notation, default no mask */
                j = atoi( p2 );
                p3 = strchr( p2, ':');
                if (NULL != p3) {
                        *p3++ = 0;

/* port optional 0-65535, default 80+dev# */
                        port = atoi( p3 );
                        p4 = strchr( p3, ':');
                        if (NULL != p4) {
                                *p4++ = 0;

/* threads optional, default 3 */
                                pt = atoi( p4 );

                        }
                }
        }

/* if mask not blank */
        if (NULL != p2) {
/* mask can be dotted notation or number of bits */
                if (NULL != strchr( p2, '.')) {
/* xlate dotted version */
                        dotouint( &mask, p2 );
                } else {
/* mask can be xlated from bit count */
                        if ((j > 0) && (j < 33)) {
                                mask = 0;
                                for (i = 0; i < j; i++) mask |= 1 << (31-i);
                        }
                }
        }

        astrncpy( host, p1, sizeof(host) );
        astrncpy( arg_whost, p1, sizeof(arg_whost) );

/* it might be a name or a dotted number. will false trigger on dotted name */
        if (NULL != strchr( host, '.'))
                dotouint( &addr, host );

/* 0 or -1 for port will give default port 80 */
        if (0 == port) port = WWW_PORT;
        if (0xFFFF == port) port = WWW_PORT;

        if (pt < 1) pt = WWW_THREADS;

        arg_wthreads = pt;
        arg_wmask = mask;
        arg_wport = port;

        i = stat64( root, &fs );
        if (0 == i) {
                if (S_IFDIR & fs.st_mode) {
                        advrlog( LOG_INFO, "using %s for www root\n", root);
                } else {
                    astrncpy( root, WWW_ROOT, WWW_ROOT_MAX );
                }
        } else {
                astrncpy( root, WWW_ROOT, WWW_ROOT_MAX );
        }

        if (0 == mask) {
                advrlog( LOG_INFO, "no mask given, host is w-w-w-ide open\n");
        }
        
        astrncpy( arg_wroot, out_path, sizeof(arg_wroot) );
        astrncpy( arg_whost, host, sizeof(arg_whost) );
        arg_wmask = mask;
        arg_wport = port;
        arg_waddr = addr;

/* binding to 0.0.0.0 requires using hosts/dns lookup for host dtv.
   this only matters for dump guides; index html uses thread ip name.
 */

/* name only? */
        if (NULL == strchr( host, '.')) {
                struct hostent *localhost;
                localhost = gethostbyname( host );
                if (0 != h_errno) {
                        dvrlog( LOG_INFO, "%s gethostbyname error %d %s",
                                NAME, h_errno, host );
                        fprintf( stderr, CLS "%s gethostbyname error %d %s\n",
                                NAME, h_errno, host );
                        exit(0);
                }

/* network byte order */
                addr  = 0xFF & localhost->h_addr[0];
                addr <<= 8;
                addr |= 0xFF & localhost->h_addr[1];
                addr <<= 8;
                addr |= 0xFF & localhost->h_addr[2];
                addr <<= 8;
                addr |= 0xFF & localhost->h_addr[3];
                arg_waddr = addr;
        }
}
#endif

/* step thru timer list fixing start times if weekday bits given
    TODO: could also remove overlapping timers, or at least the first one
*/
/* static */
void
validate_config (void)
{
    int i, j;
    int d;
    int c;

    c = 1;
    
    sort_timers(); /* move search timers to end */

    for (i = 0; i < timer_idx; i++) {

/* skip search events */
        if (T_SEARCH == timer[i].qstat) continue;

        if (i > 1) {
            if ( (timer[i-1].chan == timer[i].chan)
             &&  (timer[i-1].start == timer[i].start)
             &&  (timer[i-1].days == timer[i].days) ) /* tupari */
                    delete_timer( i, WHO );
        }

        if (timer[i].days != 0) {
            /* convert today weekday sun=0,sat=6 to bit # (sun=6,sat=0);
               start from today weekday and see if it matches weekday mask
             */
            d = tloc.tm_wday;

            /* wraparound up to a week */
            for (j = d; j < 14; j++) {
                /* find first set weekday bit and break out */
                if (timer[i].days & 1<<( (6-(j % 7) ) )) break;
            }

/* debug
            aprintf(stderr, "\n %s %d %d %d %d",
                    timer[i].name, timer[i].start, d, j, j - d);
 */
/* tricky math alert
   j can be 14, so that's 2 weeks in advance, should be ok
*/
            /* should be zero if current day is reschedule day */
            d = (j - d) % 7;
                    
            timer[i].start += (SECDAY * d);

            /* make reque same as submit time to catch non-repeating timers */
            timer[i].future = 0;

            /* this is enough to get everything calculated from today 0000h */
            if (timer[i].days != 0)
                timer[i].future = calc_future_date( i );

            /* but you need this to age out today stuff that is past */
            if ( (timer[i].start+timer[i].len) < utsnow )
                timer[i].start += timer[i].future;
        }
    }

    /* sort list by next activation time before using show_timers */
    advrlog( LOG_INFO, "valcfg triggers timer sort");
    timer_sort = ~0;
    sort_timers();
}


/*
 load config calls this to remove duplicate timers
 check for exact duplicate and return 0 if match else return non zero
*/
/* static */
int
test_timer_dup ( char *caller, char *n, unsigned int st, unsigned int ls )
{
    int i;
    struct qtimer_s *t;
    
    for (i=0; i< timer_idx; i++) { /* step thru known timers */
        t = &timer[i];
        if (T_SEARCH == t->qstat) continue;
        if ( 0 == strncmp( t->name, n, strlen(n) ) ) {
            if ( t->start == st ) {
                if (t->len == ls ) {
                    advrlog( LOG_INFO, "%s dup timer%d %s %s",
                            caller, i, t->name, n);
                    return 0; /* is exact duplicate */
                }
            }
        }
    }
    return ~0; /* not exact duplicate */
}


#if 0
/* IS THIS REALLY NEEDED TO FIX LCN ISSUES? IT BREAKS TOO MANY THINGS */
/* find logical channel number (scan list index) from (PTC) ch and pn */
/* static */
int
find_lcn_ptc_pn( int ch, int pn )
{
        int i;
        struct sig_s *s;

        if ( (ch < 0) || (ch > ptc_max) ) return -1;
        if ( (pn < 1) || (pn > 65534) ) return -1;

        for (i = 0; i < scan_idx; i++) {
            s = &ptc[ scan_list[i]].sig;
            if (ch != s->ptc) continue;
            if (pn != s->pn) continue;
            return i;
        }

        return -1;
}
#endif

/*  parse timer in config file format 
    handles temp timer that has absolute epoch time, no daybits.
    p is config file string
    ignores temp timers that have expired
*/
/* static */
void
parse_volatile_timer ( char *s )
{
        int ac, as, y, m, d, hh, mm, al, i, pn, ei;
        char *p[6], *n, *r, dt[32];
        struct qtimer_s *t;
        struct tm tmv;
        time_t at;

//      if (0 != arg_dummy) return;
        if (NULL == s) return;
        if (0 == *s) return;

        advrlog( LOG_INFO, "%s \042%s\042", WHO, s);

/* try the obvious disqualify */
        if (strlen( s ) > 52) {
            dvrlog( LOG_INFO, "timer too long %s", s);
            return;
        }

/* mangle s1 instead of s */
        ac = as = y = m = d = hh = mm = al = i = pn = 0;
        *dt = 0;

        if (timer_idx >= TIMER_LIST_MAX) {
            dvrlog(LOG_INFO, "rebuild with larger TIMER_LIST_MAX for %s", s);
            return;
        }

/* Two formats:
    Both formats will try to set 'as'.

    Old machine readable format
     with one new optional etmid field for EPG:

        ch:uts:lenm:name[:etmid]

    New human readable format:

        ch:yearmmdd:hh:mm:lenm:name

        32:20060917:23:35:60:StargateSG1@.3
 */

        i = build_args( p, 6, s, ':', WHO);
        if (i < 4) {
                dvrlog(LOG_INFO, "Bad config V-line: %s", s);
                return;
        }

        if ( NULL == p[0] ) return;
        ac = atoi(p[0]);

/* start uts or YYYYMMDD */
        if ( NULL == p[1] ) return;
        as = atoi(p[1]);

        ei = 0;

/**** old machine readable format: distinction fails with dates > 20991231 */
        if (as > 21000000) {
            if (NULL == p[2]) return;
            al = atoi(p[2]);            /* length in minutes */
            if ((al < 1) || (al > 1440)) return;
            al *= 60;
            if (NULL == p[3]) return;
            n = p[3];
            if (NULL != p[4]) ei = atoi(p[4]);

/***** new human readble format 20060820 */
        } else {
            y = as/10000;                       /* year > 2000 */
            m = (as-(y*10000)) / 100;           /* month 1-12*/
            d = as % 100;                       /* day of month 1-31 */

/* abort if range error */
            if (y < 2000) return;
            if ((m < 1) || (m > 12)) return;
            if ((d < 1) || (d > 31)) return;

            if (NULL == p[2]) return;
            hh = atoi(p[2]);            /* start hour < 24 */
            if ((hh < 0) || (hh > 23)) return;

            if (NULL == p[3])
            mm = atoi(p[3]);            /* start minute < 60 */
            if ((mm < 0) || (mm > 59)) return;

            if (NULL == p[4]) return;
            al = atoi(p[4]);            /* length in minutes < 1440 */
            if ((al < 1) || (al > 1440)) return;
            al *= SECMIN;

            if (NULL == p[5]) return;
            n = p[5];                   /* name */

/* valgrind */
            memset( &tmv, 0, sizeof( tmv ));

/* fill in time structure to convert to new as, al should be correct */
            tmv.tm_sec = 0;
            tmv.tm_min = mm;
            tmv.tm_hour = hh;
            tmv.tm_mday = d;
            tmv.tm_mon = m - 1;
            tmv.tm_year = y - 1900;

            as = mktime( &tmv );            /* convert to uts */
            at = (time_t) as;
            localtime_r( &at, &tmv );

/* if dst set for that date, subtract an hour from the time */
            if (tmv.tm_isdst > 0) as -= SECHR;
        }

/* stuff localtime into tmv, should handle dst ok even if display is wrong */
        at = (time_t) as;
        localtime_r( &at, &tmv );

/* parse didn't work */
        if (0 == *n) {
            dvrlog( LOG_INFO, "%s blank name %s", WHO, s);
            return;
        }

//    advrlog( LOG_INFO, "ac %d as %d al %d an %s s %s", ac, as, al, n, s );

/* timer is duplicate */
        if ( 0 == test_timer_dup( WHO, n, as, al) ) {
            advrlog( LOG_INFO, "timer %s is dup", s);
            return;
        }
    
/* timer is stale and expired */
        if ( utsnow > (as + (al-5))) {
                dvrlog( LOG_INFO, "timer is expired %d %d %s",
                        utsnow, as + (al-5), s);
                return;
        }

/* user error range check: channel number and length > 0 */
        if ( (ac >= 0) && (ac < ptc_max) && (al > 0) )
/* && (al < (1 + (24 * 3600))) ) */ /* KTRK event >1 day fix by no len chk */
        {
                i = timer_idx;
                t = &timer[i];
                timer_idx++;
        
                t->etmid = ei;
                t->qstat = T_FUBAR;
                t->chan = ac;

                t->start = as;
                t->len = al;
                t->days = 0; /* no daybits, timer removes itself on expiration */
                t->secdt = 5; /* 5 second early end for back to back AOS */
                astrncpy( t->name, n, TIMER_NAME_MAX );

                t->pn = t->va = t->vc = -1;

/* TESTME: if C-line is before V-line, is VC loaded from guide data?
   YES: if it exists from previous run, but not after make eclean
*/
/* parse program number from timer name */
                r = strchr( n, '.');
                if (NULL != r) {
                        r++;
                        pn = atoi( r );
                        t->pn = pn;
                        t->vc = find_vc_pgm( pn, WHO);
                }

/* parse progam audio number from timer name */
                r = strchr( n, ',');
                if (NULL != r) {
                        r++;
                        t->va = atoi( r );
                }       

/* TODO: use program number in channel # V13.1:10digits:60:LOST@ */
/* channel # needs to be expanded to 5 chars wide, ch.pn,
   or 6 if there are unscrambled cable sources above 99.9
 */
                advrlog( LOG_INFO, "%s %s %d.%d,%d", WHO, timer[i].name,
                        timer[i].chan, timer[i].pn, timer[i].va);

        } else {
            dvrlog( LOG_INFO, "%s range error: %s", WHO, s);
        }
        return;
}

/*  parse timer in config file format 
    ignores timers with no weekday bits set
        or crazy channel/hour/minute/runtime
*/
/* static */
void
parse_weekday_timer ( char *s )
{
        struct qtimer_s *t;
        char s1[64], *p[6], *aw, *an, *r;
        int ac, ah, am, ar; /* given */
        int ad, as, al; /* computed */
        int i;

//      if (0 != arg_dummy) return; /* no timers to confuse replay mode */

        if (NULL == s) return;
        if (0 == *s) return;

        advrlog( LOG_INFO, "%s (%s)", WHO, s );

        ac = ah = am = ar = ad = as = al = i = 0;
    
        if (timer_idx >= TIMER_LIST_MAX) {
            advrlog(LOG_INFO, "rebuild w/ larger TIMER_LIST_MAX for %s", s);
            return;
        }

/* try the obvious disqualify */
        if ( strlen(s) > 64 ) {
            advrlog( LOG_INFO, "timer too long, ignoring %s", s);
            return;
        }

        astrncpy( s1, s, sizeof(s1));

        i = build_args( p, 6, s1, ':', WHO );
        if (6 != i) return;

        if (NULL == p[0]) return;
        ac = atoi(p[0]);
        if ((ac < 0) || (ac >= ptc_max)) return;

        if (NULL == p[1]) return;
        ah = atoi(p[1]);
        if ((ah < 0) || (ah > 23)) return;

        if (NULL == p[2]) return;
        am = atoi(p[2]);
        if ((am < 0) || (am > 59)) return;

        if (NULL == p[3]) return;
        ar = atoi(p[3]);
        if ((ar < 0) || (ar > 1440)) return;

        if (NULL == p[4]) return;
        aw = p[4];

        if (NULL == p[5]) return;
        an = p[5];
        if (0 == *an) return;

        ad = abtou( aw );

/* user error range check: h 0-23, m 0-60, r 1-720 */
        if (   (ac >= 0) && (ac < ptc_max) /* ATSC channel range check */
            && (ah > -1) && (ah < 24)   /* no crazy hour */
            && (am > -1) && (am < 60)   /* no crazy min */
            && (ar > 0)  && (ar <= 1440) /* 720m is 70G ATSC or 56G MPEG2 */
            && (ad != 0)                 /* volatiles not handled here */
            && ( 0 != test_timer_dup( WHO, an, as, al ) ) /* not a dup? */
            )
        {
                i = timer_idx;
                timer_idx++;

                as = (SECHR * ah) + (SECMIN * am);
                al = (60 * ar);
                t = &timer[i];
                get_time();

/* channel offset adjust */
                t->chan = ac;
                t->qstat = T_FUBAR;

                t->h = ah;
                t->m = am;
                t->len = al;
                t->days = ad;

#if 1
/* timer starts today, but may get corrected later */
                t->start = utsmid+as;
#else
                calc_first_weekday(t); // FIXME
#endif
                t->secdt = 5; /* 5 second early end for back to back AOS */
                t->etmid = 0; /* not from program guide */

/* clear reschedule time, gets fixed later */
                t->future = 0;

/* with no EPG on cable, manual timers are the only game in town */

/* add program number? */
                r = strrchr( an, '.' ); /* .3 near end of timer name */
                if (NULL != r) {
                        r++;
                        t->pn = 0xFFFF & atoi(r);
                }

/* add audio number? limited to 4 audios per program */
                r = strrchr( an, ',' ); /* ,1 near end of timer name */
                if (NULL != r) {
                        r++;
                        t->va = 3 & atoi(r);
                }

/* FIXME: needs defined constant, or variable for screen size change */
                astrncpy( t->name, an, TIMER_NAME_MAX );

                advrlog( LOG_INFO, "%s timer%d %s c%d p%d s%d l%d d%d q%d",
                        WHO, timer_idx, t->name, t->chan, t->pn,
                        t->start, t->len, t->days, t->future);
        } else {
                dvrlog( LOG_INFO, "%s range error: %s\n", WHO, s);
        }

        return;
}

/* cfg_path & cfg_name is set by this and opened by load/save_config */
/* order for looking for the config file is:
        arg_cpath non-null will override directory
        /dtv/ram/atscap/
        /etc/atscap/
*/
/* static */
void
find_config ( void )
{
    int s;
    char n[256]; /* ridiculously long path */
    char *cp;
    struct stat cf;

/* default is /etc/atscap/atscap[0-3].conf */
    snprintf( cfg_name, sizeof(cfg_name), "%s%d.conf", NAME, arg_devnum);

/* default is not found */
    cf_no = ~0;

/* check for -c config overriding filename or pathname first */
    cp = arg_cpath;
    if ((NULL != cp) && (0 != *cp)) {

/* see if path or filename exists */
        s = stat( cp, &cf );

/* 0 means it exists */
        if (0 == stat(cp, &cf))  {

/* is it a file? if so, extract path and name */
            if (0 == (cf.st_mode & S_IFDIR)) {
                filebase( cfg_path, cp, F_PATH );
                filebase( cfg_name, cp, F_FILE );

/* -c path and name extracted */
                cf_no = 0;
            }

/* is it a dir? if so, copy and add / if doesn't have and test result */
            if (0 != (cf.st_mode & S_IFDIR)) {
                snprintf( cfg_path, sizeof(cfg_path)-1, "%s%s",
                         cp, (strrchr(cp, '/') == NULL) ? "/":"" );
                /* make full name, then check to see if default cfg is there */
                snprintf( n, sizeof(n)-1, "%s%s", cfg_path, cfg_name);
                s = stat( n, &cf );

/* no error and is regular file? */
                if ( (s == 0) && (0 != (cf.st_mode & S_IFREG)) )
                    cf_no = 0;
            }
        } else {

/* -c test failed, fall through to rest of checks */
            dvrlog( LOG_INFO, "ignoring bogus -c %s", arg_cpath);
        }
    }

/* if found, we're done here */
    if (0 == cf_no) {
        advrlog( LOG_INFO, "-c config is %s%s", cfg_path, cfg_name);
        return;
    }
    
/* default is /etc/atscap/atscap[0-3].conf */
    snprintf( cfg_name, sizeof(cfg_name), "%s%d.conf", NAME, arg_devnum);

/* still looking for config, try out_path/ram/atscapn.conf/ */
/* if ram_path "", it will check /dtv/ directory, dual purpose then */
    snprintf( n, sizeof(n), "%s%s%s", out_path, ram_path, cfg_name );
    s = stat( n, &cf );

/* exists and is regular file */
    if ( (0 == s) && (0 != (cf.st_mode & S_IFREG)) ) {
        snprintf( cfg_path, sizeof(cfg_path)-1, "%s%s", out_path, ram_path );
        cf_no = 0;
    }    

/* still looking for config, try /etc/atscap/ */
    if (0 != cf_no) {
        snprintf( n, sizeof(n), "/etc/%s/%s", NAME, cfg_name );
        s = stat( n, &cf );
        /* exists and is regular file returns */
        if ( (s == 0) && ( 0 != (cf.st_mode & S_IFREG)) ) {
            snprintf( cfg_path, sizeof(cfg_path)-1, "/etc/%s/", NAME );
            cf_no = 0;
        }
    }

/* anything found? */
    if (0 == cf_no) {
        advrlog( LOG_INFO, "config is %s%s", cfg_path, cfg_name);
    } else {
        dvrlog( LOG_INFO, "no config found");
    }
}



/* return -1 if not found, or spam list index if found */
/* static */
int
test_spam_name( char *p )
{
        int i;
        char c1, c2;
        struct spam_s *s;

        if (NULL == p) return -1;
        if (0 == *p) return -1;

        c1 = *p;
        if ((c1 >= 'A') && (c1 <='Z')) c1 |= 0x20;

/* ASCII tolower() */
/* find duplicates. lots of cycles used here */
        for (i = 0; i < spam_idx; i++) {
            s = &spam_list[i];
            c2 = *s->name;
            if ((c2 >= 'A') && (c2 <='Z')) c2 |= 0x20;
            if (c1 != c2) continue; /* save a stack cycle */

            if (0 == strncasecmp( s->name, p, s->len )) {
                s->st = utsnow;
                return i;
            }
        }
        return -1;
}

/* remove spam list entry n, move entries n+1 down one.
    n ranges from 0 to (spam_idx-1) */
/* static */
void
delete_spam( int n )
{
        int i;
        struct spam_s *s1, *s2;

//      WHOAMI;

        if (0 == spam_idx) return;
        if (n >= spam_idx) return;

        while (EBUSY == pthread_mutex_trylock( &spam_mutex ))
                nanosleep( &atomic_sleep, NULL );

/* not last entry in spam list? */
        if (n < (spam_idx - 1)) {

/* move spamlist up (towards 0) to cover current entry */
            for (i = n; i < spam_idx-1; i++) {
                s1 = &spam_list[i];
                s2 = &spam_list[i+1];
                memcpy( s1, s2, sizeof( struct spam_s ) );
            }
        }
        spam_idx--;
        if (spam_idx < 0) spam_idx = 0;

        pthread_mutex_unlock( &spam_mutex );
}

/* add spam list entry p, returns 0 ok(or dup), -1 list full */
/* static */
int
add_spam( char *p, int st )
{
        struct spam_s *s;

        if (SPAM_LIST_MAX <= spam_idx) {
            dvrlog( LOG_INFO, "spam list full, increase SPAM_LIST_MAX");
            return -1;
        }

        s = &spam_list[spam_idx];

/* adding to list clears entry before adding */
        memset( s, 0, sizeof( struct spam_s));
        astrncpy( s->name, p, SPAM_NAME_MAX );
        s->st = st;
/* store actual copied count not original length */
        s->len = strlen( s->name );

        spam_idx++;

        return 0;
}

/* Tired of editing 4 spamlists? Me too. use global /etc/atscap/atscap.spam */
/* To see spam click off junk filter on WebUI or [h] key in [p] EPG console */
/* static */
void
load_spamlist( void )
{
        FILE *f;
        char sf[256];   /* spamlist file name */
        char si[80];    /* input buffer */
        char sn[32];    /* spamlist name */
        char *ss;       /* spam start time */
        char *ok, *p;
        int k, st;
        time_t sm;
        struct stat fs; /* stat64 not needed for small file */

//      WHOAMI;

        get_time();

        memset( sn, 0, sizeof(sn));
        memset( si, 0, sizeof(si));

        snprintf( sf, sizeof(sf)-1, "%s%s.spam", cfg_path, NAME);
        k = stat( sf, &fs );
        if (0 != k) {
            advrlog( LOG_INFO, "can't stat %s", sf );
            return;
        }
/* file size needs at least 13 bytes, minimum "A:1234567890\nl" */
        if (fs.st_size < 13) return;

/* hold down until spam modify time changes by 5s */
//      if (cf_smt == fs.st_mtime) return;
        sm = fs.st_mtime - cf_smt;
        if (sm < 1) return;

        advrlog( LOG_INFO, "atscap.spam mt %d smt %d diff %ds",
                    (int)fs.st_mtime, cf_smt, (int)sm );

        cf_smt = fs.st_mtime;

        while (EBUSY == pthread_mutex_trylock( &spam_mutex ))
                nanosleep( &atomic_sleep, NULL );

//      WHOAMI;

        f = fopen( sf, "r" );

/* TODO: log error reason */
        if (NULL == f) {
                dvrlog( LOG_INFO, "can't open %s", sf );
                pthread_mutex_unlock( &spam_mutex );
                return;
        }


/* reset spam list */
        spam_idx = 0;
        memset( spam_list, 0, sizeof( spam_list ));

/* EOF is end of list, or MAX is */
        while (1) {
                if (spam_idx >= SPAM_LIST_MAX) break;   /* list full */

                ok = fgets( si, sizeof(si)-1, f );      /* read a line */
                if (NULL == ok) break;                  /* EOF */

/* # comment has human readable form of timestamp */
                p = strchr( si, '#');
                if (NULL != p) *p = 0;                  /* truncate at # */
                if (0 == *si) continue;                 /* skip blanks */

                si[ sizeof(si) - 1 ] = 0;               /* NUL term */
                si[ strlen(si) - 1 ] = 0;               /* toss NL */

                st = utsnow;
                ss = strchr( si, ':');                  /* point to time */

/* : is [?]optional last seen spam time. if not given, is now. See below. */
                if (NULL != ss) {
                    *ss = 0;                            /* remove : */
                    ss++;
                    sscanf( ss, "%d", &st);             /* text to time_t */
                }

#if USE_SPAM_TIMEOUT
/* This tries to automatically de-clutter the spam list.
    Expires spam after SPAM_AGE_MAX. This is disabled by default.
    Some unused station guides may not update for a long time.
*/
                if (st < (utsnow - SPAM_AGE_MAX)) {
                    dvrlog( LOG_INFO, "spam expired %s %d", si, st); 
                    continue; /* don't add to spam list */
                }
#endif

/* event truncate zero terms at 16 chars. one or two words, no spc */
                event_truncate( sn, si, 2, SPAM_NAME_MAX );

/* TODO: consolidate this? find is useful by itself */
                k = test_spam_name( sn );
                if (-1 == k) add_spam( sn, st );
        }

        fclose( f );

/* turn on spam filter if spam list has entries */
/* age filter is intentionally left off so user can see what just capped */
        if (0 < spam_idx ) {
            sort_spamlist( 0 ); /* spamlist by name for faster search */

/////////////////////////////////////////////////////////////
// DELETEME: bug: why does console always turn these back on?
//                      save_config only saves state of www?
//
//              pgm.age = ~0;
//              pgm.hide = ~0;
/////////////////////////////////////////////////////////////

        }

        advrlog( LOG_INFO, "%s mt %d with %d entries", WHO, (int)sm, spam_idx);

        pthread_mutex_unlock( &spam_mutex );
}

/* parse system time config line. captures on this channel set the time.
    time is given as Zchannel:offset. if offset is not given is assumed 0
 */
/* static */
void
parse_ztime ( char *t )
{
        char *p[2];
        struct sig_s *s;
        int i, ptch;

        cap_zc = 0;
        cap_zd = 0;
        cap_zto = 0;

        if (NULL == t) return;
        if (0 == *t) return;

        advrlog( LOG_INFO, "%s (%s)", WHO, t);

/* ignore build args return value, this one can be variable */
        build_args( p, 2, t, ':', WHO );


        ptch = atoi(p[0]);

/* has PTC number and not NTP name */
        if (ptch > 0) {
                if ((ptch < 1) || (ptch > ptc_max)) return;
                cap_zc = ptch;

/* drift offset is allowed to be negative */
                if (NULL != p[1]) cap_zd = atoi(p[1]);

/* find first matching ptc in scanlist and enable auto EPG to get ATSC STT */
                for (i = 0; i < scan_idx; i++) {
                        s = &ptc[scan_list[i]].sig;
                        if (ptch == s->ptc)
                        s->pgto = 1;
                }

        } else {
/* if parameter is not numeric, copy server name to use for ntpdate */
                memset(&ntp_name, 0, sizeof(ntp_name));
                strncpy( ntp_name, p[0], sizeof(ntp_name));
        }
}

/* Inum:[...]:num sets some defaults for the user interface */
/* static */
void
parse_webcfg( char *t )
{
        int i;
        char *p[11];

        if (NULL == t) return;
        if (0 == *t) return;

        advrlog( LOG_INFO, "%s (%s)", WHO, t);

        i = build_args( p, 11, t, ':', WHO);
        if (11 != i) return;

        web_config = atoi(p[0]);
        web_legend = atoi(p[1]);
        web_stats  = atoi(p[2]);;
        scan_png   = atoi(p[3]);
        scan_snr   = atoi(p[4]);

/* TESTME: this is where web interface interferes with console? */
        pgm3.find  = atoi(p[5]);
        pgm3.hide  = atoi(p[6]);
        pgm3.age   = atoi(p[7]);

        epg_grd    = atoi(p[8]);
        epg_sb     = atoi(p[9]);
        use_css    = 3 & atoi(p[10]); /* TODO rename this to html_ver */
}

/* Sserver config option adds the www server for cable EPG fetch */
/* broadcast doesn't need to do this */
/* static */
void
parse_epgsrv( char * t )
{
        if (0 == arg_cable) return;
        if (NULL == t) return;
        if (0 == *t) return;

        advrlog( LOG_INFO, "%s (%s)", WHO, t);

        memset( &epg_srv, 0, sizeof(epg_srv));
        snprintf( epg_srv, sizeof(epg_srv)-1, t );
        return;
}

/* static */
void
remove_tsid( int tx )
{
        int i;
        struct tsid_s *t0, *t1;


        if (tsidx < 1) return;
        if (tx < 0) return;
        if (tx >= TSID_MAX) return;

        while (EBUSY == pthread_mutex_trylock( &tsid_mutex ))
                nanosleep( &atomic_sleep, NULL );

/* move everything up one list item */
        for (i = tx; i < tsidx; i++) {
                t0 = &tsids[i];
                t1 = &tsids[i+1];
                memcpy(t0, t1, sizeof(struct tsid_s));
        }
        tsidx--;

        pthread_mutex_unlock( &tsid_mutex );
}

/* sort by ptc then pn */
/* static */
void
sort_tsids( void )
{
        int i, j, x;
        struct tsid_s t, *t0, *t1;

/* no sort needed */
        if (tsidx < 2) return;

/* move everything up one list item */
        for (i = 0; i < (tsidx-1); i++) {
                for (j = i+1; j < tsidx; j++) {
                        x = 0;
                        t0 = tsids + i;
                        t1 = tsids + j;
                        if (t0->ptc > t1->ptc)
                                x = ~0;
                        if (t0->ptc == t1->ptc)
                                if (t0->pn > t1->pn)
                                        x = ~0;
                        if (0 != x) {
                                memcpy(&t, t0, sizeof(struct tsid_s));
                                memcpy(t0, t1, sizeof(struct tsid_s));
                                memcpy(t1, &t, sizeof(struct tsid_s));
                        }
                }
        }
}

/* NOTE: Transport Stream IDs shouldn't change much for broadcast streams,
    but on cable they can change often. This list will have wrong data
    if the cable provider changes the channel list + TSIDs and will need
    need to be deleted/re-generated, but otherwise it should be persistent.
*/


/* find stations calls this if the tsid list is different after load tsid */
/* static */
void
save_tsids( void )
{
        int i;
        FILE *o;
        char n[256];
        struct tsid_s *t;

        while (EBUSY == pthread_mutex_trylock( &tsid_mutex ))
                nanosleep( &atomic_sleep, NULL );

        sort_tsids();

        snprintf( n, sizeof(n), "%satscap%d.tsid.%s",
                    cfg_path, arg_devnum, (0 == arg_cable)?"vsb":"qam");

        o = fopen(n, "w");
        if (NULL == o) {
            dvrlog( LOG_INFO, "%s can't save %s %s", n, strerror(errno));
        }

        fprintf(o, "# TSID:PTC:PN:CALL:SID\n");

        for (i=0; i < tsidx; i++) {
                t = &tsids[ i ];
                fprintf(o, "0x%04X:%03d:%02d:%s:%s\n",
                            t->tsid, t->ptc, t->pn, t->call, t->sid);
        }

        fflush(o);
        fclose(o);
        pthread_mutex_unlock( &tsid_mutex );
}

/* atscap?.tsid.* format: 0xTSID:PTC:PN:CALL:SID

    This is a list of detected TSIDs created by -S option. The purpose of
     keeping a separate TSID list is so you can run -S option multiple times
     and not have to fix the .conf file CALL and SID fields each time.

    -S overwrites the .conf file so storing TSIDs there is currently NOT OK.
*/
/* static */
void
load_tsids( void )
{
        int i, j;                       /* line count, sscanf return */
        FILE *f;                        /* input file descriptor */
        char n[256];                    /* input file name */
        char s[256];                    /* input string */
        char *r;                        /* pointer to input string */
        char *p[5];                     /* pointers to parts of string */
        struct tsid_s *t;               /* pointer to tsid list */

        memset( tsids, 0, sizeof( tsids ) );
        memset( n, 0, sizeof(n) );
        memset( s, 0, sizeof(s));

        snprintf( n, sizeof(n)-1, "%satscap%d.tsid.%s",
                    cfg_path, arg_devnum, (0 == arg_cable) ? "vsb":"qam" );

        f = fopen( n, "r");
        if (NULL == f) {
                dvrlog( LOG_INFO, "TSID file %s not opened", n);
                return;
        }

        while (EBUSY == pthread_mutex_trylock( &tsid_mutex ))
                nanosleep( &atomic_sleep, NULL );

        r = s;

/* i is line counter */
        i = 0;
        tsidx = 0;
        while (1) {
                if (tsidx >= TSID_MAX) {
                    dvrlog( LOG_INFO, "%s too many TSIDs (%d)", tsidx);
                    break;
                }

                memset( s, 0, sizeof(s));

/* point to new entry */
                t = &tsids[ tsidx ];

/* erase the possibly bogus previous loop result */
                memset( t, 0, sizeof(struct tsid_s));

                r = fgets( s, sizeof(s), f);
/* EOF check */
                if (NULL == r) break;
                if (r != s) break;
                i++;

/* EOL check */
                r = strchr( s, '#');
                if (NULL != r) *r = 0;

                r = strchr( s, '\n');
                if (NULL != r) *r = 0;

                r = strchr( s, '\r');
                if (NULL != r) *r = 0;

/* skip line if comment/nl/cr removal left a blank line */
                if (0 == *s) continue;

/* skip line if no delimiters on the line? */
                if (NULL == strchr(s, ':')) continue;

/* set p to a list of pointers */
                build_args( p, 5, s, ':', WHO );

/* testing various incorrect values will make it skip the line */

/* TSID base16, 0 to 65535 */
                if (NULL == p[0]) continue;
                j = sscanf( p[0], "%hX", &t->tsid );

/* should have scanned one item */
                if (1 != j) continue;

/* invalid TSID values */
                if (0 == t->tsid) continue;
                if (0xFFFF == t->tsid) continue;

/* PTC base10, 0 to 127 */
                if (NULL == p[1]) continue;
                t->ptc = 0xFF & atoi( p[1] );
                if (0 == t->ptc) continue;

/* init channels should have set ptc_max already */
                if (t->ptc > ptc_max) continue;

/* Pgm# base10, 0 to 65535 */
                if (NULL == p[2]) continue;
                t->pn = 0xFFFF & atoi( p[2] );
                if (0 == t->pn) continue;

/* call text, NUL term */
                if (NULL == p[3]) continue;
                astrncpy( t->call, p[3], 8 );
                if (0 == *t->call ) continue;

/* sid text, NUL term */
                if (NULL == p[4]) continue;
                astrncpy( t->sid,  p[4], 4 );
                if (0 == *t->sid ) continue;

                advrlog( LOG_INFO, "tsids[%2d] Ch.Pn %2d.%d TSID %04X CALL %7s SID %-3s",
                        tsidx, t->ptc, t->pn, t->tsid, t->call, t->sid );
                tsidx++;
        }
        fclose(f);
        advrlog( LOG_INFO, "%s %s has %d TSIDs", WHO, n, tsidx);

        pthread_mutex_unlock( &tsid_mutex );

/* sort the list and save it */
        save_tsids();
}

/* pick which ptc list to use from 6 available */
/* static */
void
init_channels( void )
{
        int i;
        struct sig_s *s;

/* force to 0 ATSC 8VSB in case any checks below fail */
/* use 8VSB mode */
        arg_cable = 0;

/* FUTURE FIXME: by 2009 this will be 52 */
        ptc_max = 70;

        aos_delay = AOS_VSB_DELAY;

/* use QAM256 mode */
        if (arg_frtable > 0) {
                arg_cable = ~0;
                ptc_max = 127;
                aos_delay = AOS_QAM_DELAY;
        }

        load_tsids();

        switch( arg_frtable ) {

        case 0:
                frequencies = ptc_atsc_center; /* was ptc_broadcast */
                ptc_max = ATSC_MAX;
                break;

        case 1:
                frequencies = ptc_cable_eia542_hrc;
                break;

        case 2:
                frequencies = ptc_cable_eia542_irc;
                break;

        case 3:
                frequencies = ptc_cable_hrc;
                break;

        case 4:
                frequencies = ptc_cable_irc;
                break;

        case 5:
                frequencies = ptc_cable_std;
                break;

        default:
                aprintf(stderr,
                        HOM CCE BR "bad frequency table selection %d\n" BN,
                        arg_frtable );

                console_exit(0);
                break;
        }

        advrlog(LOG_INFO, "%s frtbl %d ptc max %d",
                WHO, arg_frtable, ptc_max);


/* populate the frequency table, add some bogus callsigns and station ids */
        for (i = 0; i < ptc_max; i++) {
                s = &ptc[i].sig;
                s->freq = frequencies[i];  /* load the frequency */

/* TESTME: tuner 62.5kc granularity obviates this? Need a supertuner? */
                if (0 == arg_frtable) s->freq -= 28615;

                s->ptc = i;
                s->chan = i;     /* breadcrumbs to find scan_list index */
                s->vc = s->va = -1; /* full cap is startup default */
                s->pgto = 0;    /* clear autoguide timeout */
                s->pgmt = 0;    /* and program guide modify time */
                s->psip = 0;    /* clear psip data bits */
                s->sig_col = &bc[0][0];
                snprintf( s->sid, 4, "%03d", s->ptc);
                snprintf( s->call, 5, "%s%03d", (0 == arg_cable)?"T":"C", i);
                memset( &s->pkt, 0, sizeof(struct pkt_s));
        }
}

/* static */
void
parse_freqlist( char * t )
{
        int n;

        if (NULL == t) return;
        if (0 == *t) return;

        dvrlog( LOG_INFO, "%s (%s)", WHO, t );

        n = 0;
        n = atoi(t);
        if (n >= 6) return;
        arg_frtable = n;
        if (n > 0) arg_cable = ~0;
        init_channels();
}


/* show clock tests config file every second, calls this if cfg mod time chg */
/* static */
void
load_config ( char *caller )
{
    int i;
    FILE *o;            /* points to fopen */
    char *c, *t;        /* points to tt after good fgets */
    char fn[256];       /* config path and file as one string */
    char tt[256];       /* config file text input line */
    char b;
    int pch;

/* creating config, no need to load it */
    if ( 0 != arg_scan ) return;

    pch = cap_chan;

    advrlog(LOG_INFO, "%s start from %s\n", WHO, caller );

    get_time();
    cap_zto = 0;

    nanosleep(&msg_sleep, NULL); /* 1/4s sleep for file update after mt chg */


    timer_lock = ~0;

    timer_offset = 0;

    /* if ( D_TIMERS == display_type ) */
        aprintf( stderr, "\033[5;1H" CCE );

    get_time();
    for ( i = 0; i < scan_idx; i++ ) {
        struct sig_s *s;
        s = &ptc[ scan_list[i] ].sig;
        s->pgto = 0; /* reset autoguide timeout */
        s->pgmt = 0; /* reset program guide modtime */
    }

/* touch the EPG grid */
    snprintf( fn, sizeof(fn)-1, "%s%s/pg/grid%d.html",
                 out_path, ram_path, arg_devnum );
    o = fopen( fn, "a" );
    if (NULL != o) fclose(o);

    snprintf( fn, sizeof(fn)-1, "%s%s", cfg_path, cfg_name );

    o = fopen( fn, "r" );
    if ( NULL == o ) {
        dvrlog( LOG_INFO, "load config failed %s", fn);
        /* alert user there still was a problem with the config file */
        cf_no = ~0;
        fprintf( stderr, CLS "load config %s failed\n", fn );
        console_exit(0);

/* fatal, enter warn/test mode, if not doing console exit instead 
        test_mode = ~0;
        timer_lock = 0;
        return;
*/
    }

/* clear the timer list */
    reset_timers();

/* clear the search list */
    memset( search_list, 0, sizeof(search_list) );
    search_idx = 0;

    memset( scan_list, 0, sizeof(scan_list) );

/* add or remove channels loses the current index */
    scan_pos = 0;
    scan_idx = 0;

    c = tt;
    while (NULL != c) {
        memset(tt, 0, sizeof(tt));
        c = fgets( tt, 128, o ); /* c gets NULL at EOF */
        if (NULL == c) {
            advrlog( LOG_INFO, "%s EOF %s", WHO, fn);
            break;
        }

/* change NL terminate to NUL term */
        t = strchr( tt, '\n');
        if (NULL != t) *t = 0;

/* change comment to NUL term */
        t = strchr( tt, '#');
        if (NULL != t) *t = 0;

/* blank line? */
        if (0 == *tt) continue;

        advrlog( LOG_INFO, "%s:%d [%s]", WHO, WHERE, tt);

        t = tt;
        b = *t;
        t++;

        switch(b) {

/* there is now an order requirement, C lines before W or V */

/* automatic search event */
        case 'A':
            parse_search_event( t );
            break;

/* broadcast or cable channel */
        case 'C':
            parse_channel( t );
            break;

/* last set -F option */
        case 'F':
            parse_freqlist( t );
            break;

/* user interface format string */
        case 'I':
            parse_webcfg( t );
            break;

/* epg server */
        case 'S':
            parse_epgsrv( t );
            break;

/* volatile timer */
        case 'V':
            parse_volatile_timer( t );
            break;

/* new mnemonic for Weekday instead of T for Timer */
/* weekday timer */
        case 'W':
            parse_weekday_timer( t );
            break;

/* ATSC system time channel select */
        case 'Z':
            parse_ztime( t );
            break;

/* ignore the other lines */
        default:
            break;
        }           
    }

//    advrlog( LOG_INFO, "%s %s%s has: %2d sc, %2d ti, %2d si",
//              WHO, cfg_path, cfg_name, scan_idx,
//              timer_idx - search_idx, search_idx);

#if 0
// stops at parse before saving
    fprintf( stdout, "\n\n%s%s has: %2d channels %2d timers %2d searches\n\n",
                cfg_path, cfg_name, scan_idx,
                timer_idx - search_idx, search_idx);

    console_reset();
    console_reset();
    exit(0);
#endif


/* fixup weekday and dst issues, toss overlaps, and sort */
    validate_config();

    fclose( o );

    sort_searchlist();

    /* DEBUG: log the list of event names to search */
    if ( search_idx > 0 ) {
        advrlog( LOG_INFO, "Search event list:");
        for ( i=0; i < search_idx; i++ ) {
            advrlog( LOG_INFO, "  %s", search_list[ i ].name);
        }
    }

/* update modtime on config file and save cleaned out events */
    save_config( WHO );

    get_time();

/* CHANGE: trigger guide test in 5s */
    utstpg = utsnow + (300 * (1 + arg_devnum));

    display_type = D_TIMERS; /* 0 */
    refresh.timers = 1;
    timer_lock = 0; /* unlock so show timers works */

    show_headers(1);

/* put it back so nothing gets confused */
    cap_chan = pgm.chan = pch;
#if 0
/* TESTME: is this why guide for KUHT showing up on KHCW? */
    load_guide( pch, WHO );
#endif
    advrlog( LOG_INFO, "%s stop\n", WHO);
}

/* show vc selection calls this to count filtered events on each program */
/* static */
int
count_pg_pgm( int pn )
{
        int i, j;
/* i steps thru the list, j only increments when entry moved down */
/* j becomes new pgm.idx, thus removing all but program# matches */

        j = 0;
        for (i = 0; i < pgm.idx; i++)
                if (pn == epg[ pg[ i ] ].pn)
                        j++;
        return j;
}


/* similar to load epg, but in reverse */
/* static */
void
save_epg ( int ch, struct event_s *e, struct pgm_s *p, short *pgx,
                char *caller )
{
        FILE *f;                        /* fd for output */
        char n[256];                    /* name for output */
        unsigned short m1, i, j, k;
        struct event_s *e1;
        size_t w;

/* cable has to use static EPG copy. test epgs could fetch new copy? */
        if (0 != arg_cable) return;
        if (0 != arg_scan) return;

        advrlog( LOG_INFO, "%s %s %s", WHO, caller, n );

        memset( p, 0, sizeof(struct pgm_s) );   /* clear filters */
        memset( pgx, 0xFF, sizeof(pg) );        /* clear indices */
        p->chan = ch;                           /* save epg chan */

/* build unfiltered copy (blanks removed, pg1 indices may give shorter list) */
        build_pg_epg( e, p, pgx, WHO );

/* minus 1 */   
        m1 = 0;
        m1--;

        j = 0xFFFF & p->idx;            /* hmm, want full list */

        if (j >= PGZ) return;           /* boundary check */
        if (j == 0) return;             /* nothing to do */

        snprintf( n, sizeof(n)-1, "%s%spg/%02d.epg", out_path, ram_path, ch);

        f = fopen( n, "w");
        if (NULL == f) {
                dvrlog( LOG_INFO, "%s writing %s error %s",
                        WHO, n, strerror(errno) );
                return;
        }

/* write whole pgx structure, j items */
        w = fwrite( pgx, sizeof( short ), j, f);
        if (j != w) {
                dvrlog( LOG_INFO, "%s error %d wr idx %s", WHO, w, n);
                fclose( f );
                return;
        }

/* term list with short -1 */
        w = fwrite( &m1, sizeof( short ), 1, f);
        if (1 != w) {
                dvrlog( LOG_INFO, "%s -1 wr %s is %d", WHO, n, w);
                fclose( f );
                return;
        }

        for (i = 0; i < j; i++) {

                k = pgx[ i ];
                if (0xFFFF == k) break;

/* one event */
                e1 = &e[ k ];

                w = fwrite( e1, sizeof(struct event_s), 1, f );

                if (1 != w) {
                        dvrlog( LOG_INFO, "%s error %d wr %s event %d",
                                WHO, w, n, i);
                        break;                          /* EOF */
                }
        }

        fclose( f );

/* update callers mtime */
        p->mtime = utsnow;
}

/* similar to load vct, but in reverse:
    ncv is number of channls in VCT
    ncp is number of channels in PAT
    v is vc structure
    p is pa structure

   If the volume is full, there will be a lot of errors in log. The log
   will not be written, if not using -E option for logging to tmpfs.
*/
/* static */
void
save_vct( int ch, int *ncv, struct vc_s *v, int *ncp, struct pa_s *p )
{
        FILE *f;                        /* fd for output */
        char n[256];                    /* name for output */
        size_t w;

        if (0 != arg_scan) return;

        if (ch > ptc_max) {             /* boundary check */
                dvrlog( LOG_INFO, "%s %d >= ptc max %d",
                        WHO, ch, ptc_max);
                return;
        }

        snprintf( n, sizeof(n)-1, "%s%spg/%02d.vc", out_path, ram_path, ch);
        advrlog( LOG_INFO, "%s %s", WHO, n );

        f = fopen( n, "w");
        if (NULL == f) {
                dvrlog( LOG_INFO, "%s writing %s error %s",
                        WHO, n, strerror(errno) );
                return;
        }

/* write vct_ncs and pat_ncs */
        w = fwrite( ncv, sizeof( int ), 1, f);
        if (1 != w) {
                dvrlog( LOG_INFO,"%s error %d wr vctncs %s",WHO, w, n );
                fclose( f );
                return;
        }
        w = fwrite( ncp, sizeof( int ), 1, f);
        if (1 != w) {
                dvrlog( LOG_INFO,"%s error %d wr patncs %s",WHO, w, n );
                fclose( f );
                return;
        }

/* write vc and pa */
        w = fwrite( v, sizeof( vc ), 1, f); /* FIXME: vc needs abstraction */
        if (1 != w) {
                dvrlog( LOG_INFO, "%s error %d wr vc %s",WHO,w,n );
                fclose( f );
                return;
        }
        w = fwrite( p, sizeof( pa ), 1, f); /* FIXME: pa needs abstraction */
        if (1 != w) {
                dvrlog( LOG_INFO, "%s error %d wr pa %s",WHO,w,n );
        }

        fclose( f );
}


/* test for existing capture file to add to epg html in dump epg
        d is destination name tried,
        base is file base name to use for attempts,
        n is epg# used for program # and start time lookup
        return 0 if found, nz if not found
*/
/* static */
int
test_ts_file( char *d, char *base, struct event_s *e1, struct stat64 *fs )
{
        int ok, mn, dy, h, m, p;
        struct tm tne;
        time_t tany;

/* check is name-mmdd-hhmm.pn.ts format */
        tany = (time_t)e1->st;
        p = e1->pn;

        localtime_r( &tany, &tne);
        mn = tne.tm_mon+1;
        dy = tne.tm_mday;
        h = tne.tm_hour;
        m = tne.tm_min;

/* base is truncated 2 word version of eventname */

/* program cap with timestamp, could be aged or current cap */
        snprintf( d, 64, "%s%s-%02d%02d-%02d%02d.%d.ts",
                    out_path, base, mn, dy, h, m, p );
        ok = stat64( d, fs ); /* big files need stat64 */
        if (0 == ok) {
            advrlog( LOG_INFO, "html stat64 %s = %d", d, ok);
            return 0;
        }

/* leave these out for now. requires further thought on need or use */
#if 0
/* TODO: program cap. no provision to add event without @ */
        snprintf( d, 64, "%s%s.%d.ts", out_path, base, p );
        ok = stat64( d, fs ); /* big files need stat64 */
        if (0 == ok) {
            advrlog( LOG_INFO, "html stat64 %s = %d", d, ok);
            return 0;
        }

/* TODO: full cap. no provision to add event as full cap from html */
        snprintf( d, 64, "%s%s.ts", out_path, base );
        ok = stat64( d, fs ); /* big files need stat64 */
        if (0 == ok) {
            advrlog( LOG_INFO, "html stat64 %s = %d", d, ok);
            return 0;
        }
#endif

        return -1;
}

#ifdef USE_PNG
/* static */
void
write_png_error( png_structp png_ptr, png_const_charp msg)
{
        struct img_s *img;
        dvrlog( LOG_INFO, "%s", msg);
        img = png_get_error_ptr( png_ptr );
        if (NULL == img) {
                dvrlog( LOG_INFO, "write_png jmpbuf not recoverable!");
                console_exit(0);
        }
        longjmp( img->jmpbuf, 1 );
}

/* create png file n from signal image data created by build sig png */
/* compression and a bunch of other things are set to defaults */
/* static */
void
write_png( struct img_s *img, char *n )
{
        int ok;
        FILE *fp;
        png_structp png_ptr;
        png_infop info_ptr;
        png_bytepp row_pointers;

        ok = ~0;                /* nz is not ok */

        fp = NULL;

/* allocates memory */
        png_ptr = png_create_write_struct(
                    PNG_LIBPNG_VER_STRING,
                    (png_voidp) img, write_png_error, NULL );

/* all these gotos are to destroy libpng allocated memory */
        if (NULL == png_ptr) goto write_png_exit;

/* also allocates memory */
        info_ptr = png_create_info_struct( png_ptr );
        if (NULL == info_ptr) goto write_png_exit;
        if ( setjmp( img->jmpbuf ) ) goto write_png_exit;

/* open channel.png file for writing */
        fp = fopen( n, "wb");
        if (NULL == fp) {
                dvrlog( LOG_INFO, "can't open %s for writing", n);
                return;
        }

/* tell png what file to write */
        png_init_io( png_ptr, fp );

/* compression and filtering settings */
/* TESTME: Z_BEST should be less storage for tmpfs but eats more CPU.
   Remote users will find the large sig.png file size very annoying,
   probably even with compression, until I create an 8 entry palette for it.

   NOTE: most href imgs are not compressed but are also fairly small.
 */
        png_set_compression_level( png_ptr, SIG_PNG_COMP );
        png_set_filter( png_ptr, 0, PNG_FILTER_NONE );

/* image header data */
        png_set_IHDR(
                png_ptr, info_ptr,
                img->width, img->height, img->depth,
                img->colortype, img->interlace,
                PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
        
/* RGB image pixel data, as a list of row pointers, 0 to height-1 */
        png_set_packing( png_ptr );
        row_pointers = (png_bytepp) &img->row_pointers;
        png_set_rows( png_ptr, info_ptr, row_pointers );
        png_write_png( png_ptr, info_ptr, img->transform, NULL);

/* all done */
        ok = 0;

write_png_exit:

/* No error? */
        if (0 == ok) {
                advrlog( LOG_INFO, "wrote %s", n);
        } else {

/* Show error */
                dvrlog( LOG_INFO, "libpng error %s", n);
        }

/* Close file? */
        if (NULL != fp) {
                fflush( fp );
                fclose( fp );
        }

/* Destroy pointer(s) and free memory. */
        if (NULL != png_ptr) {
                if (NULL != info_ptr) {
/* Destroy both? */
                        png_destroy_write_struct( &png_ptr, &info_ptr );
                } else {
/* Destroy only png_ptr. */
                        png_destroy_write_struct( &png_ptr, (png_infopp) NULL);
                }
        }
}

/* Build RGB data from s->smp strength sample data */
/* raster: 50 rows (%/2) of 60 RGB bytes (seconds) in 3 byte packing,
   signal strength is y dimension, x is time, slower during cap
   TODO: use RGBA and do transform to set Alpha to tranparency.
   This should make it look a little better on a white background.
*/
/* static */
void
build_sig_png ( int ch, int a, char *caller )
{
        unsigned char p[ SIG_PNG_H ][ SIG_PNG_W * SIG_PNG_B ];
        int i, j, k, m, o, r, t;
        unsigned int c;                 /* color */
        char n[ 256 ];
        struct img_s spng;
        struct sig_s *s;
        struct timespec png_start = { 0, 0 };
        struct timespec png_stop =  { 0, 0 };
        struct timespec png_diff =  { 0, 0 };
        struct timespec png_sleep = { 0, 1000000 }; /* 1 ms */
        int png_bench = 0;

        while ( EBUSY == pthread_mutex_trylock( &png_mutex ) )
            nanosleep( &png_sleep, NULL );

        if (0 != png_bench) clock_gettime( clock_method, &png_start );
        
        s = &ptc[ ch ].sig;
        advrlog( LOG_INFO, "%s %s %d", WHO, caller, s->chan);
        
        spng.width = SIG_PNG_W;
        spng.height = SIG_PNG_H;
        spng.transform = PNG_TRANSFORM_IDENTITY;
//      spng.transform |= PNG_TRANSFORM_INVERT_ALPHA;
        spng.colortype = PNG_COLOR_TYPE_RGB_ALPHA;
        spng.interlace = PNG_INTERLACE_NONE;
        spng.depth = 8;

/* point to image data for each row */
        for (i = 0; i < SIG_PNG_H; i++)
            spng.row_pointers[i] = &p[i][0];

/* needs a faint background to delineate upper boundary */
        memset( p, 0x10, sizeof(p) );

/* greyscale for now, do colors later */
        for (i = 0; i < SIG_PNG_W; i++ ) {
            k = s->smx + i;
            if (k > SIG_PNG_W) k -= SIG_PNG_W;

/* colorize the sample according to signal strength */
            t = s->smp[k];
            c = 0;
            if (t >  0) c = 0x80808000;         /* gray */
            if (t > 12) c = 0x0000FF00;         /* blue */
            if (t > 25) c = 0xFF00FF00;         /* magenta */
            if (t > 38) c = 0xFF000000;         /* red */
            if (t > 51) c = 0xFFFF0000;         /* yellow */
            if (t > 64) c = 0x00FF0000;         /* green */
            if (t > 77) c = 0x00FFFF00;         /* cyan */
            if (t > 90) c = 0xFFFFFF00;         /* white */

            c |= 0xff & a;      /* alpha blend opacity, higher is more opaque */

/* set the R pixel offset */
            o = i * SIG_PNG_B;

/* normalize strength/100 to sigbar pixels y / height */
            m = s->smp[ k ];
            if (m < 0) m = 0;
            m *= SIG_PNG_H;
            m /= 100;
            if (m >= SIG_PNG_H) m = SIG_PNG_H - 1;

/* NOTE: origin is top left so have to do column pixels backwards */
            for (j = 0; j < m; j++) {
                    r = (SIG_PNG_H - 1) - j;
                    if (r >= 0) {
                        p[r][ o + 0 ] = 0xFF & (c >> 24); /* R */
                        p[r][ o + 1 ] = 0xFF & (c >> 16); /* G */
                        p[r][ o + 2 ] = 0xFF & (c >> 8);  /* B */
                        p[r][ o + 3 ] = 0xFF & c;         /* A */
                    }
            }
        }

/* not until graph is much larger. is too small even for tick marks?
        c = 0x808080;
        rgb_drawscale( &p, c, 0, 0, img->width-1, img->height-1);
*/

/* RGBA data is created, now write it as png file for this channel */
        snprintf( n, sizeof(n), "%s%spg/%d-%02d.png",
                    out_path, ram_path, arg_devnum, s->chan);

        write_png( &spng, n );
        if (0 != png_bench) {
                clock_gettime( clock_method, &png_stop );
                time_diff( &png_diff, &png_start, &png_stop);

                dvrlog( LOG_INFO, "%s %s %d.%09ds", WHO, n,
                        (int) png_diff.tv_sec, (int) png_diff.tv_nsec );
        }

        pthread_mutex_unlock( &png_mutex );
}       
#endif

/* form input text format */
#define FIT_FMT "<input type=\042%s\042 name=\042%s\042 size=\042%d\042 maxlength=\042%d\042>\n"
/* static */
void
build_epg_form( char *d, int z, int ch )
{
        char *g, *r, *n;
        struct sig_s *s;

        s = &ptc[ ch ].sig;

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);
        r = "epgtile";
        g = "large";
        n = "New Timer";

/* only for big tiles and web config enabled (more button) */
        if (1 != use_css) return;
        if (0 == web_config) return;

        asnprintf(d, z, "<form name=\042%s\042"
                        " method=\042%s\042"
                        " enctype=\042%s\042>\n",
                "epgform", "GET", "application/x-www-form-urlencoded");

        asnprintf(d, z, "<div class=\042%s %s%d\042>\n", r, "cyan", 1);
        asnprintf(d, z, "<dl class=\042dl_%s\042>\n", g );

        asnprintf(d, z, "<dt class=\042dt_%s %s\042>\n", g, "epgtc cyan");
        asnprintf(d, z, "<input type=\042%s\042 value=\042%s\042>\n",
                        "submit", "Add");

/* is s->pn ever zero? won't display anything if so */
        if (s->pn > 0) {
                asnprintf(d, z, "%s.%d\n", s->sid, s->pn);
        } else {
                asnprintf(d, z, "Full Cap\n");
        }
        asnprintf(d, z, "<br />%s\n", n);

        asnprintf(d, z, "</dt>\n");
        asnprintf(d, z, "<dd class=\042%s\042>\n", "dd_large epgvsb cyan1");

/* set the cgi value and channel in a hidden type */
        asnprintf(d, z, "<input type=\042%s\042 name=\042%s\042"
                        " value=\042%d\042>\n",
                        "hidden", "t", ch);

/* name, start time and minutes run time */
        asnprintf(d, z, FIT_FMT "Name<br />", "text", "n", 17, 17);
        asnprintf(d, z, FIT_FMT "Time hh:mm<br />", "text","s", 5, 5);
        asnprintf(d, z, FIT_FMT "Len hh:mm<br />\n", "text", "m", 5, 5);

/* check boxes for days */
        asnprintf(d, z, FIT_FMT "*Weekdays<br />*OR*<br />\n", "text", "w", 7, 7);
        asnprintf(d, z, FIT_FMT "*YYYYMMDD<br />\n", "text", "d", 8, 8);

        asnprintf(d, z, "Name@ = +mmdd<br />\n");
        asnprintf(d, z, "Name$ = +wday<br />\n");
        asnprintf(d, z, "1111111 = SMTWTFS<br />\n");
//      asnprintf(d, z, " * optional<br />\n");
        asnprintf(d, z, "</dd>\n");
        asnprintf(d, z, "</dl>\n");
        asnprintf(d, z, "</div>\n");
        asnprintf(d, z, "</form>\n\n");
}

/* build epg legend as string */
/* static */
void
build_epg_legend ( char *d, int z )
{
        int i;
        char *s[12] = {
         "epgon24", "scanon", "spam24", "unspam24", "searchadd", "searchdel",
         "timeradd", "timerdel", "zap24", "timerstop", "log24", "edit24"
        };

        char *t[12] = {
            "EPG", "Sig", "Junk+", "Junk-", "Find+", "Find-",
            "Add", "Del", "Zap", "Stop", "Log", "Edit"
        };

        char *c0, *c1;                  /* center legend color list */

        c0 = c1 = "";

/* nothing to do if web legend disabled */
        if (0 == web_legend) return;

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);

/* button legend */     

#if 0
        asnprintf(d, z, "<div class=\042%s\042>%s%s%s</div>\n",
                                "epgbl2 magenta1", c1, " Past", c0 );

        asnprintf(d, z, "<div class=\042%s\042>%s%s%s</div>\n",
                                "epgbl2 black1", c1, " Junk", c0 );
#endif

        asnprintf(d, z, "<div class=\042%s\042>%s%s%s</div>\n",
                                "epgbl2 white0", c1, " Now", c0 );

        asnprintf(d, z, "<div class=\042%s\042>%s%s%s</div>\n",
                                "epgbl2 blue1", c1, " Movie", c0 );

        asnprintf(d, z, "<div class=\042%s\042>%s%s%s</div>\n",
                                "epgbl2 green1", c1, " Timer", c0 );

#if 0
/* if it's a search, it should already have a timer so is redundant? */
        asnprintf(d, z, "<div class=\042%s\042>%s%s%s</div>\n",
                                "epgbl2 cyan1", c1, " Search", c0 );
#endif

        asnprintf(d, z, "<div class=\042%s\042>%s%s%s</div>\n",
                                "epgbl2 yellow1", c1, " Capture", c0 );
        


        for (i = 0; i < 12; i++) {
                asnprintf(d, z,  "<div class=\042%s\042>", "epgbl1");
                asnprintf(d, z,  "<img class=\042%s\042 "
                                    "alt=\042%s\042 "
                                    "src=\042img/%s.png\042 />",
                                        "epgbti", t[i], s[i]);
                asnprintf(d, z, " %s", t[i]);
                asnprintf(d, z, "</div>\n");
        }
}


/* event status bits */

#define E_SPAM   1
#define E_AGED   2
#define E_NOW    4
#define E_MOVIE  8
#define E_TIME  16
#define E_FIND  32
#define E_IMG   64
#define E_LOG  128
#define E_TS   256
#define E_MTX  512
#define E_TSX 1024
#define E_TSC 2048
/* check for following:
    spam        is on spamlist
    aged        is aged event
    now         is current event
    movie       is mpaa rated
    timer       is on timer list
    find        has match to timer list
    img         has event image
    log         has capture log
    ts          has capture file
    mtx         has modtime expired 3s+
    tsx         has sequence index
    tsc         has been edited
*/

/* static */
int
test_event_status ( struct event_s *e )
{
        struct stat64 fs;
        int ok, es;             /* event status bits */
        char s[64], t[64];      /* truncated name */
        int d, c;               /* daybits and channel */

        es = 0;

/* Event check */
        if ((e->st+e->ls) < utsnow)                             es |= E_AGED;
        if ( (utsnow >= e->st) && (utsnow < (e->st + e->ls)) )  es |= E_NOW;
        if (0 != e->movie)                                      es |= E_MOVIE;

/* List check */
        if (-1 != find_timer_epg(e))                            es |= E_TIME;

/* sunday is bit 6 */
        d = 1 << (6 - e->stm.tm_wday);
        c = e->chan;

        if (-1 != find_search_event( e->tname, d, c, WHO ))
                                                                es |= E_FIND;
/* FIXME: EPG loop caller needs to check ALL events, not the pg index. */
//      if ( (-1 != test_spam_name(e->tname))
        if ( (-1 != test_spam_event( e ))
/* Junk filter ON and using build_pg_epg pg index to epg makes this a nop. */
          && (0 == (es & E_TIME)) )                             es |= E_SPAM;

/* base file name for .ts .html .tsx .tsc */
        snprintf(s, sizeof(s), "%s%spg/img/%s.png",
                    out_path, ram_path, e->tname);
        ok = stat64(s, &fs);
        if (0 == ok) advrlog( LOG_INFO, "%s %s", WHO, s);
        if (0 == ok)                                            es |= E_IMG;

        snprintf(s, sizeof(s), "%s%s-%02d%02d-%02d%02d.%d",
                out_path, e->tname,
                e->stm.tm_mon+1, e->stm.tm_mday,
                e->stm.tm_hour, e->stm.tm_min, e->pn);


        snprintf(t, sizeof(t), "%s.ts", s);
        ok = stat64( t, &fs );
        if (0 == ok)                                            es |= E_TS;

/* not used? */
        if (0 != (es & E_TS)) {
                if (fs.st_mtime < (utsnow - 2))                 es |= E_MTX;
        }

        snprintf(t, sizeof(t), "%s.html", s);
        ok = stat64( t, &fs );
        if (0 == ok)                                            es |= E_LOG;

        snprintf(t, sizeof(t), "%s.tsx", s);
        ok = stat64( t, &fs );
        if (0 == ok)                                            es |= E_TSX;

        snprintf(t, sizeof(t), "%s.tsc", s);
        ok = stat64( t, &fs );
        if (0 == ok)
            if (0 != fs.st_size)                                es |= E_TSC;

/* File check. Stays on list if no auto-EPG update throws out event. */
/* Check for .ts file, .html log file, .png img file, .tsx file, .tsc file */
        

        return es;
}

/* [timer entry form], station png, status text and sigchart */
/* static */
void
build_epg_top ( FILE *wf, char *d, int z, struct pgm_s *p )
{
        struct stat fs;
        struct sig_s *s;
        char *si;
        int i, j, ch;
        int sr;
        char *ef; /* epg class for font size */
        char n[256];            /* stationid.png */
        char ni[16];            /* signalchart.png */
        char sa[64];            /* signal a href */

        char *c[2];             /* inactive and active classes for config */
        c[0] = "green";
        c[1] = "yellow";

        i = j = 0;
/* text mode sizing is default */
        ef = "";
        if (J_LARGE == use_css) ef = "large";
        if (J_SMALL == use_css) ef = "small";
        if (J_TINY == use_css) ef = "tiny";
        
        ch = p->chan;

        s = &ptc[ ch ].sig;

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);

//      asnprintf(d, z, "<br class=\042%s\042 />\n", "br_epgdiv");
        asnprintf(d, z, "<div class=\042%s_%s\042>\n", "epgtop", ef);

/* manual timer entry form, only shows up if (more) button enabled. */
        build_epg_form(d, z, ch);

/* station image (optional) */
        if (0 != s->sid[0])
        {
                snprintf(n, sizeof(n), "%s%s/pg/img/%s.png",
                            out_path, ram_path, s->sid);
                i = stat(n, &fs);
/* TODO: if regular file ... */
                if (0 == i)
                {
                        asnprintf(d, z, "<div class=\042%s\042>\n", "epgsid");
                        asnprintf(d, z, "<img alt=\042%s\042 "
                                              "src=\042/pg/img/%s.png\042 />\n",
                                    s->call, s->sid);
                        asnprintf(d, z, "</div>\n");
                }
        }       
//      asnprintf(d, z, "<br />\n"); // too far down
        asnprintf(d, z, "<div class=\042%s\042>\n", "epgevs");

        asnprintf(d, z, "%d/%d Events %dh<br>\n%s %s %02d.%d",
                  p->idx, p->idt, s->mgt_hrs, s->call, s->sid, s->ptc, s->pn);

/********************************************************** current status */

        asnprintf(d, z, "<br />\n"); 


        asnprintf(d, z, "Status: ");

        si = "Idle";

        if (CAP_NONE != cap_now) {
                si = "Cap EPG";
                if (0 == arg_cable) si = "Cap Info";
                if (CAP_TIME == cap_now) si = "Cap Timer";
                if (CAP_USER == cap_now) si = "Cap Manual";
        }

        if (CAP_NONE == cap_now) {
                if (0 != scan_sig) si = "Scan";
                if (0 == scan_one) si = "Scan All";
        }

        if (in_file < 3) si = "Sleeping";

/* put up status and relative href for finding current capture EPG */
        asnprintf(d, z, "%s ", si);

/* not Idle gets href to active guide unless already here */
        if ( ('I' != *si) && (cap_chan != s->chan) ) {
                struct sig_s *s1;
                s1 = &ptc[ cap_chan ].sig;
                asnprintf(d, z,
                        "<a href=\042/pg/%02d.html\042> %s </a>",
                        cap_chan, s1->sid );
        }

#if 0
/* Idle shows last capture fail status for this channel, if not sig scan */
        if ('I' == *si) {
            if (0 == scan_sig) {
                if (s->cap_fail > 0) {
                    asnprintf(d, z,"%s FAIL", cap_fails[s->cap_fail] );
                }
            }
        }
#endif

#if USE_EPG_ATSC_STATS
/* show atsc psip status if it has been checked from any capture */
        asnprintf(d, z, "<br />\n");
        if (0 == s->psip) asnprintf(d, z, "No ATSC PSIP");
//      if (0 != s->psip) asnprintf(d, z, "ATSC:");
        if ( 1 & s->psip) asnprintf(d, z, " MGT");
        if ( 2 & s->psip) asnprintf(d, z, " VCT");
        if ( 4 & s->psip) asnprintf(d, z, " EIT");
        if ( 8 & s->psip) asnprintf(d, z, " ETT");
//      if (16 & s->psip) asnprintf(d, z, " RRT");
#endif

        asnprintf(d, z, "\n</div>\n");

/****************************************** signal strength chart */

        asnprintf(d, z, "<div class=\042%s\042>\n", "epgsg");

/* other buttons may be variable, put them to right of signal graph */
        snprintf( ni, sizeof(ni), "%d-%02d.png", arg_devnum, s->chan);

        *sa = 0;

/* signal scan toggle href only if not capturing */
        if (CAP_NONE == cap_now) {

/* not scanning or not same channel gets scan enable button */
            if ( (0 == scan_sig) || (s->chan != cap_chan) )
            {
                snprintf(sa, sizeof(sa), "\042%02d.html?v=%d\042",
                         s->chan, s->chan );
            } else {

/* is scanning and is same channel gets signal scan disable button */
/* TESTME: have to click it twice to turn it off if not same channel? */
                snprintf(sa, sizeof(sa), "\042%02d.html?v=%d\042",
                         s->chan, s->chan );
            }
        }

/* if href made, put the signal chart inside of it for scan toggle */
        if (0 != *sa) asnprintf(d, z, "<a class=\042%s\042 href=%s>",
                                "epgsga", sa);
        asnprintf(d, z, "<img class=\042%s\042 "
                        "alt=\042%s%d\042 "
                        "src=\042%s\042 "
                        "border=\042%d\042 />",
                 "epgsgi", "SIG", s->chan, ni, 1);

        if (0 != *sa) asnprintf(d, z, "</a>");
        asnprintf(d, z, "\n");


/************************************* load EPG href/img when not capturing */
/* cgi reload (info cap) href img if no capture */
        if (CAP_NONE == cap_now) {
                asnprintf(d, z, "<a href=\042/pg/%02d.html?g=%d\042>",
                        s->chan, s->chan);
                asnprintf(d, z, IMGX_FMT, "EPG", "img/epgon.png", 0);
                asnprintf(d, z, "</a>\n");
        } else {
/* cgi only info cap gets zap? full cap could use it too */
                if ((CAP_INFO == cap_now) && (s->chan == cap_chan)) {
                        asnprintf(d, z, "<a href=\042%02d.html?x=%d\042>",
                                s->chan, s->chan);
                        asnprintf(d, z, IMGX_FMT, "ZAP", "img/epgoff.png", 0);
                        asnprintf(d, z, "</a>\n");
                }
        }


/* show last sig avg */
        asnprintf(d, z, "<br />\n");

        sr = scan_rate;
        if (0 == scan_sig) sr = 0;
        if (CAP_NONE != cap_now) sr = 1;
        

/* do SNR RMS or Strength average */
        if (0 != scan_snr) {

#if USE_DEBUG
                asnprintf(d, z, "<!-- SNR dB ");
                for (i = 0; i < SIG_PNG_W; i++)
                        asnprintf(d, z, "%d.%02d ",
                                0xFF & (s->rmp[i] >> 8),
                                ((0xFF & s->rmp[i]) * 100 ) >> 8 );
                asnprintf(d, z, " -->\n");
#endif
                calc_snr_rms( s );
                asnprintf(d, z, "SNR: %d.%02d dB RMS\n",
                                0xFF & (s->snr_rms >> 8),
                                ((0xFF & s->snr_rms) * 100 ) >> 8 );
        } else {

#if USE_DEBUG
                asnprintf(d, z, "<!-- STR % ");
                for (i = 0; i < SIG_PNG_W; i++)
                    asnprintf(d, z, "%d ", s->smp[i]);
                asnprintf(d, z, " -->\n");
#endif

                calc_sig_avg( s );
                asnprintf(d, z, "Sig: ");
                asnprintf(d, z, "%02d%% Avg\n", s->str_avg);
        }

#if USE_RMS_RATE
        if (0 != sr) {
            if (s->chan == cap_chan)
                asnprintf(d, z, "@ %d/s", sr);
        }
#endif

        asnprintf(d, z, "<br />\n");

/* show error rate during capture, or blank line */
        if (CAP_NONE != cap_now) {
                double erate;
                erate = 100.0 * (double) pkt.errors / (double) pkt.count;

/* show errors if doing capture */
                if ( (pkt.errors > 0) && (cap_chan == s->chan) ) {
                        asnprintf(d, z, "Err: ");
                        asnprintf(d, z, "%4.2f%% (%d)", erate, pkt.errors);
                        asnprintf(d, z, "<br />\n");
                } else {
/* no errors gets a blank line */
                        asnprintf(d, z, "<br />\n");
                }
        } else {
                asnprintf(d, z, "<br />\n");
        }
        asnprintf(d, z, "</div>\n");


/********************************************************* CSS legend */

        asnprintf(d, z, "<br class=\042%s\042 />\n", "br_epgdiv");
        asnprintf(d, z, "<br class=\042%s\042 />\n", "br_epgdiv");

        build_epg_filter_html4(d, z );
        build_epg_legend( d, z );

        asnprintf(d, z, "</div>\n");
        asnprintf(d, z, "</div>\n");

        fprintf( wf, "%s", d);

/* div for epgtop */

        return;
}


/* insert blank entries, only if no filters */
/* d is destination of size z
   n is name of blank for header
   b is number of blank tiles to insert
   c is color index of blanks to insert
   e is current stage index to set to white for NOW indication
   g is tile size, "big", "small" or "tiny"
*/
/* static */
void
build_epg_filler (char *d, int z, int b, int c, char *n, char *g, int i,
                struct event_s *e )
{
        int j, sr, hh, mm, ss;
        char *r, *s, *t, a[32];


/* pointers wrong? */
        if ( (NULL == d) || (NULL == n) || (NULL == g) )
            return;

/* counters wrong? */
        if ((z < 1) || (b < 1) || (c < 0) || (c >= COLORZ) ) return;
/* is ok if i is bogus, it won't match */

/* grid not enabled? checked elsewhere to save a call */
//      if (0 == epg_grd) return;

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);

        r = "epgtile";
        for (j=0; j < b; j++) {
                t = colors[c];
                asnprintf(d, z, "<div class=\042%s %s%d\042>\n", r, t, 1);
                asnprintf(d, z, "<dl class=\042dl_%s\042>\n", g );

/****************************************************** filler event name */
                asnprintf(d, z, "<dt class=\042dt_%s %s\042>\n", g, "epgtc");
                asnprintf(d, z, "%s\n", n);
                asnprintf(d, z, "</dt>\n");

/* show (continued) for description else color or abbreviate it */

                s = "(continued)";

                *a = 0;
/* current 30m filler timeframe is indicated by white description */
                if ((j+1) == i) {
                        t = "white";
                        sr = (e->st + (e->ls - SECDT)) - utsnow;
                        if (sr < 0) sr = 0;
                        hh = sr / 3600;
                        mm = (sr - (hh * 3600)) / 60;
                        ss = sr % 60;
                        snprintf( a, sizeof(a), "%02d:%02d:%02d left",
                                        hh, mm, ss);
                }

/* tiny tile doesn't have enough room for this */
                if (3 == use_css) { s = "(cont)"; }

/****************************************************** filler event cont */
                asnprintf(d, z, "<dd class=\042dd_%s %s%d %s\042>",
                        g, t, 0, "epgtc");

//              if (3 != use_css) asnprintf(d, z, "<br />");

                asnprintf(d, z, "%s", s);
                if (*a != 0) asnprintf(d, z, "<br />%s", a);

                asnprintf(d, z, "</dd>\n");

                asnprintf(d, z,"</dl>\n");
                asnprintf(d, z,"</div>\n");
        }
}

/* build tiles for each weekday timer.
    cyan tiles are normal weekday timers
    red tiles are ignored timers because of overlap with another timer
*/

/* static */
void
build_epg_timers ( FILE *wf, char *d, int z, char *g, int ch )
{
        int b, i, j, k;
        struct qtimer_s *t;
        struct tm estm;                         /* event start time tm */
        struct sig_s *s;
        char n[PNZ];                            /* event name */
//      char *n1;                               /* name strip pointer */
        char *c;                                /* tile color */
        char *w;                                /* weekday color class */
        char *sb;                               /* scrollbar class */

        s = &ptc[ ch ].sig;

        sb = c = w = "";
        *d = 0;
        if (1 != use_css) return;               /* only large tiles */

/* count the number of weekday timers */
        k = 0;
        for (i=0; i<timer_idx; i++) {
                t = &timer[i];

                if (T_SEARCH == t->qstat) continue;
                if (ch != t->chan) continue;
                if (0 != t->etmid) continue;
//              if (0 == t->days) continue;

                k++;
        }

/* nothing to do */
        if (0 == k) return;

        asnprintf(d, z, "\n<!-- %s -->\n", WHO);
/* show any weekday timers that match this channel */
        asnprintf(d, z, "<div class=\"%s\">", "epgdiv");
        asnprintf(d, z, "<br class=\"%s\" />", "br_epgdiv");
        asnprintf(d, z, "<center id=\"%s\" />", "weekday");
        asnprintf(d, z, "<hr />");
        asnprintf(d, z, "Volatile and Weekday Timers %s.%d", s->sid, s->pn);
        asnprintf(d, z, "</center>");
        asnprintf(d, z, "</div>\n");

        fprintf(wf, "%s\n", d);
        *d = 0;

        t = &timer[0];

        for (i=0; i < timer_idx; i++)
        {
                t = &timer[i];

                *d = 0;
/* no search, no EPG entered event, non channel events */
                if (T_SEARCH == t->qstat) continue;
                if (ch != t->chan) continue;
                if (0 != t->etmid) continue;
//              if (0 == t->days) continue;

                localtime_r( (time_t *)&t->start, &estm);

                snprintf( n, sizeof(n), "%s", t->name);

#ifdef USE_SHORT_TIMER_NAME
/* strip timer flags. there's already a function for this... */
                n1 = strchr(n, '@');
                if (NULL != n1) *n1 = 0;
                n1 = strchr(n, '.');
                if (NULL != n1) *n1 = 0;
                if (0 == *n) continue;
#endif

/* not specified or ignore gets red */
                c = "wdi";

/* future is dark cyan */
                if (T_FUTURE == t->qstat) c = "wdn";

/* today but not live gets green */
                if (estm.tm_yday == tloc.tm_yday) c = "wdt";

/* stream gets dark yellow */
                if (T_STREAM == t->qstat) c = "wds";

/* ignore gets red */
                if (T_IGNORE == t->qstat) c = "wdi";


#ifdef USE_WEEKDAY_FORMS
/* useful for changing a timer? could put in value='s from the fields */
                asnprintf(d, z, "<form name=\042%s\042"
                        " method=\042%s\042"
                        " enctype=\042%s\042>\n",
                    "timerdel", "GET", "application/x-www-form-urlencoded");
#endif

                asnprintf(d, z, "<div class=\042%s %s%d\042>\n", "epgtile", c, 1);

                asnprintf(d, z, "<dl class=\042dl_%s\042>\n", g);

                asnprintf(d, z, "<dt class=\042dt_%s %s\042>", g, "epgtc");

#if USE_WEEKDAY_FORMS
                asnprintf(d, z, "<input type=\042%s\042 value=\042%s\042>\n",
                        "submit", "Del");
#endif

/* TODO needs buttons similar to EPG tiles */

/* click title to remove timer */
                asnprintf(d, z, "<a href=\042?d=%c%d:%d:%d:%s\042>",
                            (0 == t->days)?'V':'W',
                            t->chan, t->start, t->len/60, t->name);

                asnprintf(d, z, "%s", n);

                asnprintf(d, z, "</a>");

                asnprintf(d, z, "<br />");

                asnprintf(d, z, "%02d:%02d %dm %s %s %d",
                                estm.tm_hour, estm.tm_min, t->len/60,
                                days[ estm.tm_wday ],
                                mons[ estm.tm_mon ],
                                estm.tm_mday
                );
                asnprintf(d, z, "</dt>\n");
                sb = "";

/* not needed? */
//              if (0 != epg_sb) sb = " epgvsb";

                asnprintf(d, z, "<dd class=\"dd_%s %s%d%s\">\n",
                            g, c, 0, sb );

/* TODO: need program # for vc list here too, but by s-> struct!??
        maybe not if only changing and not adding
*/

/* put up caplog icon if it's current timer */
                if (T_STREAM == t->qstat) {
                    asnprintf(d, z,"<a href=\042/%s\042>"
                             "<img border=0 src=\042%s\042></a>\n",
                                &caplog_name[strlen(out_path)],
                                "/pg/img/log24.png");
                }

                if (0 == t->days) asnprintf(d, z, "Volatile ");
                if (0 != t->days) asnprintf(d, z, "Weekday ");

                if (T_IGNORE == t->qstat) {
                    asnprintf(d, z, "IGNORED ");
                }
#if 0
/* etmid debug */
                asnprintf(d, z, " %04X.%04X",
                            0xFFFF & (t->etmid>>16), 0xFFFF & t->etmid);
#endif

/* hrefs for each weekday to toggle the bit for that day */
                if (t->days != 0) {
                    for (j=6; j >= 0; j--) {
                        b = (1<<j) & t->days;

/* grey: no weekday bits match */
                        w = "wda0";

                        if (0 != b) {
/* cyan: weekday bits match */
                            w = "wda1";
                            if ( ((6-j) == tloc.tm_wday)
                              && (estm.tm_yday == tloc.tm_yday) )
/* green: weekday bits match, weekday is today, yearday is today */
                                w = "wda2";
                        }

                        asnprintf(d, z, "<br />\n");
                        asnprintf(d, z, "<a class=\"%s\" "
                                    "href=\"%02d.html?y=%d:%s:%d\">",
                            w, t->chan, t->chan, t->name, (1 << j) );

                        if (0 == b) {
                            asnprintf(d, z, "<img alt=\"%s\""
                                            " class=\"%s\""
                                            " src=\"%s\">",
                                    "0", "wdb0", "img/norec16.png");
                        } else {
                            asnprintf(d, z, "<img alt=\"%s\""
                                            " class=\"%s\""
                                            " src=\"%s\">",
                                    "1 ", "wdb1", "img/rec16.png");
                        }

                        asnprintf(d, z, " %s", daysl[6-j]);
                        asnprintf(d, z, "</a>");
                    }
                }
                asnprintf(d, z, "</dd>\n");
                asnprintf(d, z, "</dl>\n");
                asnprintf(d, z, "</div>\n");
                asnprintf(d, z, "</form>\n");
                fprintf(wf, "%s\n", d);
        }
        *d = 0;
}



/* TODO: conditionals for each event are messy. Break it down some more. */
/* TODO: abstract the tile creation. */
/* Similar to html version but style may be tweakable via style.css */
/* static */
void
dump_epg_html4 ( struct event_s *ev, struct pgm_s *p, short *pgx, char *caller )
{
        FILE *wf;                               /* write file */
        struct sig_s *s;                        /* sig structure */
        struct event_s *e1;                     /* point to one event */
        time_t et;                              /* event time time_t */

        char h[8192],                           /* header */
            n[128],                             /* file name */
            ht[16],                             /* http title */
            en[PNZ],                            /* event name */
            ed[PDZ],                            /* event description */
            tn[64],                             /* truncated name NOT USED? */
            d[8192],                            /* string buf */
            u[64];                              /* href url */

        char a[32];                             /* action image */
        char *b;                                /* image format */

        char *c = "";                           /* alt text */
        char *ed1;                              /* description pointer */
        char *g;                                /* tile large small tiny */
        char *d1;                               /* temp string fix */
        char *sb;                               /* scrollbar class */

        int mo;                                 /* filters off is zero */
        int bt;                                 /* blank tile grid filler */
        int n1;                                 /* skip past initial "The " */
        int ec;                                 /* event color index now */
        int sc;                                 /* event color index filler */
        int es;                                 /* event status bits */
        int i, j, k, x, y, z;                   /* counters */
        int ch;                                 /* channel */
        int iz;                                 /* icon size */

/* lots of ways to track how the divider will appear */
        int cpn = -1;                           /* current program number */
        int cdn = -1;                           /* current day number */
        int ppn = -1;                           /* previous program number */
        int pdn = -1;                           /* previous day number */
        int ptd = -1;                           /* primetime day number */
        unsigned short pv[VCZ];                 /* event program numbers */
        unsigned short nd[366];                 /* 18 days is actual max */
//      char nd[366];                           /* event day flags */
        int pvc = 0;                            /* prev virt channel */
        int nde = 0;                            /* number of days of events */
        int wdo = 0;                            /* week day offset */
        int lyo = 0;                            /* normal/leap year offset */
        unsigned int r;                         /* refresh time */
        int gts;                                /* grid time slot */
        int w3cv;

/* FIXME: scan conflict wrong epg top */
        ch = p->chan;
        s = &ptc[ ch ].sig;

/* old style, shows all events (all programs and all weekdays) on one page */
        if (0 != epg_all) s->yday = -1;

        d1 = "";
        *h = 0;

/* file name */
        snprintf( n, sizeof(n), "%s%s/pg/%02d.html",
                    out_path, ram_path,  ch );

        get_time();
        advrlog( LOG_INFO, "%s(%s) %d", WHO, caller, ch);

/* refresh is every 30m (or sooner if signal scanning this channel?) */
        r = utsnow;
        r += 1800;
        r /= 1800;
        r *= 1800;
        r -= utsnow;

/* Stagger each refresh by 5s so multi-card doesn't waylay the CPU. */
/* The CPU usage is an issue if capture and playback machine are the same. */
        r += 5 * (1 + arg_devnum);

        wf = fopen( n, "w");
        if (NULL == wf) return;

        g = "";
        if (1 == use_css) g = "large";
        if (2 == use_css) g = "small";
        if (3 == use_css) g = "tiny";

//      b = " <a href=\042%s\042>\n  "IMG_EPG_FMT "\n </a>\n";
//      b = " <a href=\042%s\042>\n  "IMG_EPG_CSS "\n </a>\n";
        b = "<a href=\042%s\042> " IMG_EPG_CLASS "</a>\n";


        e1 = &ev[ pgx[ 0 ] ];

/* make a list of programs and days in guide */
        memset( nd, 0, sizeof(nd));
        memset( pv, 0, sizeof(pv));
        pvc = 0;

/* calc start weekday of year */
        wdo = tloc.tm_wday - (tloc.tm_yday % 7);
        if (wdo < 0) wdo += 7;
        wdo %= 7;

        advrlog( LOG_INFO, "%s year %d starts on %s %d",
                WHO, 1900+tloc.tm_year, daysl[wdo], wdo);


/************************************ build list of programs */
        for (i = 0; i < p->idx; i++) {
                e1 = &ev[ pgx[ i ] ];
                if (ppn != e1->pn) {
/* duplicate check */
                        k = ~0;
                        for (j = 0; j < pvc; j++) {
                                if (pv[j] == e1->pn) {
                                        k = 0;
                                        break;
                                }               
                        }
                        if (0 == k) continue;

                        pv[ pvc ] = e1->pn;
                        advrlog( LOG_INFO, "%s.%d pn %d",
                                 s->sid, pvc+1, pv[pvc] );
                        pvc++;
                        if (VCZ == pvc) break;
                }
                ppn = e1->pn;
        }

/**************************************** build list of days */
        nde = 0;
        for (i = 0; i < p->idx; i++) {
                e1 = &ev[ pgx[ i ] ];
                if (pdn != e1->stm.tm_yday) {

/* duplicate check */
                        k = ~0;
                        for (j = 0; j < nde; j++) {
                                if ( nd[ j ] == e1->stm.tm_yday ) {
                                        k = 0;
                                        break;
                                }               
                        }
                        if (0 == k) continue;

                        nd[ nde ] = e1->stm.tm_yday;
                        nde++;
                        if (18 == nde) break;
                }
                pdn = e1->stm.tm_yday;
        }

/* sanity check, limits number of pgms to VCZ and days of events to 18 */
        if ( (pvc >= VCZ) || (nde > 18) ) {
    
                if (pvc >= VCZ)
                        dvrlog( LOG_INFO, "%s ch %d invalid pvc %d idx %d",
                                WHO, p->chan, pvc, p->idx);
                if (nde > 18)
                        dvrlog( LOG_INFO, "%s ch %d invalid nde %d idx %d",
                                WHO, p->chan, nde, p->idx);

                if (NULL != wf) fclose( wf );
                return;
        }

        ppn = -1;
        pdn = -1;

        advrlog( LOG_INFO, "EPG%02d has ncs %d, days %d, events %d",
                ch, pvc, nde, p->idx );

        *d = 0;
        z = sizeof(d);

/* header: */

/* refresh is every 30m, or sooner if signal scanning this channel */
        if ((0 != scan_one) && (0 != scan_sig) && (p->chan == cap_chan))
            r = 30;

        snprintf( ht, sizeof(ht), "%s %s %02d", s->call, s->sid, s->chan);

//      build_head_html( h, sizeof(h), 13, ht, r, WHO ); /* xhtml 1.0 bit 3 */
        build_head_html( h, sizeof(h), 5, ht, r, WHO );
        fprintf( wf, "%s\n", h);
        
/* top: station png, status and sig, and current event */
        *h = 0;

        build_epg_top(wf, h, sizeof(h), p);
/* body: */

//      mo = p->hide | p->age | p->find;
        mo = 0;
        cdn = 0;

/* displayed event count */
        y = 0;

        *d = 0;



/********************************************* first EPG divider "sid.pn" */
/* show top, pgm hrefs (if > 1 pgm), and day hrefs (if > 1 day) */
        if (s->yday >= 0) {
                cpn = s->pn;
                if (pvc > 0) cpn = pv[0];
                cdn = s->yday;

/* is floating */
                asnprintf(d, z, "\n");
                asnprintf(d, z, "<div class=\042%s\042>\n", "epgdiv");

                asnprintf(d, z, "<br class=\042%s\042 />\n",
                                "br_epgdiv" );

/* center is pgm place-holder */
                if (ppn != cpn) {
                        asnprintf(d, z, "<center id=\042pgm%d\042>\n", cpn );
                } else {

                        asnprintf(d, z, "<center>\n", cpn );
                }
                asnprintf(d, z, "<hr id=\042pgm%dday%d\042 />\n",
                                cpn, cdn);

#if 0
/* first one doesn't need TOP? maybe it does for cellphone */
/* FIXME: fat space after 'TOP', needs uparrow image too */
                asnprintf(d, z, "<a class=\042%s\042 "
                                    "href=\042%s\042>%s</a>\n | \n",
                                "f4 green", "#top", "TOP ");
#endif

/*************************************** first Primetime href and sid.pn(s) */
                asnprintf(d, z, "<a class=\042%s\042 "
                                    "href=\042#pgm%dpt%d\042>"
                                    "Prime Time %s.%d</a>",
                                "f4 green", cpn, cdn, s->sid, cpn);

/* show virtual channel sid + minor program nav hrefs if more than one */
                if ( (0 != epg_all) || (s->pn < 1) ) {
                        if (pvc > 1) {
                            asnprintf(d, z, " | \n");
                            for (j = 0; j < pvc; j++) {
                                k = ~0;

/* full cap shows all programs, new logical chan cap shows only this pgm# */
                                if ( (s->pn > 0) && (s->pn != pv[j]) )
                                    continue;

/* current program does not get href */
                                if (cpn == pv[ j ]) k = 0;
                                if (0 != k)

/* TODO: can the VC also be selected with correct cgi? */
                                    asnprintf(d, z,
                                            "<a class=\042%s\042 "
                                            "href=\042#pgm%d\042>",
                                            "f4 green", pv[j]);

/* netname.pgm# */
                                asnprintf(d, z, "%s.%d \n", s->sid, pv[j] );

                                if (0 != k) asnprintf(d, z, "</a>\n");
                            }
                        }
/* fat space at end of list */
                        asnprintf(d, z, " ");
                }



/******************************************** first EPG divider weekday(s) */

/* guide day nav hrefs if more than one day in guide */
                if (nde > 1) asnprintf(d, z, " | \n");

                pdn = -1;

//              asnprintf(d, z, "wdo %d, ", wdo);

                for (j = 0; j < nde; j++) {
                        char *fz;
                        char **wdt;

                        wdt = daysl;
                        if (nde > 2) wdt = days;
                        fz = "f4 green";
                        lyo = 0;

/* if next year-day number is less than first one, year meridian occurred */
                        if ( (j > 0) && (nd[0] > nd[j]) ) {
                                lyo++;
//                              if (0 == (e1->stm.tm_year & 3 )) lyo++;
                        }

                        k = ~0;
                    
                        if (cdn == nd[j]) k = 0;
                        if ( nd[j] == s->yday ) fz = "f4 white";

/* setting s->yday limits to single day uses less memory on web cell phone */
                        if (0 != k)
                                asnprintf( d, z, "<a class=\042%s\042 "
                                                "href=\042?n=%d:%d\042>",
                                                fz, ch, nd[j]);

                        asnprintf( d, z, " %s ", wdt[(nd[j] + wdo+lyo) % 7 ]);
//                      asnprintf( d, z, " %d ", (nd[j] + wdo + lyo) % 7 );

                        if (0 != k) asnprintf(d, z, "</a>\n" );
                }

                asnprintf(d, z, "</center>\n");
                asnprintf(d, z, "</div>\n");

                pdn = cdn;
                ppn = cpn;
        }

        if (0 != *d) fprintf( wf, "%s", d);
        *d = 0;

/***************** build list of events: p->idx is fewer loops than E*P*V */
        for (i = 0; i < p->idx; i++) {
                j = pgx[ i ];
                e1 = &ev[ j ];


                *d = 0;
                z = sizeof(d);

                cpn = e1->pn;
                cdn = e1->stm.tm_yday;

/* if epg_all is not selected, and only one program selected, 
    then only show the selected program, otherwise show all.
*/
                if (0 == epg_all)
                    if ((s->pn > 0) && (cpn != s->pn))
                        continue;

/* moved EPG days divider here before the further calculations */

/* if year day set, only 1 divider, otherwise dividers for each day */
                x = 0;
                if ( (-1 < s->yday) && (s->yday == cdn) ) x = ~0;
                if (-1 == s->yday) x = ~0;

/* is divider needed for new day or new program? */
                if ( (0 != x) && ((ppn != cpn) || (pdn != cdn)) ) {

/*************************************************** EPG divider "sid.pgm" */
/* show top, pgms (if > 1), and days (if > 1) */

/* is floating */
                    asnprintf(d, z, "\n");
                    asnprintf(d, z, "<div class=\042%s\042>\n", "epgdiv");

                    asnprintf(d, z, "<br class=\042%s\042 />\n",
                                "br_epgdiv" );

/* new program number or day number gets new primetime header */
                    ptd = -1;

                    if (ppn != cpn) {

/* center is pgm place-holder */
                        asnprintf(d, z, "<center id=\042pgm%d\042>\n", cpn );
                    } else {

/* still needs to be centered */
                        asnprintf(d, z, "<center>\n", cpn );
                    }

                    asnprintf(d, z, "<hr id=\042pgm%dday%d\042 />\n",
                                cpn, cdn);
#ifdef USE_EPG_TOP_IMG
/* fat space after top icon */
                    asnprintf(d, z, "<a class=\042%s\042"
                                    " href=\042%s\042>"
                                    "<img alt=\042%s\042"
                                    " src=\042%s\042"
                                    " border=\042%d\042></a>\n | \n",
                            "f4 green", "#top", "TOP", "/pg/img/top24.png", 0);
#else
/* text only. top16.img is too small to see, and top24 makes vspacing odd */
                    asnprintf(d, z, "<a class=\042%s\042 "
                                    "href=\042%s\042>%s</a>\n | \n",
                                "f4 green", "#top", "TOP ");

#endif

/* primetime href and station ID */
                    asnprintf(d, z, "<a class=\042%s\042 "
                                    "href=\042#pgm%dpt%d\042>"
                                    "Prime Time %s.%d</a>",
                                "f4 green", cpn, cdn, s->sid, cpn);

/* show virtual channel sid + minor program nav hrefs if more than one */
                    if ((0 != epg_all) || (s->pn < 1)) {
                        if (pvc > 1) {
                            asnprintf(d, z, " | \n");

                            for (j = 0; j < pvc; j++) {
                                k = ~0;

/* full cap shows all programs, new logical chan cap shows only this pgm# */
                                if (0 == epg_all)
                                    if ( (s->pn > 0) && (s->pn != pv[j]) )
                                        continue;

/* current program does not get href */
                                if (cpn == pv[ j ]) k = 0;
                                if (0 != k)
                                    asnprintf(d, z,
                                            "<a class=\042%s\042 "
                                            "href=\042#pgm%d\042>",
                                            "f4 green", pv[j]);

/* netname.pgm# */
                                asnprintf(d, z, "%s.%d ", s->sid, pv[j] );

                                if (0 != k) asnprintf(d, z, "</a>\n");
                            }
                        }
/* fat space at end of list */
                        asnprintf(d, z, " ");
                    }

                    ppn = cpn;

/*************************************************** EPG divider weekday(s) */

/* guide day nav hrefs if more than one day in guide */
                    if (nde > 1) asnprintf(d, z, " | \n");

                    cdn = e1->stm.tm_yday;

                    pdn = -1;

                    for (j = 0; j < nde; j++) {
                        char **wdt;
                        char *fz;

                        wdt = daysl;
                        if (nde > 1) wdt = days;
                        fz = "f4 green";
                        lyo = 0;
            
/* normal year starts 1 weekday later */
//                      if ( (j > 0)  && (nd[0] > nd[j]) && (nd[j] < 7) )
                        if ( (j > 0)  && (nd[0] > nd[j]) ) {
                                lyo++;
/* leap year starts 2 weekdays later */
//                              if (0 == (3 & e1->stm.tm_year)) lyo++;
                        }

                        k = ~0;
                    
/* Old style: crashes a web cell phone when phone runs out of memory. */
/* Current day has no href. All use local id tags
     for multi-day EPG if s->yday is not set
*/
                        if (cdn == nd[j]) k = 0;
                        if ( nd[j] == s->yday ) fz = "f4 white";
                        if (-1 == s->yday) {
                                if (0 != k) asnprintf(d, z,
                                                "<a class=\042%s\042 "
                                                "href=\042#pgm%dday%d\042>",
                                                fz, cpn, nd[j]);
                                asnprintf( d, z, " %s \n",
                                            wdt[ (nd[j] + wdo + lyo) % 7 ]);

                                if (0 != k) asnprintf(d, z, "</a>\n" );
                        } else {

/* setting s->yday limits to single day uses less memory on web cell phone */
                                if (0 != k) asnprintf( d, z,
                                                "<a class=\042%s\042 "
                                                "href=\042?n=%d:%d\042>",
                                                fz, ch, nd[j]);
                                asnprintf( d, z, " %s \n",
                                            wdt[ (nd[j] + wdo + lyo) % 7 ]);

                                if (0 != k) asnprintf(d, z, "</a>\n" );
                        }

                        pdn = nd[ j ];
                    }

                    asnprintf(d, z, "</center>\n");
                    asnprintf(d, z, "</div>\n");
                    pdn = cdn;
/* if ppn pdn diff */
                }


/**************************************************** EPG divider primetime */


/* draw primetime line at first timeslot starting at PRIMETIME HOUR or later */
                x = 0;
                if ( (s->yday >= 0) && (s->yday == cdn) ) x = ~0;
                if (s->yday < 0) x = ~0;
                
                if ( (0 != x) && (e1->stm.tm_hour >= PRIMETIME_HOUR) ) {

/* primetime day number diff? */
                        if (ptd != cdn) {

/* needs id for primetime in href local jump list */
                            asnprintf(d, z,"<div class=\042%s\042>\n",
                                        "epgdiv" );
                            asnprintf(d, z,"<br class=\042%s\042 />\n",
                                        "br_epgdiv");

                            asnprintf(d, z, "<hr />\n");

/* id can't be used on div or hr? ok, use it on center */
                            asnprintf(d, z, "<center id=\042pgm%dpt%d\042>\n",
                                                e1->pn, e1->stm.tm_yday);

                            asnprintf(d, z, "<a class=\042%s\042 "
                                            "href=\042%s\042>TOP</a> | ",
                                        "green", "#top");

                            asnprintf(d, z,
                                        "Prime Time %s.%d | %s, %s %d %d\n",
                                        s->sid, e1->pn,
                                        daysl[ e1->stm.tm_wday ],
                                        mons[ e1->stm.tm_mon ],
                                        e1->stm.tm_mday,
                                        1900 + e1->stm.tm_year );

                            asnprintf(d, z, "</center>\n");

                            asnprintf(d, z, "</div>\n");
                        }
                        ptd = cdn;
                }

/* if divider is not blank, write it */
                if (0 != *d) fprintf(wf, "%s\n", d);
                *d = 0;


/* day filter and program filter, but only if not using find or all */
                if ( (0 == epg_all) && (0 == p->find) ) {
                    if ( (s->yday >= 0) && (e1->stm.tm_yday != s->yday) )
                        continue;

                    if ( (s->pn > 0) && (e1->pn != s->pn) )
                        continue;
                }


#if 0
/* if not using find & has set day filter & event doesn't match selected day,
    skip event
*/
                if (0 == p->find)
                    if (s->yday >= 0)
                        if (e1->stm.tm_yday != s->yday)
                                continue;
#endif


/*************************************************** build one event */
                y++;
                astrncpy( tn, e1->tname, PNZ );
                astrncpy( en, e1->name, PNZ );
                n1 = 0;

/* We all know it's The... fix crapola */
                if (e1->name == strstr(e1->name, "The ")) n1 = 4;
                if (e1->name == strstr(e1->name, "THE ")) n1 = 4;


                astrncpy( en, &e1->name[n1], PNZ );
                astrncpy( ed, e1->desc, PDZ );

/* Also fix this crapola. Needs less, not more. */
                d1 = strstr(en, ".com");
                if (d1 != NULL) *d1 = 0;

/* NOTE: you'll probably have to adjust the last parm on truncate_text_kern
    to the number of pixels for the letter capital W in your san-serif font,
    if you're not using the font: mozilla san-serif smallest size 14.
    Sizes do not translate very well to width. You'll have to play with it.
    W is usually the widest character but that depends on diagonal W.
*/

/* needs to match _large dimensions in style.css */
/* large event name with description */
                if (1 == use_css) {
                        truncate_text_kern_box(
                                en, kern_p256_8859_1,
                                232, 8, 1, CSS_KERN_TLARGE, 1);
//                      en[20] = 0;
/* 7 lines */
                        truncate_text_kern_box(
                                ed, kern_p256_8859_1,
                                226, 8, 7, CSS_KERN_DLARGE, 0);
                }

/* needs to match _small dimensions in style.css */
/* small event name with 2 line description */
                if (2 == use_css) {
                        astrncpy( en, e1->tname, sizeof(en)-1 );
                        truncate_text_kern_box(
                                en, kern_p256_8859_1,
                                152, 8, 1, CSS_KERN_TSMALL, 1);
//                      en[16] = 0;
                        truncate_text_kern_box(
                                ed, kern_p256_8859_1,
                                148, 4, 2, CSS_KERN_DSMALL, 0);
                }

/* needs to match _tiny dimensions in style.css */
/* tiny event name with no description */
                if (3 == use_css) {
                        astrncpy( en, e1->tname, sizeof(en)-1 );
/* 80px wide, 5 = 4px + 1px tile border, 1 line, 13 pixel, fragment ok */
                        truncate_text_kern_box(
                                en, kern_p256_8859_1,
                                80, 5, 1, CSS_KERN_TTINY, 1);
//                      en[16] = 0;
                        ed[0] = 0;
                }

                es = test_event_status( e1 );
                ec = 7; /* grey if nothing picks a color */

/* pick event color from test event bits. order is important. blue not used. */

/* TEST: skip spam except for current event?
    The problem is spam is removed in build pg epg. Whoops.
    The junk filter enabled will hide the current junk event.

                if ((p->hide)
                 && (3 == ec)
                 && (0 == (es & E_NOW)))
                        continue;
*/

// cyan used for weekday timers, not automatic ones, they're green!
//              if (0 != (es & E_TIME))  ec = 4;        /* cyan    */
                if (0 != (es & E_SPAM))  ec = 0;        /* black   */
                if (0 != (es & E_MOVIE)) ec = 3;        /* blue    */
                if (0 != (es & E_TIME))  ec = 2;        /* green   */
                if (0 != (es & E_FIND))  ec = 2;        /* green   */
/* aged will set on all old events except captures and cuts */
                if (0 != (es & E_AGED))  ec = 5;        /* magenta */
                if (0 != (es & E_TS))    ec = 6;        /* yellow  */
                if (0 != (es & E_TSC))   ec = 1;        /* red     */

/* staging grid color */
                sc = ec;
/* es & E_NOW is set during entire event if it's current */
                if (0 != (es & E_NOW))   ec = 8;        /* white   */
                gts = 0;

/* if grid and event > 30m, want white NOW tile for the proper timeslot */
                if ((0 != epg_grd) && (8 == ec)) {

/* how many 30m blocks since start? */
                    gts = (utsnow - e1->st) / 1800;
                    if (0 != gts) ec = sc;
                }

/***************************************************** event detail list */
                *d = 0;

/* classes broken down for smaller style.css */
                asnprintf(d, z, "\n");

                asnprintf(d, z, "<div id=\042p%dt%d\042"
                                " class=\042%s %s%d\042>\n",
                                e1->pn, e1->st, "epgtile", colors[sc], 1);
                asnprintf(d, z, "<dl class=\042dl_%s\042>\n", g);
                asnprintf(d, z, "<dt class=\042dt_%s %s\042>\n", g, "epgtc");

/*************************************************************** event name */
                asnprintf(d, z, "%s", en );

/* time is not displayed in small or tiny css mode */
                et = e1->st;
                if (0 == (2 & use_css)) {
//                  localtime_r( &et, &estm );

                    asnprintf(d, z, "<br />\n");

                    asnprintf(d, z, "%02d:%02d ",
                                e1->stm.tm_hour, e1->stm.tm_min);
                    asnprintf(d, z, "%dm ", e1->ls/60);

                    asnprintf(d, z, "%s ", days[e1->stm.tm_wday]);

/* date (only when changes) is not in small css mode either */
                /* NOTE: sets pdn to cdn at end of loop */
                    if ( pdn != e1->stm.tm_yday )
                            asnprintf(d, z, "%s %2d ",
                                    mons[e1->stm.tm_mon], e1->stm.tm_mday);
                }

/* update previous program number and day number with today */
                pdn = e1->stm.tm_yday;
                ppn = e1->pn;

//              asnprintf(d, z, "%04d ", 1900 + estm.tm_year);
//              asnprintf(d, z, " <br />\n");

                asnprintf(d, z, "\n</dt>\n");

/**************************************************** EPG <dd> + buttons */

/* no scrollbars yet */
                sb = "";
/* want kern truncated description with no scrollbars */
                ed1 = ed;

/* large tiles, if scroll enabled, add that class and use longer desc */
                if ( (1 == use_css) && (0 != epg_sb)
                  && (strlen(ed) < strlen(e1->desc)) )
                {
                        sb = " epgvsb";

/* scrollbars get the non kern-truncated version */
                        ed1 = e1->desc;
                }
                asnprintf(d, z,"<dd class=\042dd_%s %s%d%s\042>\n",
                            g, colors[ec], 0, sb);

//              asnprintf(d, z,"<dd class=\042dd_%s %s%d\042>\n",
//                          g, colors[ec], 0);
//              asnprintf(d, z,"<div class=\042%s\042>\n", t);


/************************************************** <dd> button list */

/* action list, junk status is always visible */

                iz = 24;
                if (use_css > 1) iz = 16;

                *a = 0;

                snprintf( a, sizeof(a), "spam%d.png", iz);
                
                c = "SPAM";
                snprintf( u, sizeof(u),
                        "/pg/%02d.html?j=%s:%u#p%dt%d", ch, e1->tname, e1->st,
                        e1->pn, e1->st );

                if (  ( (3 == (3 & use_css))
                     || (0 == (es & E_TIME)) )
                  && (0 == (es & E_TS))
                    ) {
                        if (0 != (es & E_SPAM))
                            snprintf( a, sizeof(a), "unspam%d.png", iz);

                        asnprintf(d, z, b, u, g, c, a);
                }


/* search only valid for non-spam and non-aged */
                *a = 0;
                if ( (0 == (es & E_SPAM))
                  && (3 >  (3 & use_css))
                  && (0 == (es & E_AGED)) ) {
                        snprintf(a, sizeof(a), "search%d.png", iz);
                        c = "FIND";
                        snprintf( u, sizeof(u),
                                "/pg/%02d.html?s=%02d:%s",
                                ch, ch, e1->tname);
                        if (0 != (es & E_FIND))
                            snprintf(a, sizeof(a), "unsearch%d.png", iz);
                        asnprintf(d, z, b, u, g, c, a);
                }

/* timer only valid for non-aged and non spam */
                snprintf(a, sizeof(a), "timeradd%d.png", iz);
                c = "ADD";
                if (0 != (es & E_TIME)) {
                        snprintf( u, sizeof(u),
                                "/pg/%02d.html?d=V%02d:%u:%03d:%s@.%d",
                                ch, ch, e1->st, e1->ls/60, e1->tname, e1->pn);
                        c = "DEL";
                        snprintf(a, sizeof(a), "timerdel%d.png", iz);
                        if (0 != (es & E_NOW)) {
                                c = "STOP";
                                snprintf(a, sizeof(a), "timerstop%d.png", iz);
                        }
                } else {
                        snprintf( u, sizeof(u),
                                "/pg/%02d.html?a=V%02d:%u:%03d:%s@.%d:%d",
                                ch, ch, e1->st, e1->ls/60, e1->tname, e1->pn,
                                e1->etmid);
                }

                if ( (0 == (es & E_AGED)) && (0 == (es & E_SPAM)) )
                    asnprintf(d, z, b, u, g, c, a);

/* only do these if transport stream file exists */
                if (0 != (es & E_TS)) {

/* intentionally put play farther away from zap */
                        snprintf( a, sizeof(a), "blank%d.png", iz);
                        c = "PLAY";
                        if ( (3 != use_css) && (0 != (es & E_LOG)) ) {
                                snprintf( u, sizeof(u),
                                        "mpeg://%s:%d/%s-%02d%02d-%02d%02d.%d.ts",
                                        arg_whost, arg_wport, e1->tname,
                                        e1->stm.tm_mon+1, e1->stm.tm_mday,
                                        e1->stm.tm_hour, e1->stm.tm_min,
                                        e1->pn );
                                snprintf( a, sizeof(a), "xine%d.png", iz);
                                c = "XINE";
                                asnprintf(d, z, b, u, g, c, a);
                        }

                        snprintf( a, sizeof(a), "blank%d.png", iz);
                        c = "CAPLOG";
                        if (0 != (es & E_LOG)) {
                            snprintf( u, sizeof(u),
                                "/%s-%02d%02d-%02d%02d.%d.html",
                                e1->tname, e1->stm.tm_mon+1, e1->stm.tm_mday,
                                e1->stm.tm_hour, e1->stm.tm_min, e1->pn );
                            snprintf( a, sizeof(a), "log%d.png", iz);
                            asnprintf(d, z, b, u, g, c, a);
                        }

                        snprintf( a, sizeof(a), "blank%d.png", iz);
                        c = "EDIT";

                        if (0 != (es & E_TSX)) {
                                snprintf( a, sizeof(a), "edit%d.png", iz);
/* no port, assumes local running script maps the path to cut directory */
                                snprintf( u, sizeof(u),
                                        "xtc://%s-%02d%02d-%02d%02d.%d.ts",
                                        e1->tname, e1->stm.tm_mon+1, e1->stm.tm_mday,
                                        e1->stm.tm_hour, e1->stm.tm_min, e1->pn );
/* if have tsc file, use different color smiley */
                                if (0 != (es & E_TSC))
                                    snprintf( a, sizeof(a), "cut%d.png", iz);
                                asnprintf(d, z, b, u, g, c, a);
                        }

                        snprintf( a, sizeof(a), "blank%d.png", iz);
                        c = "CAPZAP";

/* only zap timer if ts and on timer list and is now */
                        if ( (0 != (es & E_TS))
                          && (0 != (es & E_TIME))
                          && (0 != (es & E_NOW))

/* it could be on the timer list but getting ignored... */
                          && (CAP_TIME == cap_now)      /* timer cap */
                          && (e1->chan == cap_chan)     /* same chan */
                          && (e1->pn == cap_pn)         /* same pgm */
                            )
                        {
                                snprintf( a, sizeof(a), "zap%d.png", iz);
                                snprintf( u, sizeof(u),
                                        "/pg/%02d.html?z=V%02d:%u:%05d:%s@.%d",
                                        ch, ch, e1->st, e1->ls, e1->tname,
                                        e1->pn);
#if 0
/* unlink only works from index.html */
                                if (0 != (es & E_MTX))
                                    snprintf( u, sizeof(u),
                                        "/pg/%02d.html?u="
                                        "%s-%02d%02d-%02d%02d.%d.ts",
                                            ch, e1->tname,
                                            e1->stm.tm_mon+1,
                                            e1->stm.tm_mday,
                                            e1->stm.tm_hour,
                                            e1->stm.tm_min,
                                            e1->pn);
#endif
                                asnprintf(d, z, b, u, g, c, a);
                        }
                }

/* this will only fit if no .ts* buttons */
                if (0 == (es & E_TS)) {
                    c = " ";
                    if (0 != (es & E_MOVIE)) {
                        c = "MOVIE ";
                    } else {
                        if (0 != (es & E_SPAM)) c = "SPAM ";
                        if (0 != (es & E_NOW)) c = "NOW ";
                    }
/* large tiles can hold rating */
                    if (0 == (2 & use_css)) {
                            asnprintf(d, z, "%s%s ", c, e1->rating);
                    } else {
                            if (2 == use_css) {
//                              asnprintf(d, z, "%02d%02d %dm",
                                asnprintf(d, z, "%02d:%02d",
                                    e1->stm.tm_hour,
                                    e1->stm.tm_min );
//                                  e1->ls/60);
                            }
                    }
                }

/* tiny doesn't need the break, everything else does */
                if (3 != use_css) {
                    asnprintf(d, z, "\n<br />\n");
                    if (0 != *e1->desc) {

/* KTRK EPG usually has event description same as event name */
                        if (0 == strncmp(e1->desc, e1->name, PNZ)) {
                                ed1 = "n/a";
                        }
                    } else {
                        ed1 = "n/a";
                    }
                }

                asnprintf(d, z, "%s\n", ed1);

//              asnprintf(d, z, "</div>\n");
                asnprintf(d, z, "</dd>\n");
                asnprintf(d, z, "</dl>\n");
                asnprintf(d, z, "</div>\n");
                fprintf( wf, "%s\n", d);

/* how many blank tiles? */
                bt = e1->ls / 1800;
                bt --;

/* if grid, insert blanks for 30m intervals if event > 30m */
/* delete (0 == mo) unused now */

                if ( (0 != epg_grd) && (0 == mo) && (bt > 0) )
                {
                    *d = 0;
                    build_epg_filler(d, z, bt, sc, en, g, gts, e1);
                    fprintf( wf, "%s\n", d);
                }
        }

/* if no events, try to show why */
        if (0 == y) {
            char *ne = "";

            *d = 0;
            asnprintf(d, z, "<div class=\042%s\042>\n", "epgdiv");
            asnprintf(d, z, "<br class=\042%s\042 />\n", "br_epgdiv");
            asnprintf(d, z, "<center>");
            asnprintf(d, z, "<hr />\n");
            if (0 != p->find) ne = "matching ";

/* depending on wdo and lyo to be correct from first or last divider */
            if (s->yday >= 0) ne = daysl[ (s->yday + wdo + lyo) % 7];

/* full cap doesn't show program number */
            if (s->pn > 0) {
                    asnprintf(d, z, "No %s EPG events on %s.%d",
                        ne, s->sid, s->pn);
            } else {
                    asnprintf(d, z, "No %s EPG events on %s",
                        ne, s->sid);
            }

            asnprintf(d, z, "</center>\n");
            asnprintf(d, z, "<hr />\n");
            asnprintf(d, z, "</div>\n");

            fprintf(wf, "%s\n", d);

        }

/* build a list of volatile and weekday timers. timer list order is fine */
        build_epg_timers(wf, d, z, g, ch);

        fprintf( wf, "<br clear=\042%s\042 />", "all");

/* html 4.01 transitional validated */
        w3cv = 5;
#ifdef USE_XHTML
/* xhtml 1.0 transitional validated */
        w3cv = 6;
#endif
/* footer */
        *h = 0;
        build_foot_html( h, sizeof(h), w3cv ); /* validated */
        fprintf( wf, "%s\n", h);
        fflush( wf );
        fclose( wf );
}


/* macro-ize it for reability: src alt w h hs vs b */
/* Dump Event Program Guide

    Outputs the following:
        browser readable .html  The new point and blech interface.
        p->chan has the guide number for the guide it will save to

      Optional output:
        human readable .txt     text file
        machine readable .db    tab delimited fields


    Changed to use same structures as load_epg:
        e points to epg[] structure to use
        p points to pgm[] filter structure
        pgx points to pg[] index of filtered/unfiltered events
*/


/* TODO: It writes 3 files where one is enough for http operation.
   Break apart build_epg_html for string and call this dump epg text,
   after all the html moved to build epg html. CONS: 3 loops not one.

   The other files are for people who want to play with the EPG data
   themselves, since some have expressed interest in feeding a database
   with it. To me, once the show is over, I'm done with it.
   The temporary nature of this html EPG is more than enough for my needs.
   Eventually the stations will send 16 day guides if they can.
*/

/* 1400 lines? sheesh. might want to break it down some. */

/* static */
void
dump_epg_html3 ( struct event_s *e, struct pgm_s *p, short *pgx, char *caller )
{
        char h[8192],           /* html header and footer */
                n[PNZ+16],      /* event name, using larger than PNZ cutoff */
                t[PDZ+16],      /* event description, using larger than PDZ cutoff */
                epn[256],       /* EPG html name, ch.epg */
                dn[256],        /* database file name */
                gn[256],        /* guide text file name */
                wn[256],        /* web html file name */
                ln[256],        /* html capture log name */
                dt[32],         /* date time */
                un[64],         /* filename and url name */
                en[20];         /* truncated eventname */


        char *h0, *h1, *h2, *h3, *h4,           /* font size */
                *c0, *c1, *c2, *c3, *c4, *c5, *c6, *c7, /* color */
                *f, *gt, *ec;                           /* misc */
        char *ename = "";                       /* full eventname ptr */
        char *edesc = "";                       /* full event desc ptr */

/* TODO these should be moved to global as daysl[] */
        char *wdl[7] = { "Sunday", "Monday", "Tuesday", "Wednesday",
                         "Thursday", "Friday", "Saturday" };

        char *wds[7] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };


        char *wd[7];            /* weekdays, long or short format */


        FILE *df,               /* database file */
                *gf,            /* text file */
                *wf;            /* html file */

        int i, j, k, ok,
                tpg,            /* test program guide against timer events */
                pn,             /* event program number */
                lpn,            /* prev pgm#, if chg use <hr id=pgm#> */
                ldn,            /* prev dayofweek, if chg use <hr id=day#> */
                nde,            /* number of days for events */
                ptd,            /* primetime day number */
                cdn,            /* current day number */
                cdw,            /* current day of week */
                sdn,            /* start day number for epg 0(Sun)...6(Sat) */
                sdw;            /* start day of week */
        
        int ref;                /* meta refresh value to nearest 30m */
        int pf;                 /* program guide fail reason */
        short pv[VCZ];                  /* vc program numbers, filtered */
        short pvc;                      /* vc program count, filtered */

        short nd[32];           /* number of days with daynumer in guide */

        struct sig_s *s;
        struct event_s *e1;
        unsigned int letmid = 0;        /* last etmid seen */
        struct tm stm;                  /* event start time converted */
        struct stat64 fs;               /* reused for various tests */
        time_t  st;                     /* event start time raw */
        int sr;                         /* scan rate or 1 */
        char *si;                       /* IDLE, SCAN, SCANALL, CAP, FAIL */

        gf = NULL;
        df = NULL;

        s = &ptc[ p->chan ].sig;

        advrlog( LOG_INFO, "%s(%s) %d", WHO, caller, p->chan);

/* needs a blank epg at the very least for status display */
/*      if (0 == p->idx) return; */

        ptd = 0;
        lpn = 0;

        f = "font face=\042sans-serif\042"; /* epg uses proportional font */

/* smaller number is smaller font */
        h0 = "size=\0420\042";
        h1 = "size=\0421\042";
        h2 = "size=\0422\042";
        h3 = "size=\0423\042";
        h4 = "size=\0424\042";

        c0 = colors3[0];
        c1 = colors3[1];
        c2 = colors3[2];
        c3 = colors3[3];
        c4 = colors3[4];
        c5 = colors3[5];
        c6 = colors3[6];
        c7 = colors3[7];

        dt[0] = 0;

/* use file modify time for live/save date */
/*    text_time( dt, p->mtime, 20); / / date in pgm is user refresh time */

/* see if saved epg exists */
        snprintf( epn, sizeof(epn)-1, "%s%spg/%02d.epg",
                    out_path, ram_path, p->chan);
        ok = stat64( epn, &fs);

/* file exists, use file mtime for date time string */
        if (0 == ok) {
                text_time( dt, (int)fs.st_mtime, 20);
        } else {

/* file does not exist, use now for date time string */
                st = time( NULL );
                localtime_r( &st, &stm );
                asctime_r( &stm, dt );
                dt[strlen(dt)-1] = 0; /* remove \n */
                advrlog( LOG_INFO, "epg %d update %s", p->chan, dt);
        }

        ldn = -1;
        lpn = -1;

        if (0 != arg_dummy) p->chan = 0; /* dummy guide to channel 0 */

        snprintf( gn, sizeof(gn)-1, "%s%spg/%02d.txt",
                    out_path, ram_path, p->chan);

        snprintf( dn, sizeof(dn)-1, "%s%spg/%02d.db",
                    out_path, ram_path, p->chan);

/* station/network id is more readable to www user */
        snprintf( wn, sizeof(wn)-1, "%s%spg/%02d.html", 
                    out_path, ram_path, p->chan);

/* Open some files. the html file is mandatory or nothing else done. */
        wf = fopen( wn, "w" );
        if (NULL == wf) {
                dvrlog( LOG_INFO, "couldn't open output %s", wn);
                return;
        }

/* Tab separated and visual formatted text file output */
#ifdef USE_EXTRA_OUTPUT 
        gf = fopen( gn, "w" );
        if (NULL == gf) {
                dvrlog( LOG_INFO, "couldn't open output %s", wn);
        }

        df = fopen( dn, "w" );
        if (NULL == df) {
                dvrlog( LOG_INFO, "couldn't open output %s", wn);
        }
#endif

/* all three have to open or nothing happens */
        if (NULL != gf)
            fprintf( gf, "Event Program Guide for %s %s%d created on %s\n",
                        s->call, s->sid, p->chan, date_now);

/* It's less annoying to do the refresh at top and bottom of the hour,
   so the events can age off the list and current event status updated,
   and to prevent some stalls in playback during the refresh interval.

   User can still force immediate refresh with the recycle button.

NOTE:
   This is not quite as useful when events don't start at hour or half hour,
   but adjusting it to refresh at end of event should reduce that problem.
   This is for those shows that refuse to use the half hour time slotting.

CPU LOAD REDUX:
    This also has a device number time delay to prevent all the instances
    from saving/dumping the guides at exactly the same time.

REFRESH:
    Refresh is variable and can be set by the following conditions:

        Capture:
            Refresh rate is managed to reduce CPU load during capture.

            Conditions:

                If capture elapsed time before 180s:
                    Refresh is every 15s during first 60 seconds, 4x.

                If capture elapsed time after 180s:
                    Refresh should act like no capture settings below.

        No Capture:
            Refresh is x seconds until next 30m frame expires.

            Conditions:

                If epg timeout is less than utsnow + refresh,
                    the refresh is the epg timeout

                If timer end is less than refresh timeout,
                    the refresh is the timer end
                    
TODO: now write the code to match above description. is close now.

*/
        ref = 0;


/* capture needs to refresh in 15s if cap duration less than 60s */
        if ( (CAP_NONE != cap_now) && (cap_chan == p->chan) ) {
/* Manual user cap will be inefficient and dump epg html every 15s,
   but timer cap does have a known finite value from timer start + len,
   so it only updates when user requests it via http.
*/
                if (CAP_TIME == cap_now) {
                        struct qtimer_s *ts1;
                        ts1 = &timer[ timer_rec ]; /* timer rec should be current */
                        ref = (ts1->start + ts1->len) - utsnow;

/* this should never happen. if it does, make it fall thru to below */
                        if (ref < 0) ref = 0;
                }
                if (utsets < 60) ref = 15;
        }

/* capture did not set refresh, so set it here */
        if (0 == ref) {

/* see what EPG mtime - utsnow is, under 30m takes precedence */
                filebase( epn, wn, F_PFILE); /* file path and file name base */
                asnprintf( epn, sizeof(epn), "%s", ".epg"); /* ch.epg file */
                i = stat64( epn, &fs);

/* get ch.epg mtime for refresh delay, if >30m, refresh 0 to handle it below */
                if (0 == i) {
                    ref = (int)fs.st_mtime - utsnow;
                    if (ref > 1800) ref = 0; /* expires beyond 30m time slot */
                    if (ref <= 0) ref = 0; /* expired now, set 30m time slot */
                }
        }

/* if all else fails use next 30m slot for refresh */
        if (0 == ref) {
                st = utsnow;
                st /= 1800;             /* number of 30m slots */
                st *= 1800;             /* this 30m slot */
                st += 1800;             /* next 30m slot */
                ref = st - utsnow;
        }    

/* the cpu load should be spread out by 5s for each instance */
        ref += 5 + (5 * arg_devnum);

/* 10s refresh when signal scanning and same channel as epg */
        if (CAP_NONE == cap_now) {
            if (p->chan == cap_chan) {
                if (0 != scan_sig) {
                    ref = 10;
                }
            }
        }

        advrlog( LOG_INFO, "%s(%s) ch %02d utsnow %d refresh in %ds",
                WHO, caller, p->chan, utsnow, ref);

        if (NULL != wf) advrlog( LOG_INFO, "%s %s writing header", WHO, wn);
        
/* Wait until guide has figured out when the html page expires:
    This is actually more complicated and probably requires dynamic update.

    The guide should refresh when program status changes. It should
    refresh more often than the computed EIT-1.0 start value, to make
    the web page reflect the latest current program as it sees it.
*/

        *h = 0;
        snprintf( n, sizeof(n)-1, "%s %s%d", s->call, s->sid, s->chan);
        build_head_html( h, sizeof(h), 5, n, ref, WHO ); /* EPG rel href */
        
        fprintf( wf, "%s\n", h);

/* table within a table */
        fprintf( wf, TBL_FMT, TBL_BRD, 0, 4, "center", "100%");

/* 320 + 8 + 8, for station image size and borders */
        fprintf( wf, "<tr>\n");
        fprintf( wf, TD_FMT, "middle", "336");

/* see if 320x180 station bitmap exists and add if so */
        snprintf( un, sizeof(un), "%s%spg/img/%s.png",
                    out_path, ram_path, s->sid );
        ok = stat64( un, &fs );
        if (0 == ok) {
            snprintf( un, sizeof(un), "img/%s.png", s->sid);
            fprintf( wf, IMGA_FMT "\n", s->sid, un, "left", 320, 180, 8, 8, 0);
        }

/* should translate to 100% of what's left
   after 336 pixels took x% of original 100% */
        fprintf( wf, TBL_FMT, TBL_BRD, 0, 4, "center", "100%");

/* middle 33% table, or left 50% table if no image */
        fprintf( wf, "<tr>\n");
        fprintf( wf, TD_FMT, "top", "50%");
/* epg status font */
        f = "font";
        fprintf( wf, "<p>\n");

/* indicate station is atsc system time-sync Z config line with yellow font */
        if (cap_zc == s->chan) {
            fprintf( wf, "<%s %s %s>", f, h3, c3);
        } else {
            fprintf( wf, "<%s %s %s>\n", f, h3, c7);
        }

        fprintf( wf, "%d Events %s %s%d ", p->idx, s->call, s->sid, s->chan );
        if (s->mgt_hrs > 0) fprintf( wf, "%dh", s->mgt_hrs );

/* turn off yellow text for rest of epg info */
        fprintf( wf, "</%s>\n", f);
        fprintf( wf, "<br>\n");

        gt = "";

#ifdef USE_UPDATE
#warning using EPG update
/* see above for refresh setting */
        if (ref > 0) {
                st = utsnow + ref;
                localtime_r( &st, &stm );

/* TODO: re-use refresh to be a link to refresh */
                fprintf( wf, "UPD %02d:%02d:%02d %lds", 
                    stm.tm_hour, stm.tm_min, stm.tm_sec, st - utsnow );
        }

#if 0
        else
        {
                if (0 != s->pgto) {
                        fprintf( wf, "Guide expired" );
                } else {
                        fprintf( wf, "Non-auto EPG" );
                }
        }
#endif

        fprintf( wf, "<br>\n");

        gt = "NEW";
        if (0 == s->pgto) gt = "OLD";
        if (CAP_NONE != cap_now)
                if (p->chan == cap_chan)
                        gt = "Live";

/* future mtime for saved or last ctime for live */
        fprintf( wf, "%s %s ", gt, &dt[11]);            /* created on */
        dt[10] = 0;
        fprintf( wf, "%s ", &dt[4]);
    
        if ( (CAP_NONE != cap_now) && (p->chan == cap_chan) )
                fprintf( wf, "ET %ds", utsets);

        fprintf( wf, "<br>\n");
#endif

        st = s->pgmt;
        localtime_r( &st, &stm );
/*
        fprintf( wf, "Next %02d:%02d:%02d %lds\n", 
                     stm.tm_hour, stm.tm_min, stm.tm_sec, st - utsnow );
        fprintf( wf, "<br>\n");
*/

/* show filter settings and hrefs to change them */
        fprintf( wf, "<%s %s %s>%s </%s>\n", f, h3, c7, "Filters: ", f);

/* cgi toggle search filter */
        fprintf( wf, "<a href=\042%02d.html?m=%d\042>",
                        s->chan, s->chan );

/* uppercase means filter on */
        fprintf( wf, "<%s %s %s> %s </%s>",
                     f, h1, c3, (0 != p->find) ? "FIND":"find", f );

        fprintf( wf, "</a>\n");


/* cgi toggle spam filter */
        fprintf( wf, "<a href=\042%02d.html?h=%d\042>",
                        s->chan, s->chan );

/* uppercase means filter on */
        fprintf( wf, "<%s %s %s> %s </%s>",
                     f, h1, c4, (0 != p->hide) ? "JUNK":"junk", f );

        fprintf( wf, "</a>\n");


/* cgi toggle aged filter */
        fprintf( wf, "<a href=\042%02d.html?o=%d\042>",
                        s->chan, s->chan );

/* uppercase means filter is on */
        fprintf( wf, "<%s %s %s> %s </%s>",
                     f, h1, c6, (0 != p->age) ? "AGED":"aged", f );

        fprintf( wf, "</a>\n");
        fprintf( wf, "<br>\n");

/* FIXME: spaghetti logic for this and the next one */

/* STATUS FIRST:
    STATUS: IDLE SCAN SCANALL CAPTURE
    SIGNAL: xx%AVG
*/
        fprintf( wf, "Status: ");

        si = "Idle";

        if (CAP_NONE != cap_now) {
                si = "Cap EPG ";
                if (CAP_TIME == cap_now) si = "Cap Timer ";
                if (CAP_USER == cap_now) si = "Cap Manual";
            
        }

        if (CAP_NONE == cap_now) {
                if (0 != scan_sig) si = "Scan";
                if (0 == scan_one) si = "Scan All";
        }

        if (in_file < 3) si = "Sleeping";

/* put up status and relative href for finding current capture EPG */
        fprintf( wf, "%s\n", si);

/* not Idle gets href to active guide unless already here */
//      if ( ('I' != *si) && (cap_chan != s->chan) )
                fprintf( wf, "<a href=\042/pg/%02d.html\042>%s </a>",
                        cap_chan, ptc[cap_chan].sig.sid );

#if 0
/* Idle shows last capture fail status for this channel, if not sig scan */
        if ('I' == *si) {
            if (0 == scan_sig) {
                if (s->cap_fail > 0) {
                    fprintf( wf, "<%s %s %s>\n", f, h3, c1 );
                    fprintf( wf, "%s FAIL </%s>", cap_fails[s->cap_fail], f );
                }
            }
        }
#endif

        fprintf( wf, "<br>\n");

/* show last sig avg */

        sr = scan_rate;
        if (0 == scan_sig) sr = 0;
        if (CAP_NONE != cap_now) sr = 1;
        
        if (scan_snr) {
            fprintf( wf, "SNR: ");
            calc_snr_rms( s );
            fprintf( wf, "%d.%02d RMS\n", 0xFF & (s->snr_rms >> 8),
                    0xFF & ((s->snr_rms * 100) >> 8) );
        } else {
            fprintf( wf, "Sig: ");
            calc_sig_avg( s );
            fprintf( wf, "%02d%% Avg\n", s->str_avg);
        }

        if (0 != sr) {
            if (s->chan == cap_chan)
                fprintf( wf, " @ %d/s", sr);
        }
        fprintf( wf, "<br>\n");

/* show error rate during capture, or blank line */
        if (CAP_NONE != cap_now) {
                double erate;
                erate = 100.0 * (double) pkt.errors / (double) pkt.count;
                ec = c2;

/* red is over 1% yellow is over .5 % bad */
                if (erate > 0.5) ec = c3;
                if (erate > 1.0) ec = c1;

/* show errors if doing capture */
                if ( (pkt.errors > 0) && (cap_chan == s->chan) ) {
                        fprintf( wf, "Err: ");
                        fprintf( wf, "<%s %s %s>\n", f, h2, ec);
                        fprintf( wf, "%4.2f%% (%d)", erate, pkt.errors);
                        fprintf( wf, "</%s>", f);
                        fprintf( wf, "<br>\n");
                } else {
/* no errors gets a blank line */
                        fprintf( wf, "<br>\n");
                }
        } else {
                fprintf( wf, "<br>\n");
        }


/* other buttons may be variable, put them to right of signal graph */
#ifdef USE_PNG
/*      if (CAP_NONE != cap_now) */ /* no, show the signal graph always */
        {
                char ni[16];
                snprintf( ni, sizeof(ni), "%d-%02d.png", arg_devnum, s->chan);
                fprintf( wf, IMG_FMT,
                        "SIGNAL", ni, SIG_PNG_W, SIG_PNG_H, 4, 3, 1);
                fprintf( wf, "\n");
        }
#endif


/* NOTE: these hrefs appear when not capturing */

/* cgi reload (info cap) href img if no capture */
        if (CAP_NONE == cap_now) {
                fprintf( wf, "<a href=\042/pg/%02d.html?g=%d\042>",
                        s->chan, s->chan);
                fprintf( wf, IMG_FMT, 
                        "EPG", "img/epgon.png", 48, 48, 4, 4, 0);
                fprintf( wf, "</a>\n");
        } else {
/* cgi only info cap gets zap? full cap could use it too */
                if ((CAP_INFO == cap_now) && (s->chan == cap_chan)) {
                        fprintf( wf, "<a href=\042%02d.html?x=%d\042>",
                                s->chan, s->chan);
                        fprintf( wf, IMG_FMT,
                                "ZAP", "img/epgoff.png", 48, 48, 4, 4, 0);
                        fprintf( wf, "</a>\n");
                }
        }

/* signal scan toggle href and img */
#if 1
        if (CAP_NONE == cap_now) {

/* not scanning or not same channel gets scan enable button */
            if ( (0 == scan_sig) || (s->chan != cap_chan) )
            {
                fprintf( wf, "<a href=\042%02d.html?v=%d\042>",
                        s->chan, s->chan );
                fprintf( wf, IMG_FMT, 
                        "SCAN", "img/scanon.png", 48, 48, 4, 4, 0);
                fprintf( wf, "</a>\n");
            } else {

/* is scanning and is same channel gets signal scan disable button */
/* TESTME: have to click it twice to turn it off if not same channel? */
                fprintf( wf, "<a href=\042%02d.html?v=%d\042>",
                        s->chan, s->chan );
                fprintf( wf, IMG_FMT, 
                        "SCAN", "img/scanoff.png", 48, 48, 4, 4, 0);
                fprintf( wf, "</a>\n");
            
            }
        }

/* no, let user agent table render decide where it goes */
/*      fprintf( wf, "<br>\n"); */
#endif

#ifdef USE_EPG_MANUAL
/* weekday manual timer entry href, new page, not done yet */
        fprintf( wf, "<a href=\042WD.html\042>" );
        fprintf( wf, IMG_FMT, "WD", "img/wd.png", 48, 48, 4, 4, 0);
        fprintf( wf, "</a>\n");

/* manual capture. does not work yet. is placeholder */
        if (CAP_NONE == cap_now) {
                fprintf( wf, "<a href=\042%02d.html?m=1\042>",
                        s->chan );
                fprintf( wf, IMG_FMT, 
                        "MANUAL", "img/capall.png", 48, 48, 4, 4, 0);
                fprintf( wf, "</a>\n");
        } else {
                if ((CAP_USER == cap_now) && (s->chan == cap_chan)) {

/* is scanning and is same channel gets signal scan disable button */
/* TESTME: have to click it twice to turn it off if not same channel? */
                    fprintf( wf, "<a href=\042%02d.html?m=0\042>",
                        s->chan );
                    fprintf( wf, IMG_FMT, 
                        "STOP", "img/capoff.png", 48, 48, 4, 4, 0);
                    fprintf( wf, "</a>\n");
                }
        }

/* manual capture of first vc, doesn't work yet */
        if (CAP_NONE == cap_now) {
                fprintf( wf, "<a href=\042%02d.html?n=1\042>",
                        s->chan );
                fprintf( wf, IMG_FMT, 
                        "CAPVCX", "img/capvc0.png", 48, 48, 4, 4, 0);
                fprintf( wf, "</a>\n");
        } else {
                if ((CAP_USER == cap_now) && (s->chan == cap_chan)) {

/* is scanning and is same channel gets signal scan disable button */
/* TESTME: have to click it twice to turn it off if not same channel? */
                    fprintf( wf, "<a href=\042%02d.html?n=0\042>",
                        s->chan );
                    fprintf( wf, IMG_FMT, 
                        "STOP", "img/capoff.png", 48, 48, 4, 4, 0);
                    fprintf( wf, "</a>\n");
                }
        }
#endif

/************************************************************* HTML3 legend */
        fprintf( wf, "<br clear=\042%s\042>\n", "both");
        fprintf( wf, "<a href=\042%02d.html?l=1\042>", s->chan);
        fprintf( wf, "%s", (0 == web_legend) ? "Help":"HELP");
        fprintf( wf, "</a> " NBSP "\n");

#if 0
        for (i = 0; i < SGML_FMT; i++ ) {
                j = 0;
                if (use_css != i) j = 1;
                fprintf( wf,
                        "<a href=\042/pg/%02d.html?f=%d\042>", s->chan, i);
                fprintf( wf, "%s", sgmls[ (i * 2) + j ] );
                fprintf( wf, "</a> \n");
        }
#endif
        fprintf( wf, "<a href=\042/pg/%02d.html?f=%d\042>%s</a>\n",
                 s->chan, 1, "CSS");

/* current event status and description */
        fprintf( wf, TD_FMT, "top", "50%");

        fprintf( wf, "<p>\n");
        fprintf( wf, "<%s %s %s>\n", f, h3, c5);
        fprintf( wf, "Current:\n");
        fprintf( wf, "</%s>\n", f );

/* walk epg list to find first program that is current */
        j = -1;
        e1 = NULL;
        for (i = 0; i < PGZ; i++){
            e1 = &e[i];
            if (0 == *e1->name) continue; /* skip blanks */
            if ( (utsnow >= e1->st) && (utsnow < (e1->st + e1->ls)) ) {
                j = i;
                break;
            }
        }

/* show current event time status too
   denoted as mm:ssr for remaining
*/
        if (-1 < j) {
            time_t utr;
            struct tm e1tm;

            utr = e1->st;
            localtime_r( &utr, &e1tm );

            utr += e1->ls;
            utr -= utsnow;      /* seconds remaining */

/* old style
            fprintf( wf, "%02d:%02d %dm %dr",
                (int)e1tm.tm_hour, (int)e1tm.tm_min, e1->ls/60, (int)utr/60);
*/
            fprintf( wf, "%02d:%02d left\n", (int)utr / 60, (int)utr % 60);
        }

        fprintf( wf, "<br>\n");

/* first current event found? */
        if (-1 < j) {
            fprintf( wf, "<%s %s %s>%s</%s><br>\n",
                         f, h3, c7, e1->name, f );

/* current event description not blank? */
            if (0 != *e1->desc) {

/* KTRK ABC fix
   description same as name is considered blank description
*/
                if (0 != strncasecmp( e1->name, e1->desc, strlen(e1->desc)) )
                {
                    char ed[PDZ];
                    astrncpy( ed, e1->desc, PDZ );
                    ed[255] = 0;
                    fprintf( wf, "<%s %s %s>%s </%s>\n",
                                f, h2, c7, ed, f );
                }
            } /* description blank doesn't generate html */
        } else {

/* no current event found (guide is blank or out of date) */
                fprintf( wf, "<%s %s %s>%s </%s>\n", f, h3, c1, "NONE", f );
                fprintf( wf, "<br>\n");

/* show pgm fail reason too, if any. middle box gets capture fail reason */
                pf = p->fail; /* shut up gcc "array subscript is char" */
                fprintf( wf, "<%s %s %s>Status: %s</%s>\n",
                            f, h3, c1, epg_fails[ pf ], f );

/* show atsc psip status if it has been checked from any capture */
                fprintf( wf, "<br>\n");
                if (0 == s->psip) fprintf( wf, "No ATSC PSIP Loaded");
                if (0 != s->psip) fprintf( wf, "PSIP has: ");
                if ( 1 & s->psip) fprintf( wf, "MGT ");
                if ( 2 & s->psip) fprintf( wf, "VCT ");
                if ( 4 & s->psip) fprintf( wf, "EIT ");
                if ( 8 & s->psip) fprintf( wf, "ETT ");
                if (16 & s->psip) fprintf( wf, "RRT ");
        }

        fprintf( wf, "</tr>\n");
        fprintf( wf, "</table>\n");
        fprintf( wf, "</table>\n");

/*      fprintf( wf, "<br clear=\042%s\042>\n", "left"); */

#define USE_LEGEND
#ifdef USE_LEGEND
/* NOTE:
        The legend is displayed here to fill browser cache with images.
        Image matches in the rest of the page should come from browser cache.
        The legend can be turned off to cut down the browser clutter,
        but it may impact performance if the images are not loaded.
 */
/* if legend enabled, show it */
        if (0 != web_legend) {
        
        fprintf( wf, "<hr>\n");

            fprintf( wf, TBL_FMT, TBL_BRD, 0, 2, "center", "66%");


/* row of event control imgs and text */
            fprintf( wf, "<tr>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "EPG", "img/epgon.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "EPG");
            fprintf( wf, "</font>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "SIG", "img/scanon.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Sig");
            fprintf( wf, "</font>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "JUNK+", "img/spamadd.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Junk+");
            fprintf( wf, "</font>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "JUNK-", "img/spamdel.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Junk-");
            fprintf( wf, "</font>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "FIND+", "img/searchadd.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Find+");
            fprintf( wf, "</font>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "FIND-", "img/searchdel.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Find-");
            fprintf( wf, "</font>\n");

/* row of timer control imgs and text */
            fprintf( wf, "<tr>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "ADD", "img/timeradd.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Add");
            fprintf( wf, "</font>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "DEL", "img/timerdel.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Del");
            fprintf( wf, "</font>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "LOG", "img/log24.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Log");
            fprintf( wf, "</font>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "STOP", "img/timerstop.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Stop");
            fprintf( wf, "</font>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "ZAP", "img/zap24.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Zap");
            fprintf( wf, "</font>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, IMG_FMT "\n", "CUT", "img/edit24.png", 24, 24, 0, 0, 0);
            fprintf( wf, FN_FMT, f, h1, c7, "Edit");
            fprintf( wf, "</font>\n");

/* row of color legends for event namess. At bottom so vspace looks OK. */
            fprintf( wf, "<tr>\n");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, FN_FMT, f, h1, c4, "Junk </font>");
        
            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, FN_FMT, f, h1, c6, "Old </font>");
            
            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, FN_FMT, f, h1, c7, "Now </font>");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, FN_FMT, f, h1, c2, "Later </font>");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, FN_FMT, f, h1, c3, "Timer </font>");

            fprintf( wf, TD_FMT, "top", "16%");
            fprintf( wf, FN_FMT, f, h1, c3, "<i>Capture</i> </font>");

            fprintf( wf, "</table>\n");

/* huh? why is this here? */
//          fprintf( wf, FN_FMT, f, h3, c7, "<center> </center>");
        }

/* end of legend table */
#endif

/* cgi */

/* if no epg available, create this as stub page for user to try later */
        if (0 == p->idx) {
                if (NULL != gf) { fflush( gf ); fclose( gf ); }
                if (NULL != df) { fflush( df ); fclose( df ); }
                if (NULL != wf) {
                        fprintf( wf, "<hr>");
                        fprintf( wf, "<center>");
                        fprintf( wf, "<b>");
                        fprintf( wf, "No Events");
                        if (0 != p->find) fprintf( wf, " Found");
                        fprintf( wf, "</b>");
                        fprintf( wf, "</center>");
                        fprintf( wf, "<hr>\n");
                        fprintf( wf, "\n</body>\n");
                        fprintf( wf, "</html>\n");
                        fflush( wf );
                        fclose( wf );
                }
                return;
        }

/* first event, day of year and day of week */
        st = e[ pgx[0] ].st;
        localtime_r( &st, &stm );
        sdn = stm.tm_yday;              /* start day of year */
        sdw = stm.tm_wday;              /* start day of week */

/*      lpn = e[ pgx[0] ].pn; */ /* don't know if there is one yet */
        lpn = 0;
        ldn = -1;
        nde = 0;
        pvc = 0;
    
/* find number of programs and days in guide */
        for (j = 0; j < p->idx; j++) {

/* unless event list is empty will always add +1 */
                if (lpn != e[ pgx[ j ]].pn) {
                        pv[ pvc ] = e[ pgx[ j ]].pn;
                        advrlog( LOG_INFO, "%s.%d pn %d",
                                 s->sid, pvc+1, pv[pvc] );
                        pvc++;
                }
                lpn = e[ pgx[ j ]].pn;

/* after first program change, keep counting programs, but not days */
                if (pvc > 1) continue;

/* count days until first program # change */
                st = e[ pgx[j] ].st;
                localtime_r( &st, &stm );

/* unless event list is empty will always add +1 */
                if (ldn != stm.tm_yday) {
/*                      advrlog( LOG_INFO, "day %d", stm.tm_yday); */
                        nd[ nde ] = stm.tm_yday;
                        nde++;
                }
                ldn = stm.tm_yday;
        }

        advrlog( LOG_INFO, "EPG%02d has ncs %d, days %d, events %d",
                p->chan, pvc, nde, p->idx );

        if ( (pvc >= VCZ) || (nde > 17) ) {
    
                if (pvc >= VCZ)
                        dvrlog( LOG_INFO, "%s ch %d invalid pvc %d idx %d",
                                WHO, p->chan, pvc, p->idx);
                if (nde > 17)
                        dvrlog( LOG_INFO, "%s ch %d invalid nde %d idx %d",
                                WHO, p->chan, nde, p->idx);

                if (NULL != wf) fclose( wf );
                if (NULL != df) fclose( df );
                if (NULL != gf) fclose( gf );
                return;
        }
        advrlog( LOG_INFO, "%s ch %d pgms %d days %d",
                WHO, p->chan, pvc, nde);

        ldn = -1;
        lpn = -1;

/* use long day names if guide has less than one week of data */
        if (nde < 8) {
                wd[0] = wdl[0];
                wd[1] = wdl[1];
                wd[2] = wdl[2];
                wd[3] = wdl[3];
                wd[4] = wdl[4];
                wd[5] = wdl[5];
                wd[6] = wdl[6];
        } else {

/* want 16 days and 2 pgms to fit in 960 pixel wide browser window */
                wd[0] = wds[0];
                wd[1] = wds[1];
                wd[2] = wds[2];
                wd[3] = wds[3];
                wd[4] = wds[4];
                wd[5] = wds[5];
                wd[6] = wds[6];
        }

// validator doesn't like this
//      fprintf( wf, "<%s %s>", f, c7);

/*  Sorted in vc order by placement algorithm in parse eit.
    Should also be sorted by eit number within vc with sort eit, KRIV/FOX fix
*/

/* es is event status bits for this event (used by html, rest don't care):
      1 is spam
      2 is aged
      4 is now
      8 is movie
     16 has timer
     32 has image
     64 has log
    128 has ts
    256 has search timer entry
    512 has been modified recently

The design objective is for a functional but not superfluous web interface:
    href imgs are drawn after the eventname/time, reduced to fewest sensible.
    Left-most icon least destructive to capture, right-most is scrap all bits.

        Spam does not change capture status so it goes first.

        Searchadd/searchdel does change timer and capture status but no delete.

        Log does not change capture status.

        Timeradd/timerdel changes capture status but does not delete capture.

        Zap deletes whatever it can find that matches that event.
        Zap is at far right to reduce mouse-fumble. [larger hspace needed?]
        Zap is also at far right in capture directory index.html.
        Zap is disabled if no matching timer found and file < 30s old
*/

    for (k = 0; k < p->idx; k++) {              /* fewer loops than E*P*V */
        char a;
        char *et = "";                          /* event status text */
        char *jf = "";                          /* spam add or del png */
        char *efz = "";                         /* eventname font size */
        char *enc = c7;
        char wh[256];                           /* web haystack */
        char sn[256];                           /* stat name */
        char tr[256];                           /* timer request string */
        int es;                                 /* event status bits */
        int dd;                                 /* event day diff from now */
        int iz = 24;                            /* image size, 16 or 24 */

#ifdef USE_EPG_SLEEP
/* TESTME: try to reduce cpu load on guide write, tweak this value lower? */
        struct timespec ns = { 0,1 };           /* short delay */
        nanosleep( &ns, NULL);
#endif
        ename = "";                     /* full eventname ptr */
        edesc = "";                     /* full event desc ptr */

        ec = "";
        es = 0;
        i = pgx[ k ];

        e1 = &e[ i ];

/* this should never display if build pg epg worked */
        if ( letmid == e1->etmid ) {
            dvrlog( LOG_INFO, "%s %s is duplicate", WHO, n);
            continue; /* skip duplicate */
        }

        letmid = e1->etmid;

/* TODO: these could be moved to build_pg_epg */
/* skip blank or ntsc or invalid pgm# entries */
        astrncpy( n, e1->name, PNZ );

/* this should never display if build pg epg worked */
        if ( (e1->pn < 1)
          || (e1->pn > 65534)
          || (0 == *n) ) {
                advrlog( LOG_INFO, "%s %s is invalid", WHO, n);
                continue;
        }

/* spam coloration and font size redux */
        efz = h4;                               /* event font size */


        if (E_SPAM & es) iz = 16;               /* image size */

/* age coloration and font size */
        if ( e1->st + e1->ls < utsnow ) {
                es |= E_AGED;                   /* aged is nz */
                efz = h3;                       /* spam font is h1 */
        }

/* this should never display if build pg epg worked */
        if (0 != p->hide) {
                if (E_SPAM & es) {
                        advrlog( LOG_INFO, "%s %s is spam", WHO, n);
                        continue;               /* skip spam */
                }
        }

/* this should never display if build pg epg worked */
        if (0 != p->age) {
                if (E_AGED & es) {
                        advrlog( LOG_INFO, "%s %s is aged", WHO, n);
                        continue; /* skip aged */
                }
        }

        if ( test_spam_event(e1) >= 0 ) {
                es |= E_SPAM;                   /* spam is nz */
                efz = h1;                       /* spam font is smaller */
        }


/* current overrides */
        if ( ( utsnow < e1->st + e1->ls )
          && ( utsnow >= e1->st) )
                    es |= E_NOW;                /* current is nz */

        if (0 != e1->movie) es |= E_MOVIE;

/* check for event on timer list */
        tpg = find_timer_epg( e1 );
        if (-1 < tpg) es |= E_TIME;             /* has timer is nz */

        ec = c2;                                /* future green */
        if (es > 0) {
                if (E_SPAM & es) ec = c4;       /* spam grey */
                if (E_AGED & es) ec = c6;       /* aged magenta */
                if (E_NOW  & es) ec = c7;       /* current white */
                if (E_TIME & es) ec = c3;       /* timer yellow */
        }

        pn = e1->pn;
        st = e1->st;
        localtime_r( &st, &stm );
        asctime_r( &stm, dt);


        n[42] = 0;

/*      strftime( w, sizeof(w)-1, "%A", &stm); */

        cdn = stm.tm_yday;
        cdw = stm.tm_wday;

/* IDEA: image map for weekdays? problem is: variable browser resolution */
/* if program number or day number changes, put up some navigation help */
/* Prime time division check not done here but needs pt href here */
        if ( (pn != lpn) || (cdn != ldn) ) { /* || (td != ltd)) */

/* show TOP, pgms (if > 1), and days (if > 1) */

/* validator doesn't like two id same. 1st center cancelled. is placeholder */
                if (pn != lpn)
                    fprintf( wf, "<center id=\042pgm%d\042></center>\n", pn );
                fprintf( wf, "<center>\n");

                fprintf( wf, "<hr id=\042pgm%dday%d\042 />\n", pn, cdn );
/* fat space after top */
                fprintf( wf, "<a href=\042#top\042>%s %s</a>",
                            "TOP", NBSP);
/* fat space after primetime href */
                fprintf( wf, "<a href=\042#pgm%dpt%d\042>PT %s</a>",
                            pn, cdn, NBSP);

/* show virtual channel sid + minor program nav hrefs if more than one */
                if (pvc > 1) {
                    fprintf( wf, "| %s ", NBSP );
                    for (j = 0; j < pvc; j++) {
                        a = ~0;

/* current program does not get href */
                        if (pn == pv[ j ]) a = 0;
                        if (0 != a)
                            fprintf( wf, "<a href=\042#pgm%d\042>", pv[j]);

                        fprintf( wf, "%s.%d ", s->sid, pv[j] );

                        if (0 != a)
                            fprintf( wf, "</a>\n");
                    }
/* fat space at end of list */
                    fprintf( wf, " %s ", NBSP);
                }
/* show guide day nav hrefs if more than one day in guide */
                if (nde > 1) fprintf( wf, "| %s ", NBSP);
                for (j = 0; j < nde; j++) {
                    a = ~0;

/* current day does not get href */
                    if (cdn == nd[j]) a = 0;

                    if (0 != a) 
                        fprintf( wf, "<a href=\042#pgm%dday%d\042>",
                                     pn, nd[j] );

/* weekday index does not reset at end of year */
                    fprintf( wf, "%s ", wd[ (sdw + j) % 7 ] );

                    if (0 != a) fprintf( wf, "</a>\n" );
                }

// DELETEME: doesn't need an end glyph?
/*              if (nde > 1) fprintf( wf, "| "); */

                fprintf( wf, "</center>\n");
                fprintf( wf, "<hr>\n");
        }

/* draw primetime line at first timeslot starting at 7pm or later */
        if (stm.tm_hour >= 19) {
            if (ptd != cdn) {
                int vcn;
                vcn = find_vc_pgm( pn, WHO );
                fprintf( wf, "<hr id=\042pgm%dpt%d\042 />\n", pn, cdn);
/*
                fprintf( wf, "<center>Prime Time %s %s.%d</center><hr>\n",
                            wdl[cdw], s->sid, vcn + 1 );
*/
                fprintf( wf, "<center>Prime Time %s %s.%d</center>\n",
                            wdl[cdw], s->sid, pn );
                fprintf( wf, "<hr />\n");
                ptd = cdn;
            }
        }

        lpn = pn;
        ldn = cdn;


/* TAB separated for easy loading into SQL tables */
/* always 5 separators, char TAB does not occur in ATSC */
/* start time is unsigned int for now */
        if (NULL != df)
            fprintf( df, "%d\t%d\t%u\t%d\t\042%s\042\t",
                p->chan, pn, e1->st, e1->ls, e1->name );
            
/* by the time you get here, e1-> should have one of the allowed events */
/* event description is blanked if same as eventname or n/a, rating too */
        ename = e1->name;
        edesc = e1->desc;

        if (0 != *edesc)
            if ( 0 == strncasecmp( ename, edesc, strlen(edesc)) )
                edesc = "";

/* if desc not blank, add it to text and database files */
        if (0 != *edesc) {

/* Do not forget space at end for last word to wrap
    first line moved out to be staggered from title
    2nd and more lines of description get one more char indent
*/

/* NOTE: There is a variable space issue here. pad below "" at will, but
    realize anything decreasing description width will increase line count
    in the word wrap with indent scenario versus usual word wrap giving
    a decrease in the number of lines required.
*/

/* "" should be name bytes long or fixed at 20 spaces with trunc eventname */

                snprintf( t, sizeof( t )-1, "                         "
                            "|  %s ", e1->desc );

                word_wrap_indent( gf, t ); /* text file */
                snprintf( t, sizeof(t)-1, "\042%s\042", e1->desc );
                if (NULL != df)
                    fprintf( df, "%s", t);  /* sql table */
        }
        if (NULL != df)
            fprintf( df, "\n");

/* mangle name to two words */
        event_truncate( en, e1->name, 2, sizeof(en)-1 );
/* truncate en same as add from show program guide does */
        en[16] = 0;

        if (-1 < find_search_timer(en)) es |= E_FIND;

/* FIXME: glob existing png to redux event pixmap check to memory */

/* generic movie image file if it exists */
        snprintf( wh, sizeof(wh), "%s%spg/img/%s.png",
                    out_path, ram_path, en);
        if (E_MOVIE & es)
                snprintf( wh, sizeof(wh), "%s%spg/img/movie.png",
                            out_path, ram_path);

        ok = stat64( wh, &fs );
        advrlog( LOG_INFO, "dump epg stat %d %s", ok, wh);

/* build image href if pixmap available */
        if (0 == ok) {
                es |= E_IMG;            /* event image exists */
/*              advrlog( LOG_INFO, "dump epg found %s", wh); */

/* make file name for event pixmap */
                snprintf( wh, sizeof(wh), "img/%s.png", en);
                if (E_MOVIE & es)
                    snprintf( wh, sizeof(wh), "img/movie.png");
                advrlog( LOG_INFO, "dump epg using %s", wh);
        }


/* if .html file available, set flag for log href */
        snprintf( ln, sizeof(ln)-1, "%s%s-%02d%02d-%02d%02d.%d.html",
                        out_path, en, stm.tm_mon+1, stm.tm_mday,
                        stm.tm_hour, stm.tm_min, e1->pn );
        ok = stat64( ln, &fs );
        if (0 == ok) es |= E_LOG;

/* if .ts file available, set flag for ts href img video.png
    and also href for unlink
 */
        ok = test_ts_file( sn, en, e1, &fs );
        if (0 == ok) {
            es |= E_TS;
            ec = c3;
/* 3s past last mod? */
            if (fs.st_mtime < (utsnow - 3)) es |= E_MTX;
        }

/* see http help at top for configuring mozilla to handle mpeg://url */
/* don't relative href this because player might need the specific port#? */
        if (E_TS & es) fprintf( wf, "<a href=\042mpeg://%s:%d/%s\042>",
                                "dtv", arg_wport, &sn[strlen(out_path)] );
/* if image exists, make it same href as eventname has, the .ts file */
        if (E_IMG & es)
                fprintf( wf, "<img "
                                "src=\042%s\042 "
                                "alt=\042%s\042 "
                                "align=\042%s\042 "
                                "width=%d "
                                "height=%d "
                                "hspace=%d "
                                "vspace=%d>\n",
                                        wh, en, "left", 160, 90, 8, 8);
        if (E_TS & es) fprintf( wf, "</a>\n");
        enc = ec;

/* removed line break after event name
        fprintf( wf, "<br>\n");
*/
        ec = c7;
        if (E_SPAM & es) ec = c4;       /* spam gets time as low light */
        if (E_TS & es) ec = c3;         /* yellow for captures */

/* event time */
/* strategy:
        today shows time only.
        within a week shows day and time only
        outside of a week shows day date time
        outside of 16 days shows day date year time
*/
        dd = abs(e1->st - utsnow);      /* day diff */
        dd /= 86400;                    /* seconds to days */

/* time only, same day meridian check */
        if (0 == dd) {

/* same day meridian? */
            if (stm.tm_yday == tloc.tm_yday) { /* tloc is utsnow */
                fprintf( wf, "<%s %s %s> %02d:%02d %dm </font>\n",
                        f, h3, ec, stm.tm_hour, stm.tm_min,
                        e1->ls/60 );
            } else {
                dd = 1;         /* not same day */
            }
        }

/* TODO: end of month/year shows new month/year */

/* day and time only, same as above for 1-6 days, 0 is today */
        if ((dd > 0) && (dd < 6))
                fprintf( wf, "<%s %s %s> %s %02d:%02d %dm </font>\n",
                        f, h3, ec,
                        wds[ stm.tm_wday ], stm.tm_hour, stm.tm_min,
                        e1->ls/60 );

/* day date time for 7-16 days */
        if ((dd > 5) && (dd < 17)) {
                dt[16] = 0;             /* don't need seconds, yet... */
                fprintf( wf, "<%s %s %s> %s %dm </font>\n",
                        f, h3, ec, dt, e1->ls/60 );
        }

/* day date time year for more than 16 day diff, shows stale epg full date */
        if (dd >16)
                fprintf( wf, "<%s %s %s> %s %dm </font>\n",
                        f, h3, ec, dt, e1->ls/60 );

/* regent dt again but truncate seconds + year for text file output */
        asctime_r( &stm, dt);
        dt[16] = 0; /* truncate time before seconds */
        if (NULL != gf)
            fprintf( gf, "\n%d %s %4dm | %s", pn, dt, e1->ls/60, n );


/* give small description of status */
        et = "";

        if (E_SPAM & es)
        {
            et = "JUNK";
            ec = c4;
        }

        if (E_AGED & es)
        {
            et = "AGED";
            ec = c6;
        }

        if ( (E_AGED | E_SPAM) == ((E_AGED | E_SPAM) & es) )
        {
            et = "AGED JUNK";
            ec = c4;
        }

        if (E_NOW & es)
        {
            et = "NOW";
            ec = c7;
        }

        if ((E_SPAM | E_NOW) == ((E_SPAM | E_AGED | E_NOW) & es))
        {
            et = "NOW JUNK";
            ec = c7;
        }

#if 0
/* icon and aged is enough? */
        if (E_MOVIE & es) {
            et = "MOVIE";
            ec = c2;
        }

        if ((E_MOVIE | E_AGED) == ((E_SPAM | E_AGED | E_NOW | E_MOVIE) & es))
        {
            et = "AGED MOVIE";
            ec = c6;
        }
#endif
        if (E_FIND & es)
        {
            ec = c3;
        }

        fprintf( wf, "<%s %s %s>%s </font>\n",
                        f, h1, ec, et);

/* no spam href for search */
/* hmm, below it says non-spam does the search toggle */
/* haven't run out of bits in es yet, could add search bit */

/* spam list add/remove toggle */
        jf = "img/spamadd.png";
        if (E_SPAM & es) {
                jf = "img/spamdel.png";
        }

        fprintf( wf, "<a href=\042%02d.html?j=%s:%u\042>",
                s->chan, en, e1->st);

        fprintf( wf, IMG_FMT,
                (E_SPAM & es) ? "JUNK-":"JUNK+", jf, iz, iz, 4, 4, 0 );

        fprintf( wf, "</a>\n");

/* search href img */
        if (0 == (E_SPAM & es)) { /* non spam gets search toggle */
                char *spn = "img/searchadd.png";

                if (E_FIND & es) spn = "img/searchdel.png";
                fprintf( wf, "<a href=\042%02d.html?s=%02d:%s\042>",
                        s->chan, s->chan, en);
                fprintf( wf, IMG_FMT, "SEARCH", spn, 24, 24, 4, 4, 0 );
                fprintf( wf, "</a>\n");
        }
/* timer request, format matches config file */
        snprintf( tr, sizeof(tr)-1, "V%02d:%u:%03d:%s@.%d:%d",
                        s->chan, e1->st, e1->ls/60, en, pn, e1->etmid );

/* capture log href img */
        if (E_LOG & es) {
/* see http at bottom for configuring mozilla to handle mpeg://url */
                fprintf( wf,"<a href=\042/%s\042>", &ln[strlen(out_path)] );

                fprintf( wf, IMG_FMT, "LOG", "img/log24.png", iz, iz, 4, 4, 0);
                fprintf( wf, "</a>\n");
        }

/* timer remove href img, if event on timer list */
        if (E_TIME & es) {

/* not [spam, ] aged, current, nor search: timer gets timer delete img */
/*              if (0 == ((E_SPAM | E_AGED | E_NOW | E_FIND) & es)) { */
                if (0 == ((E_AGED | E_NOW | E_FIND) & es)) {
/* cgi */
                    fprintf( wf, "<a href=\042%02d.html?d=%s\042>",
                            s->chan, tr );

                    fprintf( wf, IMG_FMT,
                            "DEL", "img/timerdel.png", iz, iz, 4, 4, 0 );
                    fprintf( wf, "</a>\n");
                }

/* current timer gets timer stop */
                if (E_NOW & es) {
                        fprintf( wf,
                            "<a href=\042%02d.html?d=%s\042>",
                                s->chan, tr );

                        fprintf( wf, IMG_FMT, 
                                "DEL", "img/timerstop.png", iz, iz, 4, 4, 0);
                        fprintf( wf, "</a>\n");
                }

/* event is user settable for future, gets face-on clock img */
                if (0 == (E_TIME & es)) {
                    fprintf( wf, "<a href=\042%02d.html?d=%s\042>",
                            s->chan, tr );

                    fprintf( wf, IMG_FMT,
                            "DEL", "img/timerclk.png", iz, iz, 4, 4, 0);
                    fprintf( wf, "</a>\n");
                }
/* user settable for not future is clock turned off from facing */

        } else {

/* timer add href img */
                if (0 == (E_AGED & es)) { /* aged does not need timer add href */

/* spamlist cap image smaller for adjacent spam to use fewer vertical pixels */
/* trash can is smaller too. but log and zap could be smaller too */

/* cgi */
/* FIXME: same ip/port concerns as above */
                    fprintf( wf, "<a href=\042%02d.html?a=%s\042>",
                            s->chan, tr );

                    fprintf( wf, IMG_FMT, 
                            "ADD", "img/timeradd.png", iz, iz, 4, 4, 0 );
                    fprintf( wf, "</a>\n");
                }
        }

/* TODO: if aged, it gets the file name, if current it gets the timer name */
/* zap only for current event, may try to reuse as file delete too */
        if ((E_TS | E_NOW | E_TIME) == ((E_TS | E_NOW | E_TIME) & es)) {
                fprintf( wf, "<a href=\042%02d.html?z=%s\042>",
                            s->chan, tr );
                fprintf( wf, IMG_FMT, "ZAP", "img/zap24.png", iz, iz, 4, 4, 0);
                fprintf( wf, "</a>\n");
        }

#if 0
/* deciding not to use this for now because it confuses ?u= function */
/* u= unlink filename, same img as timer zap, need diff color? */
        if (E_TS & es) {
/* mod time expired? */
            if (E_MTX & es) {
/* sometimes you want to delete a near current cap */
                if ((E_AGED & es) || (CAP_NONE == cap_now))
                {
                    char un[256];
                    filebase( un, sn, F_FILE );
                    fprintf( wf, "<a href=\042%02d.html?u=%02d:%s\042>",
                            s->chan, s->chan, un );
                    fprintf( wf, IMG_FMT,
                            "UNLINK", "img/unlink.png", iz, iz, 4, 4, 0 );
                    fprintf( wf, "</a>\n");
                }
            }
        }
#endif

#if 0
/* secondary media player icon, not done but is very easy to do */
        if (E_TS & es) {
/* see http at bottom for configuring mozilla to handle mpeg://url */

/* like the xine href above, this one should keep ip and port#, not relative */
                fprintf( wf, "<a href=\042mplayer://%s:%d/%s\042>",
                        "dtv", arg_wport, &sn[strlen(out_path)] );
/* FIXME? mpeg://dtv has dtv as default host */
                fprintf( wf, IMG_FMT, 
                        "LOG", "img/video.png", iz, iz, 4, 4, 0 );
                fprintf( wf, "</a>\n");
        }
#endif
            

/* event name */
/* (different font and color possible) */
        if (E_TS & es)  fprintf( wf, "<a href=\042mpeg://%s:%d/%s\042>",
                                "dtv", arg_wport, &sn[strlen(out_path)] );
        fprintf( wf, "<%s %s %s> ", f, efz, enc);
        if (E_TS & es) fprintf( wf, "<i>");
        fprintf( wf, "%s ", n);
        if (E_TS & es) fprintf( wf, "</i>");
        fprintf( wf, "</%s>", f );
        if (E_TS & es) fprintf( wf, "</a>");
        fprintf( wf, "\n");



/* description color is white for readability even at small font sizes */
        ec = c7;

        fprintf( wf, "<br>\n");

/* spam always gets grey for all colors */
        if (E_SPAM & es) ec = c4;

/* image needs hspace="8" attribute or text is too near image */

        if ( 0 != *edesc ) {
/* event rating */
            if (0 != *e1->rating )
                fprintf( wf, "<%s %s %s>" "[%s] </font>\n",
                            f, h1, ec, e1->rating);
                fprintf( wf,"<%s %s %s>%s</%s>\n", f, h2, ec, edesc, f);

        }

/* <br> after possible no description or else image sits on next event */
        fprintf( wf, "<br clear=\042%s\042>\n", "left");
        if ( (strlen(edesc)>1) || (E_IMG & es) )
                fprintf( wf, "<br>\n"); /* runs together without this */

/* end of event loop */
    }

        advrlog( LOG_INFO, "%s %s writing footer", WHO, wn);

        for (i = 0; i < 16; i++) fprintf( wf, "<br>\n");
        fprintf( wf, "\n");
        fprintf( wf, "<hr>\n" );

        *h = 0;
        build_foot_html( h, sizeof(h), 1); /* validated */
        fprintf( wf, "%s", h );

        if (NULL != wf) {
            fflush( wf );
            fclose( wf );
        }

#ifdef USE_EXTRA_OUTPUT
        if (NULL != df) {
            fflush( df );
            fclose( df );
        }

/* text file */
        if (NULL != gf) fprintf( gf, "\n");
        if (NULL != gf) {
            fflush( gf );
            fclose( gf );
        }
#endif

        advrlog( LOG_INFO, "%s done", WHO);
}

/* static */
void
dump_epg_html ( struct event_s *e, struct pgm_s *p, short *pgx, char *caller )
{

        build_pg_epg( e, p, pgx, WHO);

/* can't do it? */
        if (p->idx >= PGZ) {
            dvrlog( LOG_INFO, "%s chan %02d has bad event index %d",
                    WHO, p->chan, p->idx);
            return;
        }

        if (0 == use_css) {
            dump_epg_html3( e, p, pgx, caller );
        } else {
            dump_epg_html4( e, p, pgx, caller );
        }
}

#define SIDZ "5%"
/* dump 3 hour grid starting at epg_gs */
void
dump_epg_grid_html4( void )
{
        FILE *f;
        struct event_s *e1;
        struct sig_s *s;
        unsigned int r, r1, r2;
        int c, i, j, k, ch, m, w, z, un, un1, es;
        char n[256], hr[256], *ir;
        char *d;
        time_t t;
        struct tm tt;
        
        z = 32768;
        d = icalloc( z, 1, "epg grid4" );

        epg4 = imalloc( sizeof( epg ), "http epg4");

/* 3 hour meridian */
        un = utsnow / SEC3HR;
        un *= SEC3HR;

/* 1 hour meridian */
        un1 = utsnow / SECHR;
        un1 *= SECHR;

        r1 = epg_gs;
        r1 /= SECHR;
        r1 *= SECHR;

/* epg_gs not set or trying to go back before the current EPG meridian */
        if (r1 < un) r1 = un;
        epg_gs = r1;

        r2 = (r1 + SEC3HR) - 1;
        m = 180;
        r = 1800 - (utsnow % 1800);

        *d = 0;
        build_head_html( d, z, 1, "EPG Grid", r, WHO );

        asnprintf(d, z, "<table border=0 width=\042%s\042>\n", "100%" );
        asnprintf(d, z, "<tr>\n");
        asnprintf(d, z, "<th width=\042%s\042>", SIDZ);

        if (r1 > un) {

                asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042>",
                        arg_devnum, r1 - 10800 );
                asnprintf(d, z, "%s", "&lt&lt" );
                asnprintf(d, z, "</a>\n");

                asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042>",
                        arg_devnum, r1 - 3600 );
                asnprintf(d, z, "%s", "&lt" );
                asnprintf(d, z, "</a>\n");

        }

        text_time( n, r1, 16 );
        t = (time_t) un1;
        localtime_r( &t, &tt );


        asnprintf(d, z, "<th width=\042%s\042>", "90%");

        asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042> %s </a>\n",
                        arg_devnum, un1, "Now" );

/* switch to HTML3 */
        asnprintf(d, z, "<a href=\042/pg/grid%d.html?f=0\042> %s </a>\n",
                            arg_devnum, "HTML");

        asnprintf(d, z, "%s \n", n);

        for (i = 0; i < 7; i++) {
            asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042> %s </a>\n",
                        arg_devnum,
                        un1 + (i * SECDAY),
                        days[ (i + tt.tm_wday) % 7]);
        }

/* next hour and next 3 hours */
        asnprintf(d, z, "<th width=\042%s\042>", SIDZ);
        asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042>",
                        arg_devnum, r1 + 3600 );
        asnprintf(d, z, "%s", "&gt" );
        asnprintf(d, z, "</a>\n");

        asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042>",
                        arg_devnum, r1 + 10800 );
        asnprintf(d, z, "%s", "&gt&gt" );
        asnprintf(d, z, "</a>\n");

        asnprintf(d, z, "</tr>\n");
        asnprintf(d, z, "</table>\n");


        asnprintf(d, z, "<table class=\042%s\042"
//                      " border=1 frame=box align=\042center\042"
//                      " cellspacing=0 cellpadding=3"
                        " width=\042%s\042>\n",
                            "ta_egs", "100%" );

        asnprintf(d, z, "<tr>\n");

/* SID */
        asnprintf(d, z, "<th class=\042%s\042 width=\042%s\042>SID\n",
                    "th_egs", SIDZ);

/* draw hh:mm legend at top */
        for (i = 0; i < SEC3HR; i+= 1800) {
            asnprintf(d, z, "<th class=\042%s\042 width=\042%d%%\042>",
                        "th_egs", 16 );

            t = (time_t) r1 + i;
            localtime_r(&t, &tloc4);
            asnprintf(d, z, "%02d:%02d\n", tloc4.tm_hour, tloc4.tm_min);
//          asnprintf(d, z, "<br>%d\n", r1 + i);
        }
        asnprintf(d, z, "</tr>\n");
        asnprintf(d, z, "</table>\n\n");

/* step through all channels and load the epg for each */
        for (i = 0; i < scan_idx; i++) {
                ch = scan_list[i];
                s = &ptc[ch].sig;

                memset(&pgm4, 0, sizeof(pgm4));
                pgm4.chan = ch;

                load_epg( ch, epg4, &pgm4, pg4, WHO );
                build_pg_epg( epg4, &pgm4, pg4, WHO );


/* cable might have a lot of blank channels. bad reception will be blank too,
   but it won't be blank if the guide is stale, even if no events in range
*/

/* broadcast shows all, cable shows only what is loaded from remote */
                if (0 != arg_cable)
                    if (0 == s->pgto)
                        continue;

                if (0 == pgm4.idx) continue;

                asnprintf(d, z, "<table class=\042%s\042"
//                              " border=1 frame=box"
//                              " cellspacing=0 cellpadding=3"
                                " width=\042%s\042>\n",
                                    "tb_egs", "100%");

                asnprintf(d, z, "<tr valign=\042%s\042>\n", "baseline");

/* s->sid 4% */
                asnprintf(d, z, "<th class=\042%s\042 width=\042%s\042>",
                            "th_egs", SIDZ );

                asnprintf(d, z, "<a href=\042/pg/%02d.html\042>%s\n",
                                ch, s->sid);

                asnprintf(d, z, "</a>\n");

                k = 96;

                for (j = 0; j < pgm4.idx; j++) {
                    e1 = &epg4[ pg4[ j ] ];
/* skip anything outside the range */
                    if (s->pn != e1->pn) continue;

//                  if ((e1->st + e1->ls) < un) continue;
                    if ((e1->st + e1->ls) < r1) continue;

                    if (e1->st > r2) continue;

                    r = e1->ls;
                    if (e1->st < r1) r = (e1->st + e1->ls) - r1;
                    r /= 60;
//                  if (r > m) continue;

//                  w = (100 * r) / m;
                    w = (96 * r) / m;
                    if (w > k) w = k;

/* skip expired events */
                    if (0 == w) continue;
                    if (w < 6) w = 6; /* 10m is smallest division */

                    k -= w;

                    es = test_event_status( e1 );
                    c = 7;
// cyan used for weekday timers, not automatic ones, they're green!
                    if (0 != (es & E_SPAM))  c = 0;     /* black   */
                    if (0 != (es & E_MOVIE)) c = 3;     /* blue    */
                    if (0 != (es & E_NOW))   c = 8;     /* white   */
                    if (0 != (es & E_TIME))  c = 2;     /* green   */
                    if (0 != (es & E_FIND))  c = 2;     /* green   */
/* aged will set on all old events except captures and cuts */
                    if (0 != (es & E_AGED))  c = 5;     /* magenta */
                    if (0 != (es & E_TS))    c = 6;     /* yellow  */
                    if (0 != (es & E_TSC))   c = 1;     /* red     */

                    ir = "";
                    *hr = 0;

                    if ( 0 == (es & ( E_SPAM | E_AGED)) ) {
                        if (0 == (es & E_TIME)) {
                            ir = "/pg/img/timeradd24.png";
/* timer request, format matches config file */
                            snprintf( hr, sizeof(hr)-1,
                                        "?a=V%02d:%u:%03d:%s@.%d:%d",
                                                s->chan, e1->st, e1->ls/60,
                                                e1->tname, e1->pn, e1->etmid );
                        } else {
                            ir = "/pg/img/timerdel24.png";
                            snprintf( hr, sizeof(hr)-1,
                                        "?d=V%02d:%u:%03d:%s@.%d:%d",
                                    s->chan, e1->st, e1->ls/60,
                                    e1->tname, e1->pn, e1->etmid );
                        }
                    }

                    asnprintf(d, z, "<td class=\042%s %s0\042"
                                    " width=\042%d%%\042>",
                                "td_egs", colors[c], w );

                    if (0 != *hr) {
                        asnprintf(d, z, "<a href=\042%s\042>", hr);
                        asnprintf(d, z, "<img class=\042%s\042"
                                        " src=\042%s\042>", "img_large", ir);
                        asnprintf(d, z, "</a>");
                    }

                    asnprintf(d, z, "%s", e1->name);

//                  asnprintf(d, z, "<br>r%d w%d%%", r, w); // debug
                    asnprintf(d, z, "\n");
                }

                if (96 == k) {
                    asnprintf(d, z, "<td class=\042%s\042 width=\042%d%%\042>",
                                "td_egs", 96 );
                    asnprintf(d, z, "n/a\n");
                } else {
                    if (0 != k) {
                        asnprintf(d, z,
                                "<td class=\042%s\042 width=\042%d%%\042>",
                                "td_egs", k );
                        asnprintf(d, z, "n/a\n");
//                      asnprintf(d, z, "%s\n", e1->name);
//                      asnprintf(d, z, "<br>r%d w%d%%", r, w); // debug
                    }
                }

                asnprintf(d, z, "</tr>\n");
                asnprintf(d, z, "</table>\n\n");
        }
    
        ifree( epg4, "http epg4" );

        build_foot_html4(d, z, 1); /* TODO: validate me */

        memset(n, 0, sizeof(n));

/* race condition for more than one user, use mutex to avoid */
        snprintf( n, sizeof(n)-1, "%s%s/pg/grid%d.html",
                    out_path, ram_path, arg_devnum);

        f = fopen( n, "w");
        if (NULL == f) return;

        fprintf( f, "%s\n", d);
        fflush(f);
        fclose(f);

        ifree(d, "epg grid4");
}

/* dump 3 hour grid starting at epg_gs */
void
dump_epg_grid_html3( void )
{
        FILE *f;
        struct event_s *e1;
        struct sig_s *s;
        unsigned int r, r1, r2;
        int c, i, j, k, ch, m, w, z, un, un1, es;
        char n[256], hr[256], *ir;
        char *d;
        time_t t;
        struct tm tt;   

        z = 32768;
        d = icalloc( z, 1, "epg grid3" );

        epg4 = imalloc( sizeof( epg ), "http epg4");

        un = utsnow / SEC3HR;
        un *= SEC3HR;

        un1 = utsnow / SECHR;
        un1 *= SECHR;

        r1 = epg_gs;
        r1 /= 3600;
        r1 *= 3600;

/* epg_gs not set or trying to go back before the current hour */
        if (r1 < un) r1 = un;
        epg_gs = r1;

        r2 = (r1 + SEC3HR) - 1;
        m = 180;
        r = 1800 - (utsnow % 1800);

        *d = 0;
        build_head_html( d, z, 1, "EPG Grid", r, WHO );

        asnprintf(d, z, "<table border=0"
                        " cellspacing=0 cellpadding=3"
                        " width=\042%s\042>\n",
                            "100%" );
        asnprintf(d, z, "<tr>\n");

        asnprintf(d, z, "<th width=\042%s\042>", SIDZ);

        if (r1 > un) {
                asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042>",
                        arg_devnum, r1 - 3600 );
                asnprintf(d, z, "%s", "&lt" );
                asnprintf(d, z, "</a>\n");

                asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042>",
                        arg_devnum, r1 - 10800 );
                asnprintf(d, z, "%s", "&lt&lt" );
                asnprintf(d, z, "</a>\n");

        }

        text_time(n, r1, 16);
        t = (time_t) un1;
        localtime_r( &t, &tt );

        asnprintf(d, z, "<th width=\042%s\042>", "90%");

        asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042> %s </a>\n",
                        arg_devnum, un1, "Now" );

        asnprintf(d, z, "<a href=\042/pg/grid%d.html?f=1\042> %s </a>\n",
                            arg_devnum, "CSS");
        asnprintf(d, z, "%s \n", n);

        for (i = 0; i < 7; i++) {
            asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042> %s </a>\n",
                        arg_devnum,
                        un1 + (i * SECDAY), 
                        days[ (i + tt.tm_wday) % 7]);
        }


        asnprintf(d, z, "<th width=\042%s\042>", SIDZ);
        asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042>",
                        arg_devnum, r1 + 3600 );
        asnprintf(d, z, "%s", "&gt" );
        asnprintf(d, z, "</a>\n");

        asnprintf(d, z, "<a href=\042/pg/grid%d.html?i=%d\042>",
                        arg_devnum, r1 + 10800 );
        asnprintf(d, z, "%s", "&gt&gt" );
        asnprintf(d, z, "</a>\n");

        asnprintf(d, z, "</tr>\n");
        asnprintf(d, z, "</table>\n");


        asnprintf(d, z, "<table border=1"
                        " cellspacing=0 cellpadding=3"
                        " width=\042%s\042>\n",
                            "100%" );

        asnprintf(d, z, "<tr>\n");

/* SID */
        asnprintf(d, z, "<th width=\042%s\042>SID\n", SIDZ );

/* draw hh:mm legend at top */
        for (i = 0; i < SEC3HR; i+= 1800) {
            asnprintf(d, z, "<th width=\042%d%%\042>", 16 );

            t = (time_t) r1 + i;
            localtime_r(&t, &tloc4);
            asnprintf(d, z, "%02d:%02d\n", tloc4.tm_hour, tloc4.tm_min);
//          asnprintf(d, z, "<br>%d\n", r1 + i);
        }
        asnprintf(d, z, "</tr>\n");
        asnprintf(d, z, "</table>\n\n");

/* step through all channels and load the epg for each */
        for (i = 0; i < scan_idx; i++) {
                ch = scan_list[i];
                s = &ptc[ch].sig;

                memset(&pgm4, 0, sizeof(pgm4));
                pgm4.chan = ch;

                load_epg( ch, epg4, &pgm4, pg4, WHO );
// don't filter, this grid needs to show current events
                build_pg_epg( epg4, &pgm4, pg4, WHO );


/* cable might have a lot of blank channels. bad reception will be blank too,
   but it won't be blank if the guide is stale, even if no events in range
*/
                if (0 == pgm4.idx) continue;

/* broadcast shows all, cable shows only what is loaded from remote */
                if (0 != arg_cable)
                    if (0 == s->pgto)
                        continue;

                asnprintf(d, z, "<table"
                                " border=1"
                                " cellspacing=0 cellpadding=3"
                                " width=\042%s\042>\n",
                                    "100%");

                asnprintf(d, z, "<tr valign=\042%s\042>\n", "top");

/* s->sid 4% */
                asnprintf(d, z, "<th width=\042%s\042>", SIDZ );

                asnprintf(d, z, "<a href=\042/pg/%02d.html\042>%s</a>\n",
                                ch, s->sid);

                k = 96;

                for (j = 0; j < pgm4.idx; j++) {
                    e1 = &epg4[ pg4[ j ] ];
/* skip anything outside the range */
                    if (s->pn != e1->pn) continue;

//                  if ((e1->st + e1->ls) < un) continue;
                    if ((e1->st + e1->ls) < r1) continue;

                    if (e1->st > r2) continue;

                    r = e1->ls;
                    if (e1->st < r1) r = (e1->st + e1->ls) - r1;
                    r /= 60;
                    if (r > m) continue;

//                  w = (100 * r) / m;
                    w = (96 * r) / m;
                    if (w > k) w = k;

/* skip expired events */
                    if (0 == w) continue;
                    if (w < 6) w = 6; /* 10m is smallest division */

                    k -= w;

/* set event text color */
                    es = test_event_status( e1 );
                    c = 2; /* green is not spam, no timer and not aged */
                    if (0 != (es & E_SPAM))  c = 4;     /* grey    */
                    if (0 != (es & E_MOVIE)) c = 5;     /* cyan    */
                    if (0 != (es & E_NOW))   c = 7;     /* white   */
                    if (0 != (es & E_TIME))  c = 3;     /* yellow  */
                    if (0 != (es & E_FIND))  c = 3;     /* yellow  */
/* aged will set on all old events except captures and cuts */
                    if (0 != (es & E_AGED))  c = 6;     /* magenta */
                    if (0 != (es & E_TS))    c = 3;     /* yellow  */
                    if (0 != (es & E_TSC))   c = 1;     /* red     */

                    ir = "";
                    *hr = 0;

                    if ( 0 == (es & ( E_SPAM | E_AGED)) ) {
                        if (0 == (es & E_TIME)) {
                            ir = "/pg/img/timeradd24.png";
/* timer request, format matches config file */
                            snprintf( hr, sizeof(hr)-1,
                                        "?a=V%02d:%u:%03d:%s@.%d:%d",
                                                s->chan, e1->st, e1->ls/60,
                                                e1->tname, e1->pn, e1->etmid );
                        } else {
                            ir = "/pg/img/timerdel24.png";
                            snprintf( hr, sizeof(hr)-1,
                                        "?d=V%02d:%u:%03d:%s@.%d:%d",
                                    s->chan, e1->st, e1->ls/60,
                                    e1->tname, e1->pn, e1->etmid );
                        }
                    }

                    asnprintf(d, z, "<td width=\042%d%%\042>", w );

                    if (0 != *hr) {
                        asnprintf(d, z, "<a href=\042%s\042>", hr);
                        asnprintf(d, z, "<img border=\042%s\042"
                                        " src=\042%s\042>", "0", ir);
                        asnprintf(d, z, "</a>");
                    }


                    asnprintf(d, z, "<font %s size=\042%s\042>",
                                colors3[c], "-1");
                    if (0 != (E_TS & es)) asnprintf(d, z, "<i>");
                    asnprintf(d, z, "%s", e1->name);
                    if (0 != (E_TS & es)) asnprintf(d, z, "</i>");
                    asnprintf(d, z, "</font>");
//                  asnprintf(d, z, "<br>r%d w%d%%", r, w);
                    asnprintf(d, z, "\n");

                }

                if (96 == k) {
                    asnprintf(d, z, "<td width=\042%d%%\042>", 96 );
                    asnprintf(d, z, "n/a\n");
//                  asnprintf(d, z, "<br>r%d w%d%%", 180, 96);
                } else {
                    if (0 != k) {
                        asnprintf(d, z, "<td width=\042%d%%\042>", k );
                        asnprintf(d, z, "n/a\n");
                    }
                }
                asnprintf(d, z, "</tr>\n");
                asnprintf(d, z, "</table>\n\n");
                
        }
    
        ifree(epg4, "http epg4");

        build_foot_html3(d, z, 1); /* TODO: validate me */

        memset(n, 0, sizeof(n));

/* race condition for more than one user, use mutex to avoid */
        snprintf( n, sizeof(n)-1, "%s%s/pg/grid%d.html",
                    out_path, ram_path, arg_devnum);

        f = fopen( n, "w");
        if (NULL == f) return;

        fprintf( f, "%s\n", d);
        fflush(f);
        fclose(f);

        ifree(d, "epg grid3");
}


static
void
dump_epg_grid( void )
{
/* is it already running? */
        while( (EBUSY == pthread_mutex_trylock( &grid_mutex )) ) {
            nanosleep( &console_read_sleep, NULL );
        }

        if (0 == use_css) {
                dump_epg_grid_html3();
        } else {
                dump_epg_grid_html4();
        }

        pthread_mutex_unlock(&grid_mutex);
}


/* test config frequency can be reduced somewhat now. trying 60s delay */
/* test to see if config file found or changed */
/* static */
void
test_config ( int force, char *caller )
{
        char t[256]; /* test filename */
        struct stat st;
        int ok;
    
        if (0 != arg_scan) return;
#if 0
/* TESTME: other optimizations have made this obsolete? */
        if ((0 != utstcf) && (utstcf > utsnow)) return;
        utstcf = utsnow + 1;
#endif

        advrlog( LOG_INFO, "%s(%s)", WHO, caller);

/* does nothing but eat stack cycles if atscap.spam mtime does not change */
        load_spamlist();

#ifdef USE_WWW
        http_load_allows();
#endif

/* is now part of config with auto-scheduling search events */
        test_epgs( WHO );

/* if config found, dont look again; if no config, keep trying to find */
        if (cf_no != 0) find_config();
    
        snprintf( t, sizeof(t)-1,  "%s%s", cfg_path, cfg_name );

/* only one log file alert about missing config */
        if ( cf_no != 0) { /* not found? */
                if (cf_once == 0) { /* one strike? */
                        advrlog( LOG_ERR, "config not found %s%s",
                                cfg_path, cfg_name );
                        cf_once = ~0; /* yer out! */
                }
                return;
        }

/* 0 if exists, or -1 error (errno set) */
        ok = stat( t, &st );
        if (0 == ok) {

/* FIXME? clear cf_no every time the file is found? */
/*              cf_no = 0; */

/* return if no force load and config file modify time unchanged */
                if (0 == force) {
/* nothing to do? */

                        advrlog( LOG_INFO, "test cfg stat %s %d %d %d",
                                 t, ok, cf_mt, (int)st.st_mtime);
                        if (cf_mt == (int)st.st_mtime) return;

/* it has changed, so update time and proceed with reload */
                        advrlog( LOG_INFO, "%s mtime %d != %d",
                                 cfg_name, (int)st.st_mtime, cf_mt );

                        cf_mt = (int)st.st_mtime;
                } /* force ~0 falls thru here */
        }

        load_config( WHO );
}

/* Show how many minutes and gigabytes needed for all timers + weekdays.
   To attempt to keep the hard drive asleep if it is asleep, if no cap
   is in progress it will display the last read value.
   Clear utsvsu to force it to read an updated value in build html head.
*/

/* static */
void
show_volume_status ( void )
{
        char ds[64];
        long long tb = 0LL;
        long long tt = 0LL;
        long long ts = 0LL;
        long long fg = 0LL;
        char *tc;
        char *tca;

        if (0 == refresh.volstats) return;

        refresh.volstats = 0;

        tca = BN;

/* green = more than 3 hours free space left */
        tc = BG;
        tt = total_timers();

 /* luser avail cut_ or vol_ fsp.f_bavail * .f_bsize */
 /* suser avail cut_ or vol_ fsp.f_bfree  * .f_bsize */
 /* volume size cut_ or vol_ fsp.f_blocks * .f_bsize */

        if (CAP_NONE != cap_now) read_capvol_stats();

/* free space in gigabytes */
        fg = vol_free;
        ts = vol_size;

/* transport rate estimate bytes per second * alltimers seconds */
        tb = (TSORATE * tt) >> 30;

/* if total size is less than total timer bytes */
        if (ts < tb) tca = BR;

/* cyan = less than 3 hours free */
        if ( fg < 25 ) tc = BC;

/* yellow less than 2 hours free */
        if ( fg < 16 ) tc = BY;

/* red = less than 1 hour free, blink as warning */
        if ( fg < 9 ) tc = BL BR;

        snprintf( ds, sizeof(ds), "%dt %lldm %s%lldG (%s%lld%s/%lldG)"

                    "                ",
                    timer_tot, tt / 60, tca, tb, tc, fg, BN, ts );

/* 26 chars with 7 char ecma color and 4 char ecma color reset */
        ds[ 26 + strlen( tc ) + strlen( tca ) + strlen( BN ) ] = 0;
        
/* timer_tot is number of shows total, including weekdays */
        aprintf( stderr, BN "%s %s", dca.sstat, ds);

/* For -E energy saver mode, only wake up volumes to check once every 3 hours,
   except during capture, which needs to update current capture volume stats
   so the volume full test will work. Cut volume can still be delayed until
   the next 3hr meridian. http index_html should reset utsvsu to get it now.
*/
        if (utsvsu > utsnow) return;
        utsvsu = get_next_meridian();

        if (CAP_NONE == cap_now) read_capvol_stats();
        read_cutvol_stats();
}

/* -E power save:
    if open and idle and past power down time, close the dvb device
*/
/* static */
void
test_powerdown( void )
{
        if (
             (0 != arg_tmpfs)
          && (in_file > 2)
/* dont power down during scan */
          && (0 == arg_scan)

/* no cap and test epgs is idle too? */
          && (CAP_NONE == cap_now)
          && (0 == epg_test)

/* if no channel scan: irritating. trying only if no sig scan at all */
//        && (D_CHANNELS != display_type)
          && (0 == scan_sig)


/* time to power down device and device not already closed? */
          && (utsnow > utspdd)

/* if test guides isn't going to run within next 60s */
          && ( (utsnow+60) < utstpg )


           )
        {
                close_device( WHO );
                dvrlog( LOG_INFO, "DVR CLOSED");

                utswuv = 0;
/* volume will only spin up for timers, not EPG capture */
                if ( (timer_idx > 0) && (timer[0].qstat != T_SEARCH) ) {
                        if (timer[0].start > utsnow)
                                utswuv = timer[0].start - 30;
                }

                if (utswuv > utsnow)
                    advrlog( LOG_INFO, "hdd wake in %ds", utswuv - utsnow);

                if (utstpg > utsnow)
                    advrlog( LOG_INFO, "dvb wake in %ds", utstpg - utsnow);
        }
}


/* Show wall clock in top right corner: DST is yellow, ST is normal */
/* static */
void
show_clock ( void )
{
        char *tc;

        get_time();
/* clock/timers update 1 per second */
        if ((0 == refresh.clock) && (ptnow == tnow)) return;

        refresh.clock = 0;

        ptnow = tnow;

        tc = BN;
        if (0 != tloc.tm_isdst) tc = BY;
        aprintf( stderr, SCI "%s%s%s", dca.wstat, tc, date_now );

#ifdef USE_POWERDOWN
        test_powerdown();
#endif


}

/*  This requires -x option to enable experimental capture status,
    otherwise all you get is "dvbN", "test" or "file" at dca.zstat.

    Because i2c may not work correctly, it is grouped under the -x option.
    During capture, query the device operational parameters once per second:
     SNR, strength, frequency drift, bit error rate & uncorrected blocks.
*/
/* static */
void
show_FE_status ( void )
{
        struct sig_s *s;
        char *t = "";
        char u[8];
        s = &ptc[ cap_chan ].sig;
            
        memset(u, ' ', sizeof(u));
        u[5] = 0;

        if (0 != test_mode) t = "test";
        if (0 != arg_dummy) t = "file";
        if (0 == arg_dummy) t = "dvb";

/* TESTME: This was causing it to lock up before. Seems OK now. */
/* Defers device read to channel scan when not capturing. */
        if ((CAP_NONE != cap_now) && (0 != arg_extras))
            get_signal_lock(s);

        aprintf( stderr, "%s" BN "%s%d", dca.zstat, t, arg_devnum );
}

/* search vc[] until found matching source id, return index or -1 if failed */
/* static */
int
find_vc_src ( unsigned int src )
{
    int i;
    for (i=0; i< vc_ncs; i++)
        if ( src == vc[i].src)
            return i;
    return -1;
}


#if 0
/* not needed yet */

/* return -1 if no matching timer etmid found, or 0-n for timer index */
/* static */
int
find_timer_etmid ( unsigned int etmid )
{
    int i;
    for (i=0;i<timer_idx;i++) {
        if (0 == timer[i].etmid) continue; /* skip non EPG sourced events */
        if (etmid == timer[i].etmid) return i;
    }
    return -1;
}
#endif

/* search for etmid match, return index if found, -1 if not found */
/* uses 1/VCZ loops of find_pgm_etmid using VCZ loops */
/* static */
int
find_epg_etmid ( unsigned int etmid )
{
    /* first, reduce the search to only this vc, so 1/8 as many loops */
    unsigned int i, j, sr;
    int v;
    sr = 0xFFFF & (etmid >> 16);

    /* if they're sending NTSC PG info, can get same ETT text for event
       this can make the descriptions fill in faster. it would be faster
       if KHWB didn't send NTSC info at all, too. give us 10 days not 5.
     */
    v = find_vc_src( sr );      /* source sanity check */
    if ( -1 == v ) return -1;   /* not found */

    j = v * PEZ * EIZ;
    if ( j >= PGZ ) j %= PGZ; /* compare is less than divide pipeline */
    
    for (i = 0; i < (PEZ * EIZ); i++) {
        /* check against ETMID loaded from EIT */
        if ( etmid == epg[ i + j ].etmid ) return i + j;
    }

    return -1;    /* not found */
}


/* Save current vc and program guide structures to separate files. */
/* static */
void
save_guide ( void )
{
        char n[256], t[32];                     /* file name */
        struct sig_s *s;
        size_t ok;
        struct utimbuf gt;                      /* guide file time stamp */
        int i, g, ch;

        if (0 != test_mode) return;
        if (0 != arg_scan) return;

        ch = pgm.chan;
        s = &ptc[ pgm.chan ].sig;
        memset( &gt, 0, sizeof(struct utimbuf) ); /* clear all times */

        g = 0;

        advrlog( LOG_INFO, "%s: vc_ncs %d, pgm.idx %d",
                WHO, vc_ncs, pgm.idx );

/* do not save until VCT or PAT+PMT available */
        if (0 == vc_ncs) {
                advrlog( LOG_INFO, "%s VCT%02d not saved: ncs: vc %d vct %d pat %d",
                            WHO, ch, vc_ncs, vct_ncs, pat_ncs);
                return;
        }
        memset(n, 0, sizeof(n));

/* NOTE: Multi-card race condition possible, but likely? Try to avoid
    with staggered sleep, but it may not be a real solution, only a test.

    Guaranteed no-race way is to not have same channels on each instance,
    if user can remember to set the auto-epgs that way for each instance.
*/
        for ( i = 0; i < arg_devnum; i++ )
                nanosleep(&signal_loop_sleep, NULL);

/* at least one valid program entry */
        save_vct( ch, &vct_ncs, vc, &pat_ncs, pa );
        advrlog( LOG_INFO, "VCT%02d guide saved", pgm.chan);

/* use copies to build full pg1 list, set pgm1.idx */
        memset( pg1, 0xFFFF, sizeof(pg1) );     /* clear indices */
        memset( &pgm1, 0, sizeof(pgm1) );       /* clear filters */
        pgm1.chan = ch;                         /* save epg chan */

/* save epg creates binary unfiltered epg data as ch.epg */
        save_epg( ch, epg, &pgm1, pg1, WHO );
        advrlog( LOG_INFO, "EPG%02d guide saved", pgm.chan);

/* This method should yield smoother 3hr meridian times. */
        if (0 != s->pgto) {
//          g = get_next_meridian( epg, &pgm1, pg1 );
            g = get_next_meridian();
            s->pgmt = g;
            gt.modtime = (time_t)g;
        }


/* Three files now, ch.vc, ch.epg and ch.html, but onl ch.epg needs
    expiration time set here. ch.html is updated by dump epg.
*/
        if (0 != g) {
                snprintf( n, sizeof(n)-1, "%s%spg/%02d.epg",
                            out_path, ram_path, pgm.chan);

                text_time( t, g, 16); /* don't need seconds */
                ok = utime( n, &gt );

                if (0 == ok) {
                        advrlog( LOG_INFO, "EPG%02d expires %d events on %s",
                                pgm.chan, pgm1.idx, &t[4] );
                }

                if (-1 == ok) {
                        advrlog( LOG_INFO, "EPG%02d utime(%s) error %s",
                                pgm.chan, n, strerror(errno) );
                }
        }
}

/* write capture log as capture name.html or return if info cap or invalid */
/* changed to use asnprintf and one fprintf to reduce filesystem io */
/* TODO: CSS version that gives each line green yellow or red background
         depending on the severity of the errors for that minute.

   For now, put in <div class=f5> at top and </div> at bottom if CSS.
*/

/* static */
void
dump_cap_log( char *caller )
{
        FILE *f;                /* caplog file descriptor */
        double fets,            /* ets as float */
            sbp,                /* seconds bad% */
            sgp;                /* seconds good% */
        long long brate;        /* bit rate */
        int i, j, k, r, z,      /* counters */
            etm, ets;           /* et minutes and seconds */
        unsigned int sn,        /* seconds n/a */
            sb,                 /* seconds bad */
            sg;                 /* seconds good */
        int t;                  /* error count per second test */
        char
//          cap_log[256],       /* caplog file name */
            p[256],             /* capture file name */
            d[256],             /* deleted capture file name */
            chop_time[32],      /* truncated time */
            bratet[32];         /* byte and bit rate text */
        char *s,                /* allocated string pointer */
            *ft,                /* fail text pointer */
            *tense;             /* present/past tense pointer */
        char t1;                /* error severity flag */
        struct sig_s *ps;       /* scan list */

        if (0 != arg_scan) return;

        ps = &ptc[cap_chan].sig;

/* can only log as big as buffer is. don't do log if it's wrapped junk, */
        if (utsets >= CAP_STZ) return; /* boundary check */

        advrlog( LOG_INFO, "%s(%s)", WHO, caller);
        sn = sg = sb = 0; /* clear seconds good,bad */

/* ets = utsnow - utscap, set by show cap stats */
        ets = utsets;           
        if (ets < 1) ets = 1;

        filebase( p, out_name, F_FILE ); /* capture name */
        filebase( d, del_name, F_FILE ); /* deleted name */
        
        if (0 == strlen(p)) return; /* sanity check */

        snprintf( chop_time, sizeof(chop_time)-1, asctime(&tloc3) );
        chop_time[19] = 0; /* only want weekday month day h:m:s */

        etm = ets / 60;
        if (etm < 1) etm = 1; /* at least one line */
        
/* allocated string size is 4k for html and text headers and counts */
/*  plus 80 * number of minutes to display for error flags */
/*  plus 80 * number of (seconds / 4) for error detail */
        z = 4096;
        z += 80 * etm;

/* five seconds per line for error detail, reuse etm */
        etm = ets / 5;
        if (etm < 1) etm = 1; /* at least one line */
        z += 80 * etm;

/* is it already running? if it is, don't do rest */
        if (EBUSY == pthread_mutex_trylock( &caplog_mutex )) return;

        s = icalloc( z, sizeof(char), "caplog" );

/* didn't calloc? need to unlock caplog mutex */
        if (NULL == s) {
            dvrlog( LOG_INFO, "%s failed caplog calloc", WHO );
            pthread_mutex_unlock( &caplog_mutex );
            return;
        }

/* any return after this point has to free s and unlock caplog mutex */


/* Live capture sets refresh to once every 15s.
    It is presumed this will only be called once when no capture is
    occurring, from the end of ts capture for the final caplog.
*/
        r = 0;
        if (0 == cap_done) r = 15;

/* html headers */
        build_head_html( s, z, 1, p, r, WHO);

        asnprintf( s, z, "<br class=\042%s\042 />\n", "br_epgdiv");

/* text for failure reason, should be copy of above */
        ft = "";
        switch(cap_fail) {
            case FAIL_NONE:
                ft = "OK";
                break;

/* Loss of sync does not happen very often with the newer cx88 based designs.
   HD-2000 may still need it if the DVB API bttv driver doesn't handle it. */
            case FAIL_TSYNC:
                ft = "SYN FAIL";
                break;

/* input fifo error, error in loop */
            case FAIL_IFIFO:
                ft = "IFE FAIL";
                break;

/* output fifo error, error in loop */
            case FAIL_OFIFO:
                ft = "OFE FAIL";
                break;

/* -z QoS bad threshold reached. is same as FAIL_QOS now? */
            case FAIL_ZAP:
                ft = "QoS FAIL";
                break;

/* show cap stat triggers this */
            case FAIL_QOS:
                ft = "QoS FAIL";
                break;

/* not sure how to trigger this */
            case FAIL_NOSPC:
                ft = "VFE FAIL"; /* volume full error */
                break;

/* ts capture loop triggers this */
            case FAIL_AOS:
                ft = "AOS FAIL";
                break;

/* what did i forget? */
            default:
                ft = "???"; /* unhandled */
                break;
        }

/* past tense if file was zapped, but then no reason to log? */
        tense = "has";
        if (cap_zap != 0) tense = "had";
            
/* make the font bigger for entire page if CSS. is OK in HTML3 */
        if (0 != use_css) {
            asnprintf( s, z, "<div class=\042%s\042>\n", "f5" );
        }

/* "dtv program" does not get an event name */
        if (0 != *epg_name)
        {
            asnprintf( s, z, "Event name: %s<br />\n", epg_name);
            if (0 != *epg_desc)
                asnprintf( s, z,  "Event text: %s<br />\n", epg_desc);

            asnprintf( s, z,  "<hr>\n");
        }

        asnprintf( s, z, "<pre>\n");    /* start pre-formatted text */
        asnprintf( s, z, "%s ", p);     /* capture name */

/* quantitative summary */
        lltoasc( bratet, outbc );
        asnprintf( s, z, "%s bytes at ", bratet );

        brate = outbc;
        brate <<= 3;
        brate /= ets;
        lltoasc( bratet, brate );
        asnprintf( s, z, "%s bits/second\n", bratet );

        asnprintf( s, z,  "%s from dvb%d PTC %d.%d: QoSavg %lld%%: %s, ET %d seconds\n",
                     ft, arg_devnum, ps->ptc, ps->pn, qost, &chop_time[0], ets );

/* qualitative summary header */
        asnprintf( s, z, "Errors/sec: GOOD: .=0,1-9  OK: a-z=10-35  BAD: A-Z=36-61 # >61 * >99 ?=na\n");
        asnprintf( s, z, "  Wall    Cap  0         1         2         3         4         5\n");
        asnprintf( s, z, "hh:mm:ss hh:mm:012345678901234567890123456789012345678901234567890123456789\n");

/* step error count of 16-bit words 60 seconds at a time.
    16 bits should be large enough word size for error packets:
        13000 broadcast limit + cc errors (20Mbit)
        26000 cable limit + cc errors     (40Mbit)
        52000 satellite limit + cc errors (80Mbit)
*/

        for (i = 0; i < ets; i += 60 )
        {
                int h2, m2, s2, h1, m1, s1;

                if ( i >= CAP_STZ) break; /* don't wrap around buffer */

                /* show minute at start of line */
                h1 = h2 = (i / 3600) % 24;
                m1 = m2 = (i / 60) % 60; 
                s1 = s2 = i % 60;

                /* tloc3 is start cap timeval */
                s1 += tloc3.tm_sec;
                if ( s1 > 60 ) {
                    s1 %= 60;
                    m1++;
                }

                m1 += tloc3.tm_min;
                if ( m1 > 60 ) {
                    m1 %= 60;
                    h1++;
                }

                h1 += tloc3.tm_hour;
                h1 %= 24;

#ifdef USE_CSS_CAPLOG
/* broken? looks ok but colors are green when they should be red */
/* is trying to nest a div inside a pre confusing the browser? */
/* tally the error counts for the entire minute */
                if (0 != use_css) {
                    char *c;
                    c = "cltc0"; // cap log text color 0
                    t = 0;
                    for (j = 0; j < 60; j++) {
                        k = i + j;
                        if ( ets <= k ) break;
                        if ( k >= CAP_STZ) break;
                            t += cap_stats[k];
                    }
/* average errors */
                    t /= j; /* /60 assumes whole minute */
                    if (t > 10) c = "cltc1";
                    if (t > 30) c = "cltc2";

/* total errors */
//                  if (t > 1000) c = "cltc1";
//                  if (t > 2000) c = "cltc2";
                    asnprintf(s, z, "<div class=\042cltf0 %s\042>", c);
                }
#endif

                /* show wall clock and capture clock to the minute */
                asnprintf( s, z,  "%02d:%02d:%02d=%02d:%02d ",
                        h1, m1, s1, h2, m2);
                /* draw 60 bytes of seconds status for rest of line */
                for (j = 0; j < 60; j++) {

                        k = i + j;
                        /* don't show unlogged data at end of last minute */
                        if ( ets <= k ) break;
                        if ( k >= CAP_STZ) break;
                        
                        t = cap_stats[ k ];

                        t1 = ' ';
                        
                        if ((t > 0) && (t < 62)) { /* 1-9 a-z A-Z, ASCII */
                            t1 = '0' + t;
                            if (t > 9) t1 = 'a' + (t-10);
                            if (t > 35) t1 = 'A' + (t-36);
                        }
        
                        if (t > 61) t1 = '#';
                        if (t > 99) t1 = '*';
            
                        if (t == 0 ) t1 = '.';  /* no errors is dot */
                        if (t < 0  ) t1 = '?';  /* -1 is no data '?' */

                        if (t < 0) {            /* no data collected */
                            sn++;               /* should --ets? */
                        }                       /*  no: see rate below */
                         else
                        {
                            if (t < 36 ) {      /* 36 is start of A-Z bads */
                                sg++;           /* seconds good */
                            } else {
                                sb++;           /* seconds bad */
                            }
                        }
                        asnprintf( s, z,  "%c", t1);
                }

#ifdef USE_CSS_CAPLOG
                if (0 != use_css) asnprintf(s,z, "</div>");
#endif

                asnprintf( s, z,  "\n");
        }

        ets -= sn;
        if (ets < 1) ets = 1;
        fets = 1.0 * ets;

/* used anymore? */
        if (pkt.pes == 0) pkt.pes = 1;
            
/* qualitative estimates, force type to float */
        sgp = (100.0 * sg) / fets;
        sbp = (100.0 * sb) / fets;

/* html <pre> doesn't remove whitespace, <code> does */
        asnprintf( s, z,  "</pre>\n");  /* stop pre-formatted text */
        asnprintf( s, z,  "<hr>\n");    /* validator error if <hr> in <pre> */
        asnprintf( s, z,  "<pre>\n");   /* start pre-formatted text */
        asnprintf( s, z,  "%s used %d bytes of FIFO (%.4f%%)\n",
                in_name, fill_max2,
                (100.0 *fill_max2) / (double)fifoz );

        if (pkt.count == 0) pkt.count = 1;
        asnprintf( s, z,   "%s read %d TS packets: %d had TEI set (%.4f%%)\n",
                in_name,
                pkt.count,
                pkt.teiert,
                (100.0 * pkt.teiert) / (double)pkt.count );

        cap_errors = pkt.errors;

/* any errors? if so, make them look nice with commas */
        if (cap_errors != 0) {
                char caperr[32], synerr[32], teierr[32];
                char tscerr[32], tccerr[32], crcerr[32];

                lltoasc(caperr, (long long)cap_errors);
                lltoasc(synerr, (long long)pkt.synert);
                lltoasc(teierr, (long long)pkt.teiert);
                lltoasc(tscerr, (long long)pkt.tscert);
                lltoasc(tccerr, (long long)pkt.tsccet);
                lltoasc(crcerr, (long long)pkt.crcats+pkt.crcmp2);

                asnprintf( s, z,  "Detected %s errors:  "
                        "%s SYNC, %s TEI, %s SCR, %s CC, %s CRC\n",
                        caperr, synerr, teierr, tscerr, tccerr, crcerr );
        }

/* qualitative analysis summary */
        asnprintf( s, z,
                    "Captured %d seconds: "
                    "%d OK (%.4f%%) %d Bad (%.4f%%) %d n/a\n",
                    ets, sg, sgp, sb, sbp, sn );
        if (0 != cap_tsid) {
            if (cap_pn > 0) {
                if (cap_vc >= 0) { /* pmt load sets this */
                    t = find_tsidx( cap_tsid, cap_pn, WHO );
                    if (t >= 0) {
                        asnprintf( s, z, "TSID %04X PTC.PN %d.%d %s %s\n",
                                    tsids[t].tsid, tsids[t].ptc, tsids[t].pn,
                                    tsids[t].call, tsids[t].sid );
                    }
                }
            }
        }

/* alert if timer name did not set VC with ".x" in name */
        if ((CAP_TIME == cap_now) && (0 != cap_pidx) && (-1 == cap_vc))
            asnprintf( s, z,  "\nERROR: full cap, VC was not set!\n");

/* NOTE: TEI errors can't have PID summary because PID field likely bad. */
/* If single program cap, show MPEG2 PIDs and continuity errors, if any. */
        if ( (cap_pidx > 0) && (-1 != cap_vc) ) {
            char *pt[4] = { "PAT", "PMT", "VID", "AUD" };
            
            asnprintf( s, z, "\n");
            asnprintf( s, z, "Video frames (/s) %d (%4.2f): ",
                 frame_idx, ( (double)frame_idx ) / (double) ets );

            if (ets < 1) ets = 1;
            j = ets>>1;
            if (j < 1) j = 1;

            i = sequence_idx / ets;
            r = sequence_idx % ets;
            if (r > j) i++;
            asnprintf( s, z, " Types I %d (%d), ", sequence_idx, i);

            i = pict[2] / ets;
            r = pict[2] % ets;
            if (r > j) i++;
            asnprintf( s, z, "P %d (%d), ", pict[2], i);

            i = pict[3] / ets;
            r = pict[3] % ets;
            if (r > j) i++;
            asnprintf( s, z, "B %d (%d)\n", pict[3], i);

            asnprintf( s, z, "\n%s %s %d MPEG2 PIDs for VC %1X AUD %1X:\n",
                        p, tense, pkt.kept, cap_vc, cap_va);

            for (i=0; i<cap_pidx; i++) {
                int ppc;
                ppc = pkt.count/100;
                if (ppc < 1) ppc = 1;   /* avoid /0s */
                if (ets < 1) ets = 1;
                j = cap_pids[i];
                brate = pids[j];
                brate *= 188;
                brate <<= 3;
                brate /= ets;

                lltoasc( bratet, brate );
                asnprintf( s, z,  " %s PID %04X %9d %12s bits/s (%2d%%)",
                            pt[i], j, pids[j], bratet, (pids[j] / ppc) );

                if (cce_pids[j] > 0) {
                    if (pids[j] > 0)
                        asnprintf( s, z, " Err ");
                        asnprintf( s, z, "%6d ", cce_pids[j] );
                        asnprintf( s, z, "(%.4f%%)",
                                    (100.0 * (double)cce_pids[j]) / (double)pids[j]);
                    }
                asnprintf( s, z,  "\n");
            }
        } else {
            asnprintf( s, z, " cap_pidx %d cap_pn %d cap_vc %d\n",
                        cap_pidx, cap_pn, cap_vc );
            for (i = 0; i < cap_pidx; i++) {
                asnprintf( s, z, " %04X", cap_pids[i]);
            }
            asnprintf( s, z, "\n");
        }

/* EPG doesn't need to test for previous capture overwritten
    or show MPEG2 summary since EPG reads only ATSC packets. */
        if ((CAP_INFO != cap_prev) && (0 != pkt.mpeg2)) {
            int pk;
            pk = pkt.mpeg2;
            if (cap_pn > 0) pk = pkt.kept;

/* if existing capture.$ file, show it will be or was deleted */
            if ( *del_name != 0 ) {
                    asnprintf( s, z,  "%s %s deleted\n",
                                d, (0 == cap_done)?"will be":"was");
            }

#if 0
/* MPEG2 packet summary */
            asnprintf( s, z,  "\nMPEG2 packets %d:\n", pk);
            asnprintf( s, z, 
                        "PAT CAT PMT"
                        "        VID"
                        "        AUD"
                        "    v+a PES"
                        "       NULL(%sdiscarded)"
                        "\n", arg_nulls ? "not ":"");

            asnprintf( s, z,  "%3d %3d %3d %10d %10d %10d %10d\n",
                        pkt.pat, pkt.cat, pkt.pmt,
                        pkt.vid, pkt.aud, pkt.pes, pkt.null );
#endif

/* MPEG2 CRC32 error summary */
            if (0 != pkt.crcmp2) {
                asnprintf( s, z,  "MPEG2 CRC errors %d:\n", pkt.crcmp2);
                asnprintf( s, z,  "PAT CAT PMT\n");
                asnprintf( s, z,  "%3d %3d %3d\n",
                          pkt.crcpat, pkt.crccat, pkt.crcpmt );
            }
        }

/* ATSC packet summary if full cap or cap info */
        if ( (( cap_pn < 1) || (CAP_INFO == cap_prev)) && (0 != pkt.atsc) ) {
            asnprintf( s, z,  "\nATSC packets %d:\n", pkt.atsc);
            asnprintf( s, z, "MGT TVCT CVCT RRT "
                             "EIT  ETT   STT\n");
            asnprintf( s, z,  "%3d %4d %4d %3d %3d %3d %5d\n",
                        pkt.mgt, pkt.tvct, pkt.cvct, pkt.rrt,
                        pkt.eit, pkt.ett, pkt.stt);

            if (0 != pkt.crcats) {
                asnprintf( s, z,  "ATSC CRC errors %d:\n", pkt.crcats);
                asnprintf( s, z, "MGT TVCT CVCT RRT "
                                 "EIT ETT   STT\n");
                asnprintf( s, z,  "%3d %4d %4d %3d %3d %3d %5d\n",
                            pkt.crcmgt, pkt.crctvct, pkt.crccvct,
                            pkt.crcrrt, pkt.crceit, pkt.crcett,
                            pkt.crcstt );
            }

        }

/* if error seconds detail is off or no errors, all done except for footer */
        asnprintf( s, z, "</pre>\n");

        if ( (0 != arg_edetail) && (cap_errors > 0) ) {
                asnprintf( s, z, "<hr>\n");
                asnprintf( s, z, "<pre>\n");
                asnprintf( s, z, "Errors per second detail (-1 is n/a):\n");

                j = 0;
                for (i = 0; i < ets; i++) {
                    if (i >= CAP_STZ) break;
                    if (0 != cap_stats[ i ] ) {

/* 5 entries per line */
                        j++;
                        j %= 5;
                        asnprintf( s, z,  "%02d:%02d:%02d %-5d",
                                (i/3600) % 24,
                                (i/60) % 60,
                                i % 60,
                                cap_stats[ i ] );

                        if (0 == j) {
                            asnprintf( s, z, "\n");
                        } else {
                            asnprintf( s, z, "  ");
                        }
                    }
                    
                }

                asnprintf( s, z, "</pre>\n");
        }
        
/* html footer */
        asnprintf( s, z, "<p>\n");

/* turn off the big font if CSS. is OK in HTML3 */
        if (0 != use_css)
            asnprintf( s, z, "</div>\n" );

        build_foot_html( s, z, 1 );

        filebase( d, out_name, F_TFILE);        /* ok to re-use d now */
/* regular cap log to cap dir name.html */
        snprintf( caplog_name, sizeof(caplog_name), "%s%s.html", out_path, d);

/* EPG cap log to /dtv/[ram/]pg/EPGch.html */
        if (NULL != strstr( d, "EPG" ))
                snprintf( caplog_name, sizeof(caplog_name), "%s%spg/%s.html",
                          out_path, ram_path, d);

/* open the file for write and write the assembled string */
        f = fopen( caplog_name, "w");
        if ( NULL != f ) {
                fprintf( f, "%s", s);
                fflush( f );
                fclose( f );
        } else {
                dvrlog( LOG_INFO, "%s error create %s", WHO, caplog_name);
        }

        ifree( s, "caplog" );
        pthread_mutex_unlock( &caplog_mutex);
}

/* rewrite of epg test code from old show packet stats */
/* 30 seconds after last EIT/ETT change, stop cap, or 180 second limit.
   180 second limit is needed for stations that send more than one new
   MGT update, which can keep the guide load going for more than 180s.
    This only operates on pgm struct since that is the live one.
 */
/* static */
void
test_epg_done ( void )
{
        if (CAP_INFO != cap_now) return; /* only for info cap */

/* NOTE: If you have 10 or 16 days of program guide you may need to
        make this number larger. If you are not getting the same
        number of programs with guide capture as you get with
        a manual capture of 5 minutes or so, try + 60 instead.
        If cable has a guide, it may be very large. For now it is
        assuming it does not have a guide and only needs quick check.
*/
        if (0 != arg_cable) {
            if (0 == pgmto) pgmto = utsnow + 2; /* cable only needs PAT+PMT */
        } else {
            if (0 == pgmto) pgmto = utsnow + 30; /* use 60 if bad signal area */

        }
/* this is faster than calling build pg epg to find title/descriptions */
/* check for EIT# or ETT # to change. versioning keeps these #'s accurate */
        if ( (pgme != pkt.eit) || (pgmd != pkt.ett) )  {
                pgme = pkt.eit; /* update current count */
                pgmd = pkt.ett; /* description count too */
                pgmto = utsnow + 30; /* each new item buys 30 more seconds */
                pgm.fail = 0; /* ok so far */
                refresh.epg = 1;
        }

/* EIT or ETT change resets timeout to the future, limited to 180 seconds */
        if (utsets > 180) pgmto = 0;
        if ( (0 != pgmto) && (utsnow < pgmto) ) return;

        stop_capture( WHO, FAIL_NONE );

/* flag guide as done */
        pgm_done = ~0;
        advrlog( LOG_INFO, "APG%02d found %3d EITs %3d ETTs in %ds",
                 cap_chan, pkt.eit, pkt.ett, utsets);
        return;
}

/*
    blink capture time once per second, and do other things too.
    display time left/time used, fifo info, transport errors, PES counts

    added test cfg/show timers to this, as it's a separate thread now,
    even if it spends a bit of time, it shouldn't degrade cap anymore.

    this also calls test eit ett done (above) to stop info cap
*/
/* static */
void
show_cap_status ( void )
{
        char n[256];
        char *f = NULL;         /* capture filename */
        char *tc;                       /* timer color */
        char d[32];                     /* display area top left 31 chars */
        char tse = ' ';         /* v or ^ for up or down vary, or blank */
        int utsel;                      /* timer eta, backwards count */
        struct sig_s *s;                /* pointer for shorthand to ptc  */
        char pe[32], pt[32], pk[32]; /* packet error strings  */
        char *ec;
        long long pkt_err = 0LL;        /* packet errors total */
        long long pkt_num = 0LL;        /* packet number total */
        long long pkt_mp2 = 0LL;        /* packet mpeg2 total */
        long long pc, pb;
        char *qtc, *qc;         /* qos/t colors */

        ec = BR;

        if ( CAP_NONE == cap_now ) return; /* false alarm */

#ifdef STOP_SCAN_ON_FIRST_VCT_FOUND
/* disabled because want to get the video dimensions from ES SEQ */
/* -S option stops at first received VCT for station ID */
        if ( (0 != arg_scan) && ( 0 != pkt.tvct ) ) {
                stop_capture( "-S found VCT, ", FAIL_NONE );
        }
#endif

        tc = "";
        refresh.pstats = 1; /* so stats will update during cap */

        get_time();
/*
    if (tnow == ptnow) return;
    ptnow = tnow;
*/
        if ( utscap == 0 ) return; /* hold down */

    
/* filename shortcut w/o path or extension */
        filebase( n, out_name, F_TFILE );

        f = n;

/* QOS per reporting period */
        pc = pkt.count - last_pktc; /* number of pkts since last time */
        pb = pkt.errors - last_pktb; /* number of errors since last time */
        if (pc < 1) pc = 1; /* avoid /0 floating point exception */
        qosc  = 100 - ( (100*pb)/pc);
        if (qosc > 100) qosc = 100;
        if (qosc < 0) qosc = 0;

/* QoS average */
        pc = last_pktc = pkt.count;
        pb = last_pktb = pkt.errors;

        if (pc < 1) pc = 1; /* avoid /0 floating point exception */
        qost = 100 - ( (100*pb)/pc);
        if (qost > 100) qost = 100;
        if (qost < 0) qost = 0;

/* disable QoS test for now */
/*    if (0 == qost) stop_capture( "show cap stats", FAIL_QOS); */

        if (utsets < 0 ) utsets = 0;    /* dont display negatives */
        utsel = utsets; /* default displays elapsed time by mode */

        test_epg_done(); /* stop cap if it's done */

#if 0
/* move to test_qos_good() */

/* QoS check for timers, presume manual and info cap do not need QoS check. */
        if (CAP_TIME == cap_now) {
            if ( (utsets > 60) && (qost < 90) ) {
                char qfc[4096];
                snprintf( qfc, sizeof(qfc)-1,
                        "timer qos fail ets %d qost %lld",
                        utsets, qost);
/* prevent test timers from setting cap now so it will terminate */
                timer[timer_rec].qstat = T_DONE;
                stop_capture( qfc, FAIL_QOS );
            }
        }
/* want guide saved even if it only got eit0 (for search timers) */

/*
 this prevents guide from being saved if QOS was too low
 but will only check for QOS after qos info ss timeout
*/
        if (utsets > QOS_INFO_TIMEOUT) {
            if (qost < QOS_INFO_SS_LIMIT) {
                stop_capture( WHO, FAIL_QOS );
            }
        }

        /* no more found will set pgm_done and stop cap */
        if ( (CAP_INFO == cap_now) && (0 != pgm_done) ) {
            stop_capture( WHO, FAIL_NONE );
            display_type = D_TIMERS; /* 0 */
        }
#endif

/* make error trend indicator as ^ for more errors and v for less errors
*/
        if (qosc > last_qos) tse = '^';
        if (qosc < last_qos) tse = 'v';
        if (qosc == last_qos) tse= ' '; /* trend is blanked if no change */
        last_qos = qosc; /* same bat time */

        qc = BG;
        qtc = BG;
        if (qosc < 99) qc = BY;
        if (qosc < 95) qc = BR;
        if (qost < 99) qtc = BY;
        if (qost < 95) qtc = BR;

/* don't zap info, might be trying to scan bad signal, want to see it.
 some guide entries might be able to get thru bad signal muck
*/    
        if (CAP_INFO != cap_now) {
            if ( (arg_zapper != 0) && (utsets > 59 ) && ( qost <= arg_zapper) )
            {
                dvrlog( LOG_INFO, "ZAP%02d: %s QOS %lld%% < limit of %d%%",
                        cap_chan, f, qost, arg_zapper);
                if (CAP_TIME == cap_now) reschedule_timer( timer_rec, WHO );
                stop_capture( WHO, FAIL_ZAP );
                cap_zap = ~0;
            }
        }

/* not counting mpeg2 packet crc yet, but some (all?) is crc-able */
        cap_errors = pkt.errors;

        pkt_num = (long long)pkt.count; /* snapshot so vals don't change */
        pkt_err = (long long)cap_errors;
        pkt_mp2 = (long long)pkt.mpeg2;

/*      if (pkt.esec != 0) advrlog( LOG_INFO, "pkt esec %d", pkt_esec); */

/* timer changes utsel to seconds remaining in capture, if 'e' toggle */
        if ( (CAP_TIME == cap_now) && (cap_etime == 0) )
                utsel = ( timer[timer_rec].start
                      + (timer[timer_rec].len - timer[timer_rec].secdt))
                      - utsnow;

/* display elapsed doesn't go below zero */
        if (utsel < 0) utsel = 0;

/* signal shortcut */
        s = &ptc[ cap_chan ].sig;

/* show file progress, if after one second of cap */
/*      if (utsets > 1) */
        {
            char *tnd = ""; /* color plus modifier to descriptor */
            if (test_mode != 0) {
                tnd = BT "TEST:";
            } else {
                tnd = (CAP_TIME == cap_now) ? BW:BG;
            }

/* load guide blink cycle time 2s, even number gets inverse text */
            if (CAP_INFO == cap_now) {

/* EPG says program guide, otherwise the file name */
                tnd = &bc[7 & utsnow][0];
                f = "Events";

/* cable only has program list in vct */
                if (0 != arg_cable) f = "Programs";

/* config file sets station network id and call sign */
                snprintf( d, sizeof(d)-1, "%s %s %d.%d",
                            f, s->call, s->ptc, s->pn);

                if (0 != arg_dummy) {
                        snprintf( d, sizeof(d)-1, "%s %s", f, arg_dummyn );
                }
            }

            if (CAP_INFO != cap_now) {
                    snprintf( d, sizeof(d)-1, "%s", f);
#if 0
                    if (0 != test_mode) {
                            snprintf( d, sizeof(d)-1, "%s", f);
                    }
#endif

            }

/* show current capture file */
            aprintf(stderr, DCA0 "%s%-32s", tnd, d);
        }

/*
 demoth
    if (CAP_INFO == cap_now) return;
*/
        /* timer cap is white inverse blink */
        if (CAP_TIME == cap_now) { 
            tc = (0 == (utsnow & 1)) ? BN BV : BW;

/*
            aprintf( stderr, "%s%sNet PTC Time %s",
                    tc, dca.hstat, (0 == cap_etime) ? "Left":"Used" );
*/

            aprintf( stderr, "%sNet PTC Time %s",
                    dca.hstat, (0 == cap_etime) ? "Left":"Used" );
        }

        /* manual cap is fg:green bg:black or fg:white bg:green */
        if (CAP_USER == cap_now) {
                tc = (0 == (utsnow & 1)) ? BG BV : BG;
                aprintf( stderr, "%s%sNet PTC Time Used", tc, dca.hstat );
        }

        if (CAP_INFO == cap_now) {
                tc = (0 == (utsnow & 1)) ? BV : "\033[27m";
                aprintf( stderr, "%s%sNet PTC Time Load", tc, dca.hstat );
        }

#if 0
/* FIXME: obsolete this: user doesn't need to hit tab during cap */
/* find which line to use for display for timer or channel list */
        snprintf ( csp, 15, "\033[%d;1H" ,
                ( D_TIMERS == display_type) ? 3 : 3+get_scanlist_offset( cap_chan ) );
#endif

        snprintf( csp, sizeof(csp)-1, "%s", "\033[3;1H" );

        *pe = *pt = *pk = 0; /* valgrind */

        lltoasc( pe, pkt_err ); /* total transport errors */
        lltoasc( pt, pkt_num ); /* ts num */
        lltoasc( pk, pkt_mp2 ); /* mpeg2 num */

        if (pkt_err < 3) ec = BG;

#if 0
/* field align test toggles values to max and min */
        if (utsnow & 1) {
                lltoasc( pe, 999999999 );
                lltoasc( pt, 999999999 );
                lltoasc( pk, 999999999 );
        } else {
                lltoasc( pe, 0 );
                lltoasc( pt, 0 );
                lltoasc( pk, 0 );
        }
#endif

/* display rate limiter */
        blinky++;
        blinky &= 1;

/* 9 digs pkt/err total exceeding 2 hours (46 million pkts/hr) */
        aprintf ( stderr,
                "%s%3s %3d  "           /* net and ptc */
                "%s%02d:%02d:%02d"
                BN " "
                BN "%s%3d%% "           /* sigcol + sigstr */
                BG "%4d/%4d "           /* FIFO% */
                BR "%s%3d%c "           /* QOS%+down=v/up=^ errors/second % */
                BR "%s%3lld "           /* QOS average%     errors/TS pkt % */
                   "%s%11s "            /* pkterr 9 digits, 11 with commas */
                BW "%11s "              /* pktnum 9 digits, 11 with commas */
                BM "%-11s" BN,          /* pktcap 9 digits, 11 with commas */
                csp, s->sid, (arg_dummy!=0)?0:s->ptc,
                tc, (utsel / 3600) % 24, (utsel / 60) % 60, utsel % 60,
                s->sig_col, s->strength,
                ( fill_max * 100 ) / fifoz, ( fill_max2 * 100 ) / fifoz,
                qc, qosc, tse, qtc, qost, /* avoid /0 */
                ec, pe, pt, pk);

/* This may need to be changed to dynamic update to prevent cpu drain */

/* capture log updates every 15s */
        if (utsdcl < utsnow) {
                dump_cap_log( WHO );
                utsdcl = utsnow + 15;
        }

#if USE_AUTO_HTML_UPDATE
/* obsoleted: moved these to http requested updates only */
        if (utsdsh < utsnow) {
                dump_html_stats( WHO );
                utsdsh = utsnow + 5;
        }

        if (utsdpg < utsnow) {
                save_epg( pgm.chan, epg, &pgm, WHO );
                utsdpg = utsnow + pgm.refresh;
                if (utsdpg <= utsnow) utsdpg += 15;
        }
#endif

/* these reset after displaying current value */
        fill_max = 0;
        return;
}

/* calc how long it will take to remove delname */
/* TODO: needs FS detection and sample data for 9G delete times
        for the various filesystems that might be used.
        for example, ext2 needs 20 seconds to delete 9G,
        but XFS only needs about a half a second.
*/
/* static */
void
calc_secdt ( void )
{
    long long file_size;
    long long file_time;
    struct stat fs1;
    int stok;
    
    if ( (timer_rec != -1) && (CAP_TIME == cap_now) )
        timer[0].secdt = 5;

    /* check if cap del and no -f fast filesystem and more than 1 timer */
    if ( (strlen(del_name) != 0) && (arg_fastfs == 0) && (timer_idx > 1) )
    {
        /* check for back-to-back, within 60 seconds of next timer for AOS */
        if ( (timer[0].start + timer[0].len + 60) >= timer[1].start ) {
            /*
             5s is minimum for aos check on back to back timers
             also, add 13s/9G of secdt len for delete time (my setup)
            */
            timer[0].secdt = 5;

            /* stat the delname file to see how big it is */
            stok = stat( del_name, &fs1);
            if (stok != 0) {
                advrlog( LOG_INFO,"couldn't stat %s for delete", del_name);
                return;
            }

            file_size = fs1.st_size;
            /* ext3 delete time here is about 500M/sec */
            file_time = file_size / 500000000;
/* ext2 is ~20s for 9G */
/*
            dvrlog( LOG_INFO,
                "calc secdt computed at %lld seconds", file_time);
*/
            timer[0].secdt = 5 + file_time;

            return;
        }    
    }

    timer[0].secdt = 5;
}

/* program guide flags, bottom middle */
/* static */
void
show_event_mask( void )
{
        int i;
        i = (columns - 6) >> 1;

        aprintf( stderr, BN DCARC "[%c%c%c%c]" CEL, lines, i,
                (pgm.hide  != 0) ? 'h':' ',
                (pgm.age != 0) ? 'a':' ',
                (pgm.find != 0) ? 'm':' ',
                (epg_www != 0) ? 'w':' '
        );
}

/* short form of event program guide count/status, bottom left corner */
/* static */
void
show_event_short ( void )
{
    struct sig_s *s;
    char pgn[32];
    char nvc[16]; /* network or network and vc program # */

    int pgi;

/* TESTME: want it to update during capture or only info cap? */
    if ( (0 == refresh.estats) && (CAP_NONE == cap_now) )
        return;

    refresh.estats = 0;

    s = &ptc[ cap_chan ].sig;

    pgi = pgm.idx; /* pg index after build pg epg */

    snprintf( nvc, sizeof(nvc)-1, "%s", s->sid);

    if (s->pn > 0) {
        snprintf( nvc, sizeof(nvc)-8, "%s.%d", s->sid, s->pn);
        pgi = count_pg_pgm( s->pn );
    }

    memset(pgn, 0, sizeof(pgn));

/* default event status if nothing else done */

    snprintf( pgn, sizeof(pgn)-1, "%s EIT %03d ETT %03d",
                                    nvc, pkt.eit, pkt.ett);


    snprintf( pgn, sizeof(pgn)-1, "%4d Events on %s", pgi, nvc);

    if (pgm.idt < 1)
        snprintf( pgn, sizeof(pgn)-1, "No Events on %s", nvc);

    if ( (CAP_NONE != cap_now) && (pkt.eit < 1) ) {
        snprintf( pgn, sizeof(pgn)-1, "No EPG for %s", nvc);
    }

    /* load guide failure reasons */
    switch( pgm.fail )
    {
    case PG_FAIL_NONE:
        break;

    case PG_FAIL_NF:
        snprintf( pgn, sizeof(pgn)-1, "No Guide for %s", nvc);
        break;

    case PG_FAIL_TO:
        snprintf( pgn, sizeof(pgn)-1, "Old Guide for %s", nvc);
        break;

    case PG_FAIL_GE:
        snprintf( pgn, sizeof(pgn)-1, "Empty Guide for %s", nvc);
        break;

    case PG_FAIL_BG:
        snprintf( pgn, sizeof(pgn)-1, "Blank Guide for %s", nvc);
        break;

    default:
        break;
    }

    aprintf( stderr, BN "%s%-30s" CEL, dca.pstat, pgn);
/*    advrlog( LOG_INFO, "pgm fail %d", pgm.fail); */

/* [hamw] in bottom middle of screen hide/age/match/web */
    show_event_mask();
}

/*
 show the following at the bottom right, or blank if not found
 APVMETR Z xx:xx:xx +nn
 APVMETR Z indicates which packets have been seen as valid
 Z indicates ATSC system stream time. It may be catastrophically wrong.
 +nn is number of seconds out, or OSL Off-Scale Low or OSH Off Scale High
*/
/* static */
void
show_atsc_stats ( void )
{
    char *s, *t;
/*    if (display_stat == 0) return; */
    if (CAP_NONE == cap_now) return; /* data valid during cap only */
    aprintf( stderr, "%s", dca.astat );

/* legend:
    A is PAT, P is PMT, V is VCT, M is MGT, E is EIT, T is ETT and R is RRT
    bottom line, center right. color P yellow for RC detected in PMT
 */
/***********************************/
    s = BN;
    t = " ";
    if (0 != pkt.fpat) {
        t = "A";
        if ( pkt.fpat == PAY_READ ) s = BR; /* reading packet */
        if ( pkt.fpat == PAY_PARSE) s = BW; /* version diff */
        if ( pkt.fpat == PAY_GOOD ) s = BG; /* version same */
        if ( pkt.fpat == PAY_DROP ) s = BM; /* payload not handled */
    }
    aprintf( stderr, "%s%s", s, t );

/***********************************/

    s = BN;
    t = " ";
    if (0 != pkt.pmt) {
        s = BG;
        t = "P";
        if (0 != pkt.pmtrc) s = BY;
    }
    aprintf( stderr, "%s%s", s, t);
/***********************************/

    s = BN;
    t = " ";
    if (0 != pkt.fvct) {
        t = "V";
        if ( pkt.fvct == PAY_READ ) s = BR; /* reading packet */
        if ( pkt.fvct == PAY_PARSE) s = BW; /* version diff */
        if ( pkt.fvct == PAY_GOOD ) s = BG; /* version same */
        if ( pkt.fvct == PAY_DROP ) s = BM; /* payload not handled */
    }
    aprintf( stderr, "%s%s", s, t );
/***********************************/

    s = BN;
    t = " ";
    if (0 != pkt.fmgt) {
        t = "M";
        if ( pkt.fmgt == PAY_READ ) s = BR; /* reading packet */
        if ( pkt.fmgt == PAY_PARSE) s = BW; /* version diff */
        if ( pkt.fmgt == PAY_GOOD ) s = BG; /* version same */
        if ( pkt.fmgt == PAY_DROP ) s = BM; /* payload not handled */
    }
    aprintf( stderr, "%s%s", s, t );
/***********************************/

    s = BN;
    t = " ";
    if (0 != pkt.feit) {
        t = "E";
        if ( pkt.feit == PAY_READ ) s = BR; /* reading packet */
        if ( pkt.feit == PAY_PARSE) s = BW; /* version diff */
        if ( pkt.feit == PAY_GOOD ) s = BG; /* version same */
        if ( pkt.feit == PAY_DROP ) s = BM; /* payload not handled */
    }
    aprintf( stderr, "%s%s", s, t );
/***********************************/

    s = BN;
    t = " ";
    if (0 != pkt.fett) {
        t = "T";
        if ( pkt.fett == PAY_READ ) s = BR; /* reading packet */
        if ( pkt.fett == PAY_PARSE) s = BW; /* version diff */
        if ( pkt.fett == PAY_GOOD ) s = BG; /* version same */
        if ( pkt.fett == PAY_DROP ) s = BM; /* payload not handled */
    }
    aprintf( stderr, "%s%s", s, t);
/***********************************/

    s = BN;
    t = " ";
    if (0 != pkt.frrt) {
        t = "R";
        if ( pkt.frrt == PAY_READ ) s = BR; /* reading packet */
        if ( pkt.frrt == PAY_PARSE) s = BW; /* version diff */
        if ( pkt.frrt == PAY_GOOD ) s = BG; /* version same */
        if ( pkt.frrt == PAY_DROP ) s = BM; /* payload not handled */
    }
    aprintf( stderr, "%s%s", s, t );
/***********************************/

/* multicast status */
    s = BN;     
    t = " ";

#ifdef USE_MCAST
    if (0 != udp_mcast) {
        t = "U";
        s = BY;
    }
#endif

    aprintf( stderr, "%s%s", s, t );
/***********************************/

/****************************************************************** ATSC STT */

/* see if time is offscale, 999+/- seconds out is considered off scale */
    if (0 != pkt.fstt) {
        char d[32];
        char o[16];

        s = BW;
        if (0 != astt.dss) s = BY; /* ATSC daylight savings in yellow */
        
        get_time();

        asctime_r( &atsc_stt_tm, d );

/* don't need year and time zone */     
        d[19] = 0;

        snprintf( &o[1], sizeof(o)-1, "%u   ", abs(atsc_stt - utsnow) );

        o[0] = '+';
        if ( (atsc_stt - utsnow) < 0) o[0] = '-';
        if ( abs(atsc_stt - utsnow) > 999 ) /* offscale high or low */
        {
/* KHCW: monitor intermittent offscale drift: is 6 hour jump ahead */
            advrlog( LOG_INFO, "STT%02d drift %ld",
                    cap_chan, utsnow - atsc_stt );

            o[1] = 'O';
            o[2] = 'S';
            o[3] = ( o[0] == '+') ? 'H':'L';
            s = BR;             /* red means time is offscale */
        }           
        
        if (0 == (atsc_stt - utsnow)) {
            o[0] = ' ';
            o[1] = ' ';
            o[2] = ' ';
            o[3] = ' ';
        }

        o[4] = 0;
        aprintf( stderr, "%sZ %s %-3s", s, d, o );
    } else {
        aprintf( stderr, CEL);
    }
}


/* display all the status indications */
/* capture mode will also display capture status on channel line */
/* wait nonzero does nothing unless time has changed */
/* certain key actions call with wait 0 to redraw sooner */
/* static */
void
show_status ( int wait, char *caller )
{
    get_time();

/* clock/timers update 1 per second */
    if ( (0 != wait) && (ptnow == tnow) ) return;
    ptnow = tnow;

    advrlog( LOG_INFO, "%s(%s)", WHO, caller);

    if (refresh.headers > 0) show_headers(0);

/* make all guides update once per second at least */
    if ( (CAP_NONE != cap_now) && (0 != wait) ) {
        refresh.log = 1;
        refresh.mgt = 1;
        refresh.epg = 1;
        refresh.vct = 1;
    }

    /* auto update config only when not capturing, so you don't
       erase/restart any currently in progress timers
     */
    if (0 == arg_capture)
      /* if ( (CAP_INFO == cap_now) || (CAP_NONE == cap_now) ) */
    {
        /* does nothing if config file didn't change */
        test_config(0, WHO);

/* NOTE: force cfg reload when Local Time changes to/from Daylight/Standard
        this corrects the timers, but will erase unsaved timers
        2am timers will be wrong, not much can do there is no 2am
 */
        if (tloc.tm_isdst != pisdst)
        {
            pisdst = tloc.tm_isdst;
            advrlog( LOG_INFO, "load cfg @ DST change");
            test_config(1, "show_status DST change");
        }
    }

/*
    refresh.pstats = 1;
    refresh.vstats = 1;
    refresh.estats = 1;
*/

    test_termsize(); /* see if any environment change happened */

//    aprintf( stderr, SCP ); /* save cursor position for user input */
    
    /* divide by 0 in here somewhere */
    calc_secdt(); /* check for updates to secdt */

    show_volume_status();       /* used/free space, calc timer total usage */

    if (0 != wait) refresh.clock = 1;

    show_clock();               /* wall clock */
    show_cap_status();          /* time elapsed, QOS */

    show_FE_status();           /* faux LEDs */

    show_timers();              /* whats on the menu, also calls check timer */
    show_packet_stats();        /* counts of everything */
    show_vc_selection();
    show_event_short();         /* show filtered event and total event count */
    show_atsc_stats();          /* atsc tables rx + system (stream) time */

    /* if no device show that, if found device but test mode say no output */
    if (0 != test_mode) {
        aprintf( stderr, DCA_SPACE BN " " "\033[1;41;37m" " TESTING... ");

        if (in_file < 3) {
            aprintf( stderr, "NO DEVICE " BN " " );
        } else {
            aprintf( stderr, "NO OUTPUT " BN " " );
        }
    }

    /* see if scan is disabled, if it is, make it stay on one channel */
    if (scan_sig == 0) scan_one = ~0;
    aprintf( stderr, RCP );
}

/* help shows uptime */
/* static */
void
show_uptime ( void )
{
    int up, d, h, m, s, f, a, i;
    char to1[32];
    struct sig_s *ss;
    
    ss = &ptc[ cap_chan ].sig;

    up = utsnow - utc_up;
    s = up % 60;
    up /= 60;
    m = up % 60;
    up /= 60;
    h = up % 24;
    up /= 24;
    d = up;

    f = open( "/etc/hosts", O_RDONLY );
    if (0 < f) {
        close(f);
    } else {
        dvrlog( LOG_INFO, "%s file counter needs /etc/hosts", WHO );
    }

    a = 0;
    for ( i = 0; i < ALLOC_LIMIT; i++ )
            if (NULL != alloc_list[i].p)
                    a += alloc_list[ i ].z;

    aprintf( stderr, welcome );
    
    aprintf( stderr, BW "Uptime %d days %d hours %d minutes %d seconds "
                     BN "%d files %d allocs\n",
                d, h, m, s, f - 1, a );
    aprintf( stderr, "Timers %d/%d  Searches %d/%d  Spams %d/%d  "
                      "Events: sel %d tot %d max %d\n",
                timer_idx, TIMER_LIST_MAX,
                search_idx, SEARCH_LIST_MAX,
                spam_idx, SPAM_LIST_MAX,
                pgm.idx, pgm.idt, PGZ);

#ifdef USE_POWERDOWN
    if (0 != arg_tmpfs) {
        text_time( to1, utspdd, 19);
        aprintf( stderr, BN "Powerdown %s ", to1 );
    }
#endif

    if (0 != ss->pgto) {
        text_time( to1, ss->pgmt, 19 );

        aprintf( stderr, BN "Auto EPG Timeout %02d %s", cap_chan, to1 );
    }
    aprintf( stderr, "\n" );
}
/* FIXME: make list scrollable */
/* display short keyhelp text until next timer,
 * or hit a key to get out sooner
 */
/* static */
void
show_keyhelp ( char *keyhelptext )
{
        int utsp = 0;
        int old_stat, old_type;
        int k, m;

/* save pkt stats display status */

        old_stat = display_stat;
        old_type = display_type;

        display_type = D_HELP;
        display_stat = 0;

        get_time();

        aprintf( stderr, DCA_HELP CCE );
        show_uptime();

        aprintf( stderr, BN "%s", keyhelptext);

        utsp = utsnow;

        m = 0;

        while (1) {
            k = console_getch();

/* if display type changes, need to get out */
            if  (D_HELP != display_type) {
                aprintf( stderr, DCA_HELP CCE );
                break;
            }

/* m key shows memory usage details, or refreshes it */
            m = 0;
            if ('m' == k) m = ~m;

            if (0 != m) {
                aprintf( stderr, DCA_HELP CCE "\n" );
                show_mem_use();
            }

/* any key but m will get out */
            if ('m' != k) if (0 != k) break;

/* reset by timer activity instead */
            get_time();

            show_status( 1, WHO );
            nanosleep( &msg_sleep, NULL );
        }


/* restore display and status */
        display_type = old_type;
        display_stat = old_stat;
        test_termsize(); /* recalc user_lines and dca.* addresses */

/* don't overwrite headers and you dont have to show them again */
/*      show_headers(1); */
        set_refresh();
        return;
}


/* sort copy of master guide table list by table type */
/* static */
void
sort_mgs ( void )
{
        int i,j;
        struct mg_s t;
        struct mg_s *m1, *m2;

        if (mg_idx < 2) return;

        for (i = 0; i < (mg_idx - 1); i++) {
                for (j = i + 1; j < mg_idx; j++) {
                        m1 = &mgs[i];
                        m2 = &mgs[j];

                        if ( m1->tt <= m2->tt ) continue;

                        memcpy(&t, m1, sizeof(t));
                        memcpy(m1, m2, sizeof(t));
                        memcpy(m2, &t, sizeof(t));
                }
        }
}


/* add string at *s to mgt_text, if it will fit, otherwise do nothing */
/* static */
void
add_mgt_text ( char *s )
{
    char *t;

    /* ignore blanks */
    if ( 0 == strlen(s) ) return;

    /* NOTE: silently fails when past line max */
    if ( mgt_idx < MGT_ROWS) {
        t = &mgt_text[ mgt_idx ][0];
        snprintf( t, strlen(s)+1, "%s", s);
        mgt_idx++;
    }
}

/* show mgt table, has list of pids, like VCT, EIT & ETT pids */
/* static */
void
build_mgt_text ( void )
{
        int i;
/*      int j = 0; */
        unsigned int tt, pid, vn, dl, nb, nbt, nbt1, nb1, vn1;
        char s[128];    /* enough for 80 column plus 5 ansi codes */
        char *tc;       /* text color */
        char *ze;       /* size error color */
        char *ve;       /* version error color */
        char po, pv, pz;
        char tx[16];    /* table x */

        int one_eit;    /* fixes display of section titles */
        int one_ett;    /* even if eit0 ett0 or rrt1 missing  */
        int one_rrt;    /* but others than first one exist */

        struct mg_s *m1;

/* (non compliant missing ETT0 KTMD fix) */
        one_eit = one_ett = one_rrt = ~0;

        memcpy( mgs, mg, sizeof(mgs) );
        sort_mgs();

        memset( s, 0, sizeof(s));
        memset( tx, 0, sizeof(tx));
        memset( mgt_text, 0, sizeof( mgt_text ));
        mgt_idx = 0;

/* hold down until version not 0xFF, i.e. a live MGT */
        if (mgt_vn == 0xFF) {
            display_type = D_TIMERS;
            return;
        }

        snprintf( s, sizeof(s)-1,
                BW "MGT Version %02X DLen %02X" BN, mgt_vn, mgt_dl);
        add_mgt_text( s );

#if 0
        snprintf( s, sizeof(s)-1,
                BM "Next update is scheduled for %s", date_next);
        add_mgt_text( s );
#endif

/* reset number of bytes total for tables
    (does not take into account multi-EIT/ETT)
*/
    nbt = nbt1 = 0;

    tc = BN;
    for (i = 0; i < mg_idx; i++) {

        m1 = &mgs[i];

        tt = m1->tt;
        pid = m1->pid;

/* descriptor is always blank? not parsed: MRD length is display only */
        dl = m1->dl;    /* MPEG registration descriptor length */

/* vn and size provided by mgt */
        nb = m1->nb;
        vn = m1->vn;

/* parsed data from last table of each type */
        nb1 = m1->nb1;
        vn1 = m1->vn1;

/* FUTURE TODO: number of bytes to allocate for table, but there are problems.
    Some stations do not send correct values here. Do not depend on these!
    The ATSC spec is a bit fuzzy on the implementation of numbytes, so these
    values are for display only, and should not actually be used.
    Red text marks the items that seem to be different from A/65b.
*/

/* add MGT table size */
        nbt += nb;
        nbt1 += nb1;
        
        if (tt == 0) {
            add_mgt_text( BY "  Terrestrial Virtual Channel0");
            tc = BY;
            snprintf( tx, sizeof(tx)-1, "TVCTC0");
        }
        if (tt == 1) {
            add_mgt_text( BY "  Terrestrial Virtual Channel1");
            tc = BY;
            snprintf( tx, sizeof(tx)-1, "TVCTC1");
        }
        if (tt == 2) {
            add_mgt_text( BY "  Cable Virtual Channel0");
            tc = BY;
            snprintf( tx, sizeof(tx)-1, "CVCTC0");
        }
        if (tt == 3) {
            add_mgt_text( BY "  Cable Virtual Channel1");
            tc = BY;
            snprintf( tx, sizeof(tx)-1, "CVCTC1");
        }
        if (tt == 4) {
            add_mgt_text( BN "  PTC Extended Text");
            tc = BN;
            snprintf( tx, sizeof(tx)-1, "PTCET ");
        }

/* have never seen this implemented in broadcast from 2004 through 2007 */
        if (tt == 5) {
            add_mgt_text( BM "  Directed Channel Change Selection Code Table:");
            tc = BM;
            snprintf( tx, sizeof(tx)-1, "DCCSCT");
        }

/* single entry tables do not need to loop on multiple values */
        if (tt < 6) {
            po = ' ';
            pv = '=';
            pz = '>';
            ve = "";
            ze = "";
            if (vn != vn1) { pv = '!'; ve = BR; }

/* insane number of bytes gets error flag */
            if (4096 < nb) { pz = '%'; ze = BR; }

/* received total exceeding mgt nb also gets error flag */
            if (nb < nb1) { pz = '<'; ze = BR; }

#if 1
            snprintf( s, sizeof(s)-1,
                "%s    %s%c Table ID %04X PID %04X NB %s%04X %c %04X%s"
                " VN %s%02X %c %02X%s DL %X",
                tc, tx, po, tt, pid, ze, nb, pz, nb1, tc,
                ve, vn, pv, vn1, tc, dl );
#else

            snprintf( s, sizeof(s)-1,
                "%s    %s%c Table ID %04X PID %04X NB %s%04X%s"
                " VN %02X DL %X",
                tc, tx, po, tt, pid, ze, nb, tc,
                vn, dl );
#endif

            add_mgt_text( s );
            continue;
        }

/* EIT-n ? */
        if ( (tt >= 0x100) && (tt < 0x17F) ) {
            po = ' ';
            tc = BN;
            if (0 != one_eit) add_mgt_text( BG "  Event Information Tables:");
            one_eit = 0;

/* FIXME: make decision:  * is payok = 0  color is PAY_GOOD   or vice versa */
/* EIT is unmarked pending when payok clear */
            if (NULL != eit) {
                if (eit[0x7F & tt].payok == 0) {
                    po = '*';
                    tc = BG;
                }
            }
            if (CAP_NONE == cap_now) {
                po = ' ';
                if (0xFF != mgs[i].vn) {
                    po = '*';
                    tc = BG;
                }
            }

            snprintf( tx, sizeof(tx)-1, "EIT-%02X%c", 0x7F & tt, po);
        }           

/* ETT-n ? */
        if ( (tt >= 0x200) && (tt <= 0x27F) ) {
            po = ' ';
            tc = BN;
            if ( 0 != one_ett ) add_mgt_text( BC "  Extended Text Tables:");
            one_ett = 0;

/* ETT is unmarked pending when both EIT and ETT payok clear */
            if (NULL != eit) {
                if ( ett[ 0x7F & tt ].payok == 0) {
                    if ( eit[ 0x7F & tt ].payok == 0) {
                        po = '*';
                        tc = BC;
                    }
                }
            }

            if (CAP_NONE == cap_now) {
                po = ' ';
                if (0xFF != mgs[i].vn) {
                    po = '*';
                    tc = BC;
                }
            }

            snprintf( tx, sizeof(tx)-1, "ETT-%02X%c", 0x7F & tt, po);
        }

/* RRT-n ? */
        if ( (tt >= 0x301) && (tt <= 0x3FF) ) {
            po = ' ';
            tc = BN;
            if ( 0 != one_rrt ) add_mgt_text( BM "  Rating Region Tables:");
            one_rrt = 0;

/* RRT is unmarked pending when payok clear */
            if (rrt.payok == 0) {
                po = '*';
                tc = BM;
            }

            if (CAP_NONE == cap_now) {
                if (0xFF != mgs[i].vn) {
                    po = '*';
                    tc = BM;
                }
            }

            snprintf( tx, sizeof(tx)-1, "RRT-%02X%c", 0xFF & tt, po);
        }

#if 0
/* have not seen these from 2004 through 2007. maybe some cable systems? */
        if ( (tt >= 0x1400) && (tt <= 0x14FF) ) {
            if (tt == 0x1400) {
                add_mgt_text( BM "  Directed Channel Change Tables:");
                tc = BM;
                snprintf( tx, sizeof(tx)-1, "DCCT-%02X", 0xFF & tt );
            }
        }
#endif

        if (tt > 0x2000) return; /* sanity check */

        po = ' ';
        pv = '=';
        pz = '>';
        ve = "";
        ze = "";
        if (vn != vn1) { pv = '!'; ve = BR; }
        if (0xFF == vn1) tc = BN;

/* insane number of bytes gets error flag */
        if (4096 < nb) { pz = '%'; ze = BR; }

/* received total exceeding mgt nb also gets error flag */
        if (nb < nb1) { pz = '<'; ze = BR; }

        snprintf( s, sizeof(s)-1,
                BN
                "%s    %s Table ID %04X PID %04X NB %s%04X %c %04X%s"
                " VN %s%02X %c %02X%s DL %02X",
                tc, tx, tt, pid, ze, nb, pz, nb1, tc,
                ve, vn, pv, vn1, tc, dl );

/* if EIT, show hours ahead of currennt SEC3HR meridian */
        if ( (tt >= 0x100) && (tt < 0x17F) ) {
            char *p;
            p = s + strlen(s);
            sprintf( p, "  Hours %3d", 3 * (tt - 0xFF));
        }
        add_mgt_text( s );
    }               

    snprintf( s, sizeof(s)-1,
            BW " Master Guide Table: MGT bytes %08X RX bytes %08X", nbt, nbt1);
    add_mgt_text( s );
    if (mg_eit == 0) {
        add_mgt_text( BR BL "No EIT in MGT, Program Guide is Disabled" BN );
    }
    add_mgt_text(" ");
}


/* Shows Master Guide Table to see what is available with ATSC PSIP */
/* static */
void
show_master_guide_table ( void )
{
    int i, j, tp;
    unsigned char key;
    int mo;     /* mgt list offset */
    unsigned char vn;
    char *tt, pgm_id[64];
    struct sig_s *s;

    vn = mgt_vn; /* vn when guide started */

    key = 0;
    mo = 0;
    
    /* nothing to do */
    if (pkt.fmgt == 0) {
        dvrlog( LOG_INFO, "no master guide to show, pkt.fmgt 0");
        return;
    }
    refresh.mgt = 1;

    if (mgt_vn != 0xFF) {
            dvrlog( LOG_INFO, "show master guide calls build mgt text");
            build_mgt_text();
    } else {
        dvrlog( LOG_INFO, "no master guide to show, mgt_vn %02X", mgt_vn);
    }

    s = &ptc[cap_chan].sig;

/* NOTE: user lines is never actually reached, but stop loop if it is */
    for (i=0; i<user_lines;) /* i gets incremented modulo user lines */
    {
        show_status( 1, WHO );

        if ( D_MGT != display_type) break;

        j = i + mo;

        if (0 != refresh.mgt) {
                if (CAP_NONE == cap_now) {
                        tt = "ATSC MASTER GUIDE TABLE";
                        tp = columns - strlen(tt);
                        tp >>= 1;
                        if (tp < 0) tp = 0;
/* replace signal header */
                        aprintf( stderr, DCARC CEL, 2, 1);
                        aprintf( stderr, DCARC BW "%s" BN, 2, tp, tt);

                        snprintf( pgm_id, sizeof(pgm_id),
                                "LCN %d PTC %d.%d %s %s",
                                s->chan, s->ptc, s->pn, s->call, s->sid);

                        tp = columns - strlen(pgm_id);
                        tp >>= 1;
                        if (tp < 0) tp = 0;
/* and strength bar */
                        aprintf( stderr, DCARC CEL, 3, 1);
                        aprintf( stderr, DCARC BY "%s", 3, tp, pgm_id);
                }

            aprintf( stderr, "\033[%d;1H" "%s" CEL, 5+i, &mgt_text[j][0] );
        }

        i++;
        i %= user_lines;
        key = 0;
        /* end of list redraws header and put cursor where needs to be */
        if (0 == i) {

            if (0 != refresh.mgt) {
            
                if (mgt_vn != 0xFF) {

                    aprintf( stderr, DCA_MGT BW
                            "Master Guide Table         "
                             BW "Keys: " BN " [g] exit  "
                             BW "Status: " BG "* current, " BR BL "! error" BN
                             SCI CEL);

                    build_mgt_text(); /* might eat cpu */
                }

            }
            refresh.mgt--;
            if (refresh.mgt < 0) refresh.mgt = 0;

            console_getch_fn( &key );
            nanosleep( &console_read_sleep, NULL );
            if (0 == key) continue;

            refresh.mgt = 1;

            if ( 'g'   == key ) break; /* g to get in, g to get out */

            if ( '?'   == key ) show_keyhelp( mgtkeyhelp );

            if ( KB_UP == key ) mo -= 1;
            if (  '='  == key ) mo -= 1;

            if ( KB_DN == key ) mo += 1;                
            if ( '\''  == key ) mo += 1;

            if ( KB_PU == key ) mo -= user_lines;
            if ( KB_PD == key ) mo += user_lines;

            if (mo < 0) mo = 0; /* sanity limit */
            if ( (mo+user_lines) >= mgt_idx) mo = mgt_idx - user_lines;
            if (mo < 0) mo = 0; /* sanity limit */
        }
    }
}


/* add string at *s to tvct_text, if it will fit, otherwise do nothing */
/* use " " by itself when calling this to add NL, and don't put NLs in text */
/* static */
void
add_tvct_text ( char *s)
{
    char *t;

    /* ignore blanks */
    if ( 0 == s[0] ) return;

    /* NOTE: silently fails when past line max */
    if (tvct_idx < TVCT_ROWS) {
        t = &tvct_text[tvct_idx][0];
        snprintf( t, strlen(s)+1, "%s", s);
        tvct_idx++;
    }       
}

/*
 Used for VCT Extended Channel Name, PMT Component Name and Content Advisory.
 Called by build vct text. Output is limited to VCT_MSS_MAX bytes.

 payload relative pointer is r, destination for uncompressed text is t
*/
#define VCT_MSS_MAX 32
/* static */
void
build_vct_mss ( unsigned char *r, char *t )
{
    unsigned int nstr, nseg, comp, mode, nchr;
    unsigned int i,j;
    char d[512]; /* text temp destination */
    char lang[4];

    nstr = r[0];
    t[0] = 0; /* make it blank at the least */
    for (i = 0; i < nstr; i++) {
        memcpy(lang, &r[1], 3);
        lang[3] = 0;
        r += 4;
        nseg = *r++;
        for (j = 0; j < nseg; j++ ) {
            comp = *r++;
            mode = *r++;
            nchr = *r++;

            if (nchr > 0) {
                /* no compression and unicode page 0 */
                if ( (0 == comp) && (0 == mode) ) {
                    nchr++;
                    /* r does not have nul term */
                    if (nchr > 256) nchr = 256;
                    astrncpy( d, (char *)r, nchr );
/* +8 for [eng][] */
                    snprintf( t, VCT_MSS_MAX, "[%s] [%s]", lang, d);
                }

/* KPXB requires non-strict mode because they got it wrong here too */
                if ((0 == arg_strict) || ((0 != arg_strict) && (0xFF == mode)))
                {
                    if ( (comp == 1) || (comp == 2) ) {
                        if (nchr > sizeof(d)) nchr = sizeof(d);
                        huffman_decode( d, r, sizeof(d)-1, nchr, comp);
                        snprintf( t, VCT_MSS_MAX, "[%s] [%s]", lang, d);
                        /* +8 for [eng][] */
                    }
                }
                /* something else */
                if ( (comp > 2) || ((mode > 0) && (mode < 255)) )
                {
                    snprintf( t, VCT_MSS_MAX, "[%s] L%02X C%02X M%02X",
                            lang, nchr, comp, mode);
                }
            } else {
                    snprintf( t, VCT_MSS_MAX, "[%s] L%02X C%02X M%02X",
                            lang, nchr, comp, mode);
            }
        }
    }
}


/*
 parse MPEG2 PMT descriptor and add lines of text to vct_text.
 these are shown after PMT PID line in [v] key Virtual Channel page.
*/
/* static */
void
build_mpeg2_descriptor ( unsigned char *r, unsigned int indent )
{
    char *t;
    char s[128];
    char ct[512];
    /* indent text */
    char it[16];
    unsigned char n, l;
    unsigned int i, j;
    char *tc = BM;      /* tag color */
    
    memset( it, 0, sizeof(it) );
    if ( (0 != indent) && (indent < sizeof(it)) ) {
        memset(it, ' ', indent);
    }
    
    t = BR"DESCRIPTOR UNPARSED"BN;
    n = r[0]; /* descriptor number */
    l = r[1]; /* desriptor length */

    if ((0 == n) || (0 == l)) return; /* bad descriptor */
/*
    snprintf( s, sizeof(s)-1, BW "   Tag %02X DLen %02X" BN, n, l);
    add_tvct_text( s );
    return;    
*/
    r += 2; /* descriptor data starts here */

/********************************************************** MPEG descriptors */
    switch ( n ) {

        case 2:
            t = "Video Stream";
            {
                unsigned char mfr, frc, m1o, cpf, spf;
                char *frct, *mfrt;
                snprintf( s, sizeof(s)-1, 
                        "%s%sTag %02X DLen %02X %s: "BN, it, tc, n, l, t);
                add_tvct_text( s );

                mfr = 1 & (r[0]>>7); /* single or multiple frame rates */
                frc = 15 & (r[0]>>3); /* frame rate code */
                m1o = 1 & (r[0]>>2); /* mpeg 1 only */
                cpf =  1 & (r[0]>>1); /* constrained parameters flag */
                spf =  1 & r[0]; /* still picture flag */

                frct = "Reserved";
                if (0 == mfr) {
                    mfrt = "Single";
                    if (0 == frc) frct = "Forbidden";
                    if (1 == frc) frct = "23.976";
                    if (2 == frc) frct = "24";
                    if (3 == frc) frct = "25";
                    if (4 == frc) frct = "29.97";
                    if (5 == frc) frct = "30";
                    if (6 == frc) frct = "50";
                    if (7 == frc) frct = "59.94";
                    if (8 == frc) frct = "60";
                } else {
                    mfrt = "Multiple";
                    if (0 == frc) frct = "Forbidden";
                    if (1 == frc) frct = "23.976";
                    if (2 == frc) frct = "24/23.976";
                    if (3 == frc) frct = "25";
                    if (4 == frc) frct = "29.97/23.976";
                    if (5 == frc) frct = "30/23.976/24/29.97";
                    if (6 == frc) frct = "50 25";
                    if (7 == frc) frct = "59.94/23.976/29.97";
                    if (8 == frc) frct = "60/23.976/24/29.97/30/59.94";
                }

                snprintf( s, sizeof(s)-1, "%s %s Frame Rate %s", it, mfrt, frct);
                add_tvct_text( s );
                
                snprintf( s, sizeof(s)-1,
                    "%s MPEG1 Only %u Constrained %u Still Picture %u",
                    it, m1o, cpf, spf);
                add_tvct_text( s );

                /* not likely for terrestrial ATSC or cable */
                if (0 != m1o) {
                    /* check reserved bits */
                    if (0x1F == (0x1F & r[2])) {
                        unsigned char pli, cf, fre;
                        pli = r[1];
                        cf  = 3 & (r[2]>>6);
                        fre = 1 & (r[2]>>5);
                        snprintf( s, sizeof(s)-1,
                                    "%s MPEG1 Profile and Level %02X "
                                    "Chroma Format %01X Frate Rate Ext %1X",
                                    it, pli, cf, fre);
                        add_tvct_text( s );
                    }
                }
                return;
            }
            break;

/* MPEG audio not seen in ATSC, see case 0x81 for A/52 audio instead */
        case 3:
            t = "MPEG2 Audio Stream";
            break;

        /* not seen in ATSC */
        case 4:
            t = "Hierarchy";
            break;

        case 5:
            t = "Registration";
            snprintf( s, sizeof(s)-1,
                    "%s%sTag %02X DLen %02X %s: " BN
                    " Format ID [%c%c%c%c], ID Len %03X",
                    it, tc, n, l, t, r[0], r[1], r[2], r[3], l-4);
            add_tvct_text( s );
            return;
            break;

        /* more or less where you can cut. usually alignment type 1 */
        case 6:
            t = "Stream Alignment";
            {
                char *sa;
                unsigned char at = 0;
                sa = "Reserved";
                if (l == 1) at = r[0];
                if (1 == at) sa = "SLI, PIC, GOP or SEQ"; /* seen in ATSC */
                if (2 == at) sa = "PIC, GOP or SEQ";
                if (3 == at) sa = "GOP or SEQ";
                if (4 == at) sa = "SEQ";
                snprintf( s, sizeof(s)-1,
                        "%s%sTag %02X DLen %02X %s: " BN "%02X %s",
                        it, tc, n, l, t, at, sa);
                add_tvct_text( s );
                return;
            }    
            break;

        /* not seen in ATSC, but sure could be useful */
        case 7:
            t = "Target Background Grid";
            break; /* write me if ever seen */

        /* not seen in ATSC, but sure could be useful */
        case 8:
            t = "Video Window";
            break; /* write me if ever seen */

        /* not seen in ATSC ? */
        case 9:
            t = "Conditional Access";
            if ( 0xE0 == (0xE0 & r[2] ) ) { /* reserved bits check */
                unsigned short casid, capid;
                casid = (r[0]<<8) | r[1];
                capid = 0x1FFF & ( (r[2]<<8) | r[3] );
                r += 6; /* skip to private data */
                snprintf( s, sizeof(s)-1, "%s%sTag %02X DLen %02X %s: "BN
                        " CA system ID %04X CA PID %04X",
                        it, BR, n, l, t, casid, capid);
                add_tvct_text( s );
//              if (l > 6) add_tvct_text( "  has private data" );
                return;
            }
            break;

        case 10:
            t = "ISO 639 Language(s)";
            {
                /* no reserved bits to check */
                char lang[4];
                unsigned char at; /* audio type */
                char *lat;
                /*
                 spec mentions can be multiple audio lang descriptors here
                 but this only gets last 3 bytes
                */
                for (i = 0; i < (l - 1); ) { /* manually bump i */
                    memcpy( lang, r, 3 );
                    lang[3] = 0;
                    r += 3;
                    i += 3;
                }               
                
                /* last byte is audio type */
                at = r[0];
                lat = "Reserved";
                if (0 == at) lat = "ATSC Normal Audio";
                if (1 == at) lat = "Clean Effects";
                if (2 == at) lat = "Hearing Impaired";
                if (3 == at) lat = "Visual Impaired Commentary";
                snprintf( s, sizeof(s)-1,
                        "%s%sTag %02X DLen %02X %s: " BN "[%s] %02X %s",
                        it, tc, n, l, t, lang, at, lat);
                add_tvct_text( s );
                return;
            }
            break;

        case 11:
            t = "System Clock";
            /* reserved bits must be set to qualify for rest */
            if ( (0x40 == (0x40 & r[0]))
              && (0x1F == (0x1F & r[1])) ) {
                unsigned char ecri, cai, cae;
                ecri = 1 & (r[0]>>7);   /* external clock reference indicator */
                cai = 0x3F & r[0];      /* clock accuracy integer */
                cae = 7 & (r[1]>>5);    /* clock accuracy exponent */
                snprintf( s, sizeof(s)-1, "%s%sTag %02X DLen %02X %s: " BN
                        "External %s, Accuracy %u^%u",
                        it, tc, n, l, t,
                        (0==ecri)?"NO":"YES",
                        cai, cae);
                add_tvct_text( s );
                return;
            }
            break;

        case 12:
            t = "Multiplex Buffer Utilization";
            {
                unsigned char bv;
                unsigned short ltwl, ltwu;

                ltwl = ltwu = 0;
                
                bv = 1 & (r[0] >> 7);   /* bound valid flag */

                /* valid and reserved set? */
                if ( (1 == bv) && (0x80 == (0x80 & r[2])) ) {
                    ltwl = 0x7FFF & ( (r[0]<<8) | r[1] );
                    ltwu = 0x7FFF & ( (r[2]<<8) | r[3] );
                }
                snprintf(s, sizeof(s)-1,
                        "%s%sTag %02X DLen %02X %s: " BN "Valid %u",
                        it, tc, n, l, t, bv);
                add_tvct_text( s );

                /* don't bother if not valid */
                if (1 == bv) {
                    snprintf( s, sizeof(s)-1,
                      "%s Legal Time Window Lower Bound %u Upper Bound %u",
                      it, ltwl, ltwu);
                    add_tvct_text( s );
                }
                return;
            }
            break;

        case 13:
            t = "Copyright";
            snprintf(s, sizeof(s)-1,"%s%sTag %02X DLen %02X %s",
                        it, tc, n,l,t);
            add_tvct_text( s );    
            return;
            break;

        case 14:
            t = "Maximum Bitrate";
            if ( 0xC0 == (0xC0 & r[0]) ) {
                unsigned int mbr;
                char m[32];
                mbr = 0x3FFFFF & ( ( r[0] << 8 ) | r[1] );
                lltoasc( m, (long long) mbr * 400LL );
                snprintf( s, sizeof(s)-1, 
                        "%s%sTag %02X DLen %02X "BN"%s: %s bits/second",
                                it, tc, n, l, t, m);
                add_tvct_text( s );
                return;
            }           
            break;

/* private data, not in 13818-1 draft 1994 jun 10, in nov 13 */
        case 15:
            {
                unsigned char pd[16];
                t = "Private Data";
                if (0 != l) memcpy( pd, r, l);
                pd[l] = 0;
                snprintf( s, sizeof(s)-1, "%s%sTag %02X DLen %02X %s: " BN 
                            "%s", it, tc, n, l, t, pd);
                add_tvct_text( s );
                return;
            }
            break;

/* smoothing buffer, not in 13818-1 draft 1994 jun 10, in nov 13 */
        case 0x10:
            t = "Smoothing Buffer";
            {
                unsigned int sblr, sbz;
                char lrt[32];
                if ( (0xC0 == (0xC0 & r[0]))
                 &&  (0xC0 == (0xC0 & r[3])) ) {
                    sblr = 0x3FFFFF & ( (r[0]<<16) | (r[1]<<8) | r[2] );
                    sbz  = 0x3FFFFF & ( (r[3]<<16) | (r[4]<<8) | r[5] );
                    lltoasc( lrt, sblr * 400 );
                    snprintf( s, sizeof(s)-1, 
                            "%s%sTag %02X DLen %02X %s: " BN
                            "Leak Rate %s bits/s Size %u",
                            it, tc, n, l, t, lrt, sbz);
                    add_tvct_text( s );
                }
                return; 
            }
            break;

        case 0x11:
            t = "System Target Decoder";
            break;

        case 0x12:
            t = "I P B Frame Layout";
            break;

/************************************************************ ATSC specific */
        case 0x52:
            t = "SCTE-35 Cue ID";
            break;

        case 0x80:
            t = "Stuffing";
            break;

        case 0x81:
            t = "AC-3 Audio";
            {
/*              unsigned char lc, lc2, mid, asvcf, tl, tc, tb;  */
                unsigned char src, bsid, brc, sm, bsm, nc, fsv;
                char *srt, *brt, *brt1, *smt, *nct, *lft, *bsmt;
                src = 0x07 & (r[0]>>5);
                srt = "Reserved";
                if (0 == src) srt = "48 kHz";
                if (1 == src) srt = "44.1 kHz";
                if (2 == src) srt = "32 kHz";
                /* must be the can't decide section */
                if (4 == src) srt = "48 or 44.1 kHz";
                if (5 == src) srt = "48 or 32 kHz";
                if (6 == src) srt = "44.1 or 32 kHz";
                if (7 == src) srt = "48, 44.1 or 32 kHz";

                bsid= 0x1F & r[0];
                brc = 0x3F & (r[1]>>2); /* bit rate code */
                sm  = 0x03 & r[1]; /* surround mode, docs also name it dsumod? */
                bsm = 0x07 & (r[2]>>5);
                nc  = 0x0F & (r[2]>>4);
                fsv  = 0x01 & r[2]; /* full audio main service */

                brt1 = "Exact";
                if (0x20 == (0x20 & brc)) brt1 = "Maximum";
                brc &= 0x1F; /* limit it now brt1 has been extracted */

                brt = "Reserved";
                if ( 0 == brc) brt = " 32";
                if ( 1 == brc) brt = " 40";
                if ( 2 == brc) brt = " 48";
                if ( 3 == brc) brt = " 56";
                if ( 4 == brc) brt = " 64";
                if ( 5 == brc) brt = " 80";
                if ( 6 == brc) brt = " 96";
                if ( 7 == brc) brt = "112";
                if ( 8 == brc) brt = "128";
                if ( 9 == brc) brt = "160";
                if (10 == brc) brt = "192";
                if (11 == brc) brt = "224";
                if (12 == brc) brt = "256";
                if (13 == brc) brt = "320";
                if (14 == brc) brt = "384";
                if (15 == brc) brt = "448";
                if (16 == brc) brt = "512";
                if (17 == brc) brt = "576";
                if (18 == brc) brt = "640"; /* want to hear */
                

                smt = "Reserved";
                if (0 == sm) smt = "Not Indicated";
                if (1 == sm) smt = "No Dolby Surround";
                if (2 == sm) smt = "Dolby Surround";
                
                nct = "Reserved";
                lft = "";
                if ( 8 == (8 & nc)) lft = " + LFE";
                if ( 0 == nc) nct = "1+1";
                if ( 1 == nc) nct = "1/0";
                if ( 2 == nc) nct = "2/0";
                if ( 3 == nc) nct = "3/0";
                if ( 4 == nc) nct = "2/1";
                if ( 5 == nc) nct = "3/1";
                if ( 6 == nc) nct = "2/2";
                if ( 7 == nc) nct = "3/2";
                /* lfe is extra channel but not in the text count */
                if ( 8 == nc) nct = "1";
                if ( 9 == nc) nct = "<=2";
                if (10 == nc) nct = "<=3";
                if (11 == nc) nct = "<=4";
                if (12 == nc) nct = "<=5";
                if (13 == nc) nct = "<=6";

                bsmt = "Reserved";
                if ( 0 == bsm) bsmt = "Main Audio: Complete Main";
                if ( 1 == bsm) bsmt = "Main Audio: Music and Effects";
                if ( 2 == bsm) bsmt = "Associated: Visually Impaired";
                if ( 3 == bsm) bsmt = "Associated: Hearing Impaired";
                if ( 4 == bsm) bsmt = "Associated: Dialogue";
                if ( 5 == bsm) bsmt = "Associated: Commentary";
                if ( 6 == bsm) bsmt = "Associated: Emergency";
                if ( 7 == bsm) bsmt = "Associated: Voice Over";

                snprintf( s, sizeof(s)-1, "%s%sTag %02X DLen %02X %s: " BN
                        "Sample Rate %s, bsid %02X",
                        it, tc, n, l, t, srt, bsid);
                add_tvct_text( s );
                snprintf( s, sizeof(s)-1, "%s %s Rate %s kbit/s Surround %s",
                        it, brt1, brt, smt);
                add_tvct_text( s );
                snprintf( s, sizeof(s)-1,
                        "%s Service %s, Channels %s %s Full Service %u",
                        it, bsmt, nct, lft, fsv);
                add_tvct_text( s );
                return;
            }
            break;

        case 0x86:
            t = "Caption Service";
            if ( 0xC0 == (0xC0 & r[0]) ) { /* reserved bits check */
                unsigned char nos, cct, l21f, csn, er, war;
                char lang[4];
                char *cctt;
                char cctx[64]; /* extra info */
                char ccty[64]; /* type */
                
                nos = 0x1F & r[0];
                r += 1; /* skip parsed */
                snprintf(s, sizeof(s)-1, "%s%sTag %02X DLen %02X %s: " BN
                        "Number of CC Services %u",
                        it, tc, n, l, t, nos);

                add_tvct_text( s );

                csn = 0;
                for (i = 0; i < nos; i++) {
                    if ( 0x40 == (0x40 & r[3]) ) { /* reserved bits */
                        memcpy( lang, r, 3 );
                        lang[3] = 0; /* 3 char lang code per ISO 639.2/B */
                        r += 3; /* skip lang */
                        cct = 1 & (r[0]>>7);
                        s[0] = 0;

                        *cctx = 0;
                        *ccty = 0;

                        /* closed captioning for show virtual channels */
                        if (0 == cct) {
                        /* EIA/CEA-608-B. that's NTSC */
                            if ( 0x3E == (0x3E & r[0]) ) { /* reserved */
                                csn++;
                                l21f = 1 & r[0];
                                snprintf(ccty, sizeof(ccty)-1,
                                         "     NTSC  # %d [%s] "
                                         "Type NTSC Line21 %s Field",
                                        csn, lang,
                                        (l21f == 0) ? "Even" : " Odd" );
                            }                           
                        } else {
                            /* EIA-708-A is ATSC ATVCC */
                            csn = 0x3F & r[0];
                            cctt = "ATVCC";
                            snprintf(ccty, sizeof(ccty)-1,
                                     "     ATVCC # %d [%s] Type %s",
                                     csn, lang, cctt);
                        }

                        if ( (0x3F == (0x3F & r[1])) && (0xFF == r[2]) ) {
                            er = 1 & (r[1]>>7);
                            war = 1 & (r[1]>>6);
                            snprintf(cctx, sizeof(cctx)-1,
                                ", Easy Reader %u Wide Aspect %u", er, war); 
                            r += 3;
                        }                           
                        snprintf( s, sizeof(s)-1, "%s%s", ccty, cctx);
                        add_tvct_text( s );
                    }
                }
                return;
            }
            break;

        case 0x87:
            t = "Content Advisory";
            if ( 0xC0 == (0xC0 & r[0]) ) {
                unsigned char rrc, rr, rd, rdj, rv, rdl;
                add_tvct_text( s );
                rrc = 0x3F & r[0];
                snprintf(s, sizeof(s)-1, "%s%sTag %02X DLen %02X %s: " BN
                        "Rating Region Count %u",
                        it, tc, n, l, t, rrc);
                add_tvct_text( s );
                r += 1; /* skip to loop vals */
                for (i = 0; i < rrc; i++) {
                    rr = r[0]; /* rating region */
                    rd = r[1]; /* rated dimensions */

                    /* one dimension will try to print on one line */
                    snprintf(s, sizeof(s)-1,
                            "%s Region %u Dimensions %u",
                            it, rr, rd);
                    add_tvct_text( s );
                            
                    r += 2;
                    for (j = 0; j < rd; j++) {
                        if ( 0xF0 == (0xF0 & r[1]) ) {
                            rdj = r[0]; /* rating dimension j */
                            rv = 0xF & r[1]; /* rating value */
                            snprintf(s, sizeof(s)-1,
                                "%s  Dimension %u Value %u",
                                it, rdj, rv);
                            add_tvct_text( s );
                            r += 2;
                        }
                    }
                    rdl = r[0];
                    r++;
                    if (rdl != 0) {
                        char rt[512];
                        build_vct_mss( r, rt );
                        snprintf(s, sizeof(s)-1, "%s    Rating: %s", it, rt);
                        add_tvct_text( s );
                    }
                }
                return;
            }
            break;


/* parsed in VCT but warn with blink if they show as mpeg descriptor */
        case 0xA0:
            t = BL "ECN" BN;
            break;

        case 0xA1:
            t = BL "SVLOC" BN;
            break;

        case 0xA2:
            t = BL "TSS" BN;
            break;
/* end of parsed in VCT descriptors */

        case 0xA3:
            t = BM "Component Name" BN;
            build_vct_mss( r, ct );
            snprintf( s, sizeof(s)-1, "%s%sTag %02X DLen %02X %s: %s",
                        it, BC, n, l, t, ct);
            add_tvct_text( s );
            return;
            break;

/* warn with blink for these unsupported and so far unseen types */
        case 0xA8:
            t = BL "DCC Departing Request" BN;
            break;

        case 0xA9:
            t = BL "DCC Arriving Request" BN;
            break;                  

/* warn with blink to advertise the imminent peril to the right of fair use */
        case 0xAA:
            t = BR BL "Redistribution Control - Fair Use Rights In Dire Jeopardy" BN;
            break;
/****************************************************************************/

        /* handle 0-1, 16-63, 64 and rest not done above */
        default:
            /*
              these have nothing to parse
              well not completely true,
              there are some odd descriptors showing up
            */
            if (n < 2) t = "Reserved";
            if ((n >= 16) && (n <= 63)) t = "ISO/IEC 13818-1 Reserved";
            if (n >= 64) t = "User Private";
            break;
    }

/* yellow is not parsed, no colon either */
    snprintf( s, sizeof(s)-1, "%s%sTag %02X DLen %02X %s ", it, BY, n, l, t);
    add_tvct_text( s );    
}




/* build vc text calls this */
/* A/65b Table 6.26 Service Location Descriptor for n'th Virtual Channel */
/* static */
void
build_vct_svloc ( unsigned int n )
{
    unsigned short pcrpid;              /* program clock reference pid */
    unsigned short numes;               /* number of elementary streams */
    unsigned short espid;               /* elementary stream pid */
    unsigned char est;                  /* elementary stream type */
    char eslang[4];             /* elementary stream language */
    char estx[32];              /* elementary stream type text */
    char t[256];                /* temp text build */
    unsigned char i, a;
    unsigned int j, k;
    char *c;                    /* color based on cap vc & va */
    char *p;                    /* es type, vct or pat */
    unsigned char dtag, dlen;
    struct sig_s *s;
    int svc, sva, svp;

    s = &ptc[ cap_chan ].sig;

    svp = cap_pn;
    sva = cap_va;
    if (CAP_NONE == cap_now) {
        svp = s->pn;
        sva = s->va;
    }
    svc = find_vc_pgm( svp, WHO);

/* NO NTSC or Hidden
    if ( (0 == vc[n].pn) || (65535 == vc[n].pn) )
        return;
*/

    /* flag for not parsed */
    snprintf( estx, sizeof(estx)-1, "%s", "?parse?");

    pcrpid = vc[n].pcrpid;

    numes = vc[n].vctes;
    if (numes < vc[n].pmtes) numes = vc[n].pmtes;
/* so vc audio select works in MPEG only fallback */
    vc[n].pmtes = numes;

    c = BN; /* not cap */

/* NTSC does not appear on list anymore
    if (vc[n].pn < 65535) {
        if (n == svc) c = BG;
    }
*/
    if (-1 == svp)
        if (-1 == svc)
            c = BG;     /* cap all overrides colors */

    if (-1 < svp)
        if (svp == vc[n].pn)
            c = BG;     /* cap program overrides color */

    p = "VCT";

/* red indicates missing PMT PID */
#if 0
    if (0 == strncmp( c, BG, 8))
        if (0 == pids[vc[n].pmtpid]) c = BR;
#endif

    if ( (svp > 0) && (n != svc) ) c = BN; /* cap vc overrides color */
    snprintf( t, sizeof(t)-1,
                "%s   %s Program Map PID %04X Vn %02X "
                "Clock Ref PID %04X DLen %03X ES Num %u:" BN,
                c, p, vc[n].pmtpid, vc[n].pmtvn, pcrpid,
                vc[n].pilen, vc[n].vctes);

    add_tvct_text( t );

    /* add an extra line to indicate PMT ES is different from VCT ES */
    if (vc[n].pmtes > vc[n].vctes) {

        c = BY; /* cap all overrides colors */

        p = "PMT";

/* red indicates missing PMT PID */
#if 0
        if (0 == strncmp( c, BG, 8))
            if (0 == pids[vc[n].pmtpid]) c = BR;
#endif

        snprintf( t, sizeof(t)-1,
                "%s   %s Program Map PID %04X Vn %02X "
                "Clock Ref PID %04X DLen %03X ES Num %u:" BN,
                c, p, vc[n].pmtpid, vc[n].pmtvn, pcrpid,
                vc[n].pilen, vc[n].pmtes);

        add_tvct_text( t );
    }

    if (0 != vct_dtl) {

        snprintf( t, sizeof(t)-1,
                     BM "    PMT DESCRIPTORS: PID %04X DLen %02X:" BN,
                     vc[n].pmtpid, vc[n].pilen );
        add_tvct_text( t );

        for (j = 0; j < ( 0x3FF & vc[n].pilen); ) {
            /* program info has PMT descriptors */
            dtag = vc[n].pidesc[j];
            dlen = vc[n].pidesc[j+1];
            build_mpeg2_descriptor( &vc[n].pidesc[j], 4 );
            j += 2;
            j += dlen; /* to next descriptor until pilen */
        }
        add_tvct_text( " " );
    }

    a = 0;
    for (i=0; i<numes; i++) {
        if (numes > 7 ) {
            return; /* 8 VC limit */
        } else {
            memcpy( eslang, &vc[n].eslang[i][0], 4);
            eslang[3] = 0; /* NUL term */
            est = vc[n].estype[i];
            espid = vc[n].espid[i];

            if (-1 < svp)
                if ( n == svc)
                    c = BG;

            p = "VCT";

            /* full cap colors yellow unparsed non-video non-audio */
            if ( (-1 == svp) && (0x02 != est) && (0x81 != est) )
                c = BY;

            if (i >= vc[n].vctes) {
                p = "PMT";
                c = BM;
            }

            snprintf( estx, sizeof(estx)-1,  "%s A/90 Type [%02X]", p, est);

            if (0x02 == est) {
                snprintf( estx, sizeof(estx)-1, "%s MPEG Video # %d", p, n);
            }

            if (0x81 == est) {
                snprintf( estx, sizeof(estx)-1, "%s A/52 Audio # %d", p, a);
                if ( ( -1 < svp) && (n == svc) && (a != sva) ) c = BN;
                a++;
                /* color audio being capped, but reset color if not this vc */
            }

/* red indicates missing ES PIDs */
#if 0
            if (0 == strncmp( c, BG, 8))
                if (0 == pids[vc[n].espid[i]]) c = BR;
#endif
            snprintf( t, sizeof(t)-1,
                "%s   %s [%3s] ES # %d Type %02X ES PID %04X ES ILen %03X" BN,
                c, estx, eslang, i, est, espid, vc[n].esilen[i]);
            add_tvct_text( t );
            
            if ( (0 != vct_dtl)
              && (0 != vc[n].pmtpid)
              && (0 != vc[n].esilen[i]) )
            {
                for (k = 0; k < (0x3FF & vc[n].esilen[i]); ) {
                    /* elementary stream descriptors */
                    dtag = vc[n].esdesc[i][k];
                    dlen = vc[n].esdesc[i][k+1];

                    build_mpeg2_descriptor( &vc[n].esdesc[i][k], 4);

                    k += 2;
                    k += dlen; /* to next descriptor until pilen */
                }
                add_tvct_text( " " );
            }
        }
    }                                   
}



/*
 r points to start of descriptors.
   vct may have: ext chan name, svc loc, time shift svc
 do until len exhausted
 n is vc[n] for svloc
*/
/* static */
void
build_vct_descriptor ( unsigned char *r, unsigned int n, unsigned short vcdlen )
{
    unsigned char dtag, dlen;
    char s[128];
    unsigned short len = vcdlen;

/* should not be any descriptors for HIDDEN or NTSC?
    char *t;
    if ( (0 == vc[n].pn) || (vc[n].pn == 65535) ) return;
*/
    
/* uncomment this and you won't see the text below if bad descriptor

    if ((0 == r[0]) || (0 == r[1]))
        return;

*/

    dtag = dlen = 0;
    len &= 0x3FF; /* boundary force, r stays within .vcdesc[1024] */

    if (0 != vct_dtl) {
        snprintf( s, sizeof(s)-1,
            BC "  VCT DESCRIPTORS: DLen %02X ADLen %02X" BN,
            len, vc[n].adl);
        add_tvct_text( s );
    }

    while ( len > 0 ) {
        if ((0 == r[0]) || (0 == r[1])) return; /* bad descriptor */
        dtag = *r;
        r++;
        dlen = *r;
        r++;    
        len -= 2;

        switch( dtag ) {

            /* extended channel name descriptor is mulitple string structure */
            case 0xA0:
                if (0 != vct_dtl) {
                    char ecn[512];
                    build_vct_mss( r, ecn );
                    snprintf( s, sizeof(s)-1,
                        "    %sTag %02X DLen %02X "
                        "Ext Channel Name: " BN "%s", BC, dtag, dlen, ecn );
                    add_tvct_text( s );
                }
                break;

            /* service location descriptor */
            case 0xA1:
                if (0 != vct_dtl) {
                    snprintf( s, sizeof(s)-1,
                        "    %sTag %02X DLen %02X "
                        "Service Location:" BN, BC, dtag, dlen );
                    add_tvct_text( s );
                }
                build_vct_svloc( n );
                break;

            /* time shifted service descriptor, nop currently */
            case 0xA2:
                snprintf( s, sizeof(s)-1,
                        "    %sTag %02X DLen %02X "
                        "Time Shifted Service:", BY, dtag, dlen );
                add_tvct_text( s );
                break;

            /* alert for anything not right */
            default:
                snprintf( s, sizeof(s)-1, 
                        BY "   *Tag %02X DLen %02X ignored" BN, dtag, dlen);
                add_tvct_text( s );
                break;
        }
        r += dlen;
        len -= dlen;
    }
}




/******************************************************************** VCT TEXT
 build an array of text lines with info from VCT and PMT.
 This gives info on which PIDs are for which virtual channel stream.
 It also gives you details on Program Map Tables and stream descriptors.
*/
/* static */
void
build_vc_text ( void )
{
    unsigned short sl, adl;
    unsigned char vn;
/*    unsigned char cni, sn, lsn, pv, ncs; */
    unsigned char i, j;
    unsigned int k;
    short tsi;
    char t[256]; /* temp text string */
    char *c; /* color capturable vcs */
    int svc, sva, svp;
    struct sig_s *s;

    s = &ptc[ cap_chan ].sig;
    svp = cap_pn;
    sva = cap_va;
    if (CAP_NONE == cap_now) {
        svp = s->pn;
        sva = s->va;
    }
    svc = find_vc_pgm( svp, t);

    advrlog( LOG_INFO, "build vc text vcncs %d p %d v %d a %d",
            vc_ncs, svp, svc, sva);

    /* vc_ncs should not be zero if you want to display anything */
    if (vc_ncs < 1) return;

    /*(0 == pkt.pmt) && (0 == pkt.tvct) ) return; */

    sl = tsi = adl = 0;
/*    vn = cni = sn = lsn = pv = ncs = 0; */
    vn = 0xFF;
    i = j = 0;

/*    if ( (0 < pkt.tvct) && (0 < pkt.pat) ) return; */
    
    if (vct_ncs > 0) {
        unsigned char *r;
        r = vct.payload;
        sl = ( ( 0x0F & r[1] ) << 8 ) | r[2];
        tsi= ( r[3] << 8 ) | r[4];
        vn = 0x1F & (r[5]>>1);
        if (CAP_NONE == cap_now) vn = 0xFF;

/* rest aren't used
        cni = 1 & r[5];
        sn = r[6];
        lsn = r[7];     
        pv = [8];
        ncs = r[9];
*/
    }
    
    /* right now have 50 lines to work with. bump tvct_text if need more */
    memset( tvct_text, 0, sizeof(tvct_text) );
    tvct_idx = 0;
    /* ncs = vct_ncs; */

#if DEBUG
    snprintf(t, sizeof(t)-1, "vct ncs %d pat ncs %d vc ncs %d",
                vct_ncs, pat_ncs, vc_ncs);
    add_tvct_text( t );
#endif

    if (0 != vct_ncs) {
        snprintf( t, sizeof(t)-1,
                BW "VCT Vn %02X SLen %03X Channels %d" BN,
                vn, sl, vct_ncs );

    } else {

/* red indicates missing VCT */
        snprintf( t, sizeof(t)-1, "%s",
                    BR "VCT NONE MPEG2TS PAT+PMT ONLY" );
    }
    add_tvct_text( t );

    if (0 != pat_ncs) {
        snprintf( t, sizeof(t)-1,
                BW "PAT Vn %02X SLen %03X Programs %d" BN,
                pat.vn, pat.sl, pat_ncs );
        add_tvct_text( t );
    }

/* NO: faulty VCT gets overridden by PAT VC list */
/*    if (vct_ncs < pat_ncs) ncs = pat_ncs; */

    add_tvct_text( " " );

    for (i=0; i < vc_ncs; i++)
    {
        char ct[32];    /* program number or channel type */
        char *mm = "";  /* modulation mode */
        char *el = "";  /* etm location text */
        char *st = "";  /* service type */
        char *pw = "";  /* PAT warning of missing data */
        char *cn = "";  /* VCT callsign or PAT TSID lookup of same */
        ct[0] = 0;

        /* set vc colors based on sig->vc sig->va status and program */
        c = BN; /* not cap */

        if (-1 == svc) c = BG; /* cap all vc */

        if ( (vc[i].pn > 0) && (vc[i].pn < 65535) ) {
            if (i == svc) c = BG; /* cap this */
        }

/* QAM256 is close enough until can query device status */
        if ((0 != arg_cable) & (0 == vc[i].mode))
                vc[i].mode= 3;

        /* transmission mode */
        switch( vc[i].mode ) {
            case 1:  mm = "NTSC"; c = BM;   break;
            case 2:  mm = "QAM64";  break;
            case 3:  mm = "QAM256"; break;
            case 4:  mm = "VSB8";   break;
            case 5:  mm = "VSB16";  break;
            default: mm = "rsvd";   break;
        }
                
        /* extended text message location */
        switch( vc[i].etm ) {
            case 0:  el = "None"; break;
            case 1:  el = "PSIP"; break;
            case 2:  el = "TSID"; break;
            default: el = "rsvd"; break;
        }

        /* service type */
        switch( vc[i].svct ) {
            case 1:  st = "NTSC";       break;
            case 2:  st = "ATSC DTV";   break;
            case 3:  st = "ATSC Audio"; break;
            case 4:  st = "ATSC Data";  break;
            default: st = "rsvd";       break;
        }

        if (0xFFFF == vc[i].pn) {
            snprintf( ct, sizeof(ct)-1, "Analog TV");
            c = BM;
        }

        if (0 == vc[i].pn) {
            snprintf( ct, sizeof(ct)-1, "  HIDDEN ");
            c = BR;
        }
        /*
         channel types, ATSC.PN, NTSC or HIDDEN is disabled
         defaul to ATSC color then fallback
        */
        if (0 == *ct) { /* nothing else set it, so set it now */
            char pt[8];
            snprintf( pt, sizeof(pt)-1, "%d", vc[i].pn);
            snprintf( ct, sizeof(ct)-1, BW "Pgm %-5s %s", pt, c);
        }

/* vct specific */
/* TSID/callsign lookup not done in ATSC. Uses component name or VCT name */
        if (i < vct_ncs) {
            snprintf( t, sizeof(t)-1,
                    BG "ATSC %sChn %d %s TSID %04X [%-7s] %d.%d "
                    "%dx%d Mode %s ETM %s",
                    c, 1 + i, ct, vc[i].tsid, vc[i].name,
                    vc[i].major, vc[i].minor, vc[i].hres, vc[i].vres, mm, el );
            add_tvct_text( t );

            if (0 != vct_dtl) {
                snprintf( t, sizeof(t)-1,
                    "%s VCT Access Control %d Hidden %d Hide Guide %d "
                    "Service Type %s Source %d",
                    c, vc[i].actrl,
                    vc[i].hide, vc[i].hideg, st, /* vc[i].svct, */
                    (vc[i].src) );
                add_tvct_text( t );
            }
        }

/* if program is hidden there is no other data so insert separator */

        if (0 == vc[i].pn) {
            add_tvct_text( " " );
            if (0 != vct_dtl) /* detail needs an extra separator */
                add_tvct_text( " " );
        }

        /* show VCT descriptors if VCT exists and VC descriptor len not zero */
        if ( (i < vct_ncs)
          && (0 < vc[i].vcdlen)
          && (vc[i].vcdlen < 1021) )
        {
            build_vct_descriptor( vc[i].vcdescr, i, vc[i].vcdlen );
            /* no more descriptors */
            add_tvct_text( " " );
        }

/* output redux: limit duplicate PAT output below until after VCT entries.
   If VCT exists, extra PAT entries will be added to VCT at vc[vct_ncs] and
   vc_ncs is adjusted to reflect larger number of entries in PAT
   If no VCT exists, the PAT vc order will reflect the PAT accurately
 */
        if ( (i < vct_ncs) 
            /* && (i == pat_ncs) */
            ) continue;


        cn = vc[i].cname; /* try to use component name if available */

/* FIXME: because of the confusion on cable where they sometimes send the
   tvct and cvct, it may be best to ignore both of them and use pat+pmt
*/
        if ((vct_ncs > 0) && (i >= vct_ncs))    pw = "  NOT IN VCT";
        if (0 == vc[i].pmtes)                   pw = "* NO PMT INFO";
        if (0 != vc[i].ca)                      pw = "* SCRAMBLED";

/* stream type 2 is first estype from PMT, if it has a video entry */
        if (CAP_NONE != cap_now) {
            if (2 == vc[i].estype[0]) {
                if (0 == pids[vc[i].espid[0]]) {
                    pw = "* NO VIDEO PID";
                }
            }
        }

/* don't show if no details and problem text was set */
        if (0 == vct_dtl)
            if ('*' == *pw)
                continue;
        if ('*' == *pw) c = BR;

/* Make users hit [d]etails to see other VC's. This is the new default
   for the logical channel numbering scheme to support cable and satellite.
   Each scanlist entry should point to what find stations located.
   That's not to say you can't go back to the old way by selecting the VC.
*/
        if  ( (0 == vct_dtl) && (s->pn != vc[i].pn) ) continue;

        tsi = find_tsidx( vc[i].tsid, vc[i].pn, WHO );
        if (tsi >= 0) cn = tsids[tsi].call;

/* PAT gets colored magenta to indicate PAT supplied only, not in VCT */
        snprintf( t, sizeof(t)-1,
                BM" PAT %sChn %2d  %s %sTSID %04X [%-7s] %dx%d %s",
                        c, 1 + i, ct, c, vc[i].tsid, cn,
                        vc[i].hres, vc[i].vres, pw);
        add_tvct_text( t );

/* NOTE: this doesn't show if problem filter skipping it above */
        if (0 == vct_dtl) {
            if (0 != vc[i].ca) {
                add_tvct_text( " " );
                continue;
            }
            if (0 == vc[i].pmtes) {
                add_tvct_text( " " );
                continue;
            }
        }

/* fallback to PAT and PMT for Elementary Stream info */
        if (0 != vc[i].pmtpid) {

/* red indicates missing PMT PID */
#if 0
            if (0 == strncmp( c, BG, 8))
                if ( 0 == pids[vc[i].pmtpid] ) c = BR;
#endif

            snprintf( t, sizeof(t)-1,
                    "%s  PMT Program Map PID %04X Vn %02X "
                    "Clock Ref PID %04X DLen %03X ES Num %u:" BN,
                    c, vc[i].pmtpid, vc[i].pmtvn, vc[i].pcrpid,
                    vc[i].pilen, vc[i].pmtes );
            add_tvct_text( t );

            if ( 0 != vct_dtl ) {
                for ( j = 0; j < vc[i].pilen; ) {
                    unsigned char dtag, dlen;
                    /* program info has global PMT descriptors */
                    dtag = vc[i].pidesc[j];
                    dlen = vc[i].pidesc[j+1];
                    build_mpeg2_descriptor( &vc[i].pidesc[j], 4 );
                    j += 2;
                    j += dlen; /* to next descriptor until pilen */
                }
                add_tvct_text( " " );
            }

            /* don't display if missing PMT info */

/* or if already displayed above */

            if (0 != vc[i].pmtes) {

                int a;
                a = 0;
                /* step thru known PMT stream types and show descriptors */
                for (j = 0; j < vc[i].pmtes; j++ ) {
                    char estx[32];
                    unsigned char est;
                    est = vc[i].estype[j];

                    c = BN;

/* treat everything unparsed as generic A/90 data type */
                    if ( (-1 == svc) && (0x02 != est) && (0x81 != est) )
                        c = BY;

                    snprintf( estx, sizeof(estx)-1,
                             " PMT A/90 Type [%02X]", est);

                    /* Video type */
                    if ( 0x02 == est ) {
                        if (i == svc) c = BG;
                        snprintf( estx, sizeof( estx )-1,
                                 " PMT MPEG Video # %d", i);
                    }

                    /* Audio type, cap aud means highlight only one */
                    if ( 0x81 == est ) {
                        if ( (i == svc) && (a == sva) ) c = BG;
                        snprintf( estx, sizeof( estx )-1,
                                 " PMT A/52 Audio # %d", a);
                        a++;
                    }
/* else could display other types like vct does above but not doing this */

                    if (-1 == svp) c = BG;

/* red indicates missing ES PIDs */
#if 0
                    if (0 == strncmp( c, BG, 8))
                        if (0 == pids[vc[i].espid[j]]) c = BR;
#endif

                    snprintf( t, sizeof(t)-1,
                            "%s  %s [%3s] ES # %01X Type %02X ES PID %04X "
                            "ES ILen %03X" BN,
                            c, estx, vc[i].eslang[j], j, est,
                            vc[i].espid[j], vc[i].esilen[j] );
                    add_tvct_text( t );

                    if (0 != vct_dtl) {
                        for (k = 0; k < vc[i].esilen[j]; ) {
                            unsigned char dtag, dlen;
                            /* elementary stream descriptors */
                            dtag = vc[i].esdesc[j][k];
                            dlen = vc[i].esdesc[j][k+1];
                            build_mpeg2_descriptor( &vc[i].esdesc[j][k], 4);
                            k += 2;
                            k += dlen; /* to next descriptor until pilen */
                        }
                        if ( 0 != vc[i].esilen[j] ) add_tvct_text( " " );
                    }
                }
            }
            add_tvct_text( " " );
        }
    }

#if 0
/* additional VCT descriptors
 ignoring these because have no examples to test against.
 look for additional descriptors, spec says may be 0
*/
    if (0xFC == (r[0] & 0xFC)) {
        adl = ((0x3 & r[0]) << 8) | r[1];
        if (adl != 0) {
            snprintf( t, sizeof(t)-1, "TVCT add'l desc NOT PARSED!\n");
            add_tvct_text( t );

            /* not doing anything with add'l descriptors */
            for ( j = 0; j < adl; j++) {
/*              aprintf( stderr, "%02X", *r); */
                r++; /* skip descriptor */
            }
        }
    }
#endif

}


/* starting from vc[n], find next usable vc and return the index */
/* used by the [c] key in show virtual channels to change to next VC */
/* This is for cable users with more than broadcast usual of 1-5 VCs */
/* This is until coded for 'A'-'Z' similar to channel/epg selects */
/* static */
int
find_next_vc( int n )
{
        int i, j;
        for (i = 1; i<vc_ncs; i++) {
                j = (i + n) % vc_ncs;
                advrlog( LOG_INFO, "%s n %d i %d j %d pn%d es%d ca%d",
                        WHO, n, i, j, vc[j].pn, vc[j].pmtes, vc[j].ca);
                if (0 == vc[j].pn) continue;
                if (0xFFFF == vc[j].pn) continue;
                if (0 == vc[j].pmtes) continue;
                if (0 != vc[j].ca) continue;
                advrlog( LOG_INFO, "%s found %d", WHO, j);
                return j;
        }
        advrlog( LOG_INFO, "%s fallback %d", WHO, n);
        return n;
}

/*
 Show user the Virtual Channel Table with Program Map Table descriptors,
 or show Program Map Table with descriptors if no VCT found, or half and half
 if the # of channels don't match (can only do so much with non-compliance)
*/
/* static */
void
show_virtual_channels ( void )
{
    int i, j, tp;
    unsigned char key = 0;
    int vcs = 0;
    int vo = 0;
    int svc, sva, svp, ovnc;
    struct sig_s *s;
    char *tt, pgm_id[64];

    s = &ptc[ cap_chan ].sig;

    ovnc = 0; /* gets copy of vct ncs if [p] key hit */

/* display uses current cap pn/va setting or config pn/va if no cap */
    svp = cap_pn;
    sva = cap_va;
    if (CAP_NONE == cap_now) {
        svp = s->pn;
        sva = s->va;
    }
    svc = find_vc_pgm( svp, WHO );

    if (vc_ncs < 1) {
        dvrlog( LOG_INFO, "%s vc ncs %d", WHO, vc_ncs );
        return;
    }

/* test mode always starts out in full cap */
    if (0 != test_mode) {
        s->vc = s->va = cap_vc = cap_va = svc = sva = svp = -1;
    }

    refresh.vct = 1;
    build_vc_text();

    for (i = 0; i < user_lines;) {

        if ( D_VCT != display_type) {
            if (0 != ovnc) vct_ncs = ovnc; /* have an ACME cigar! */
            return;
        }
        j = i + vo;
        if (0 != refresh.vct) {
                if (CAP_NONE == cap_now) {
                        tt = "ATSC VIRTUAL CHANNEL TABLE";
                        tp = columns - strlen(tt);
                        tp >>= 1;
                        if (tp < 0) tp = 0;
/* replace signal header */
                        aprintf( stderr, DCARC CEL, 2, 1);
                        aprintf( stderr, DCARC BW "%s" BN, 2, tp, tt);

                        snprintf( pgm_id, sizeof(pgm_id),
                                "LCN %d PTC %d.%d %s %s",
                                s->chan, s->ptc, s->pn, s->call, s->sid);
                        tp = columns - strlen(pgm_id);
                        tp >>= 1;
                        if (tp < 0) tp = 0;
/* and strength bar */
                        aprintf( stderr, DCARC CEL, 3, 1);
                        aprintf( stderr, DCARC BY "%s", 3, tp, pgm_id);
                }
        
            aprintf( stderr, "\033[%d;1H%s" CEL, 5+i, &tvct_text[j][0] );
        }

        i++;
        i %= user_lines;

        if (i == 0) {
            char *t;
            show_status( 1, WHO );

            t = "";
            if (CAP_NONE == cap_now) {
                t = "Last";
            } else {
                t = "LIVE";
            }
            if (0 != refresh.vct) {
                aprintf( stderr, DCA_VCT CEL BW "%s Virtual Channel Table ", t);
                aprintf( stderr, BN BW "(" BG "CAP" BW ")" BN " " SCV );

                if (-1 < svp) {
                    aprintf( stderr, BG "%d.%d PGM %d VC %d VA %d" BN CEL,
//                          vc[svc].major, vc[svc].minor, svp, svc, sva);
                            s->ptc, s->pn, svp, svc, sva);
                } else {
                    aprintf( stderr, BG "Full Capture" BN CEL);
                }
    
                aprintf( stderr, BN"%s[?] help", dca.ustat);
                /* hold down further redraws */
            }

            refresh.vct--;
            if (refresh.vct < 0) refresh.vct = 0;

            /* end of page? wait for key and process it */
            key = 0;
            console_getch_fn( &key );
            nanosleep( &console_read_sleep, NULL ); /* need 1/5s */
            if (0 == key) continue;

            if ( (10 == key) || ('v' == key) ) {
                if (0 != ovnc) vct_ncs = ovnc;
                return;
            }
            /* any key refreshes */
            refresh.vct = 1;

/* if cap is info or none, [0...9] key sets virtual channel # */
/* don't allow user to change it during capture */
            if ( (CAP_INFO == cap_now) || (CAP_NONE == cap_now) )
            {
                if ( ('c' == key) || ((key >= '1')  && (key <= '9'))) {
                    vcs = key - '1';
                    if ('c' == key) vcs = find_next_vc( svc );
                    if ( (vcs >= 0) && (vcs < vc_ncs) ) { 

                        /* don't select Hidden or NTSC, nothing there */
                        if ( (vc[ vcs ].pn < 65535)
                          && (vc[ vcs ].pn != 0)
                          && (vc[ vcs ].pmtes != 0) ) /* no ES to select? */
                        {
                            s->pn = cap_pn = svp = vc[vcs].pn;
                            s->vc = cap_vc = svc = vcs;
                            s->va = cap_va = sva = 0; /* default audio 0 */
                            advrlog( LOG_INFO, "vc %d selected pgm %d",
                                    cap_vc, cap_pn);
                            pat_built = 0; /* force a new PAT */

                        } else {
                            dvrlog( LOG_INFO, "vc can't select %d", vcs);
                        }
                        nanosleep( &console_read_sleep, NULL ); /* 100ms */
                        key = 0;
                    }
                }
            }


/* if cap info or cap none, [a] sets the audio # within vc */
/* if it gets it wrong, remove comment to disable audio select during capture
            if ( (CAP_NONE == cap_now) || (CAP_INFO == cap_now) )
*/
            {
                if ( 'a' == key) {
                    advrlog( LOG_INFO, "va select vc%d", svc );

                    /* wait til user sets vc first */
                    if (-1 < svc) {

                        /* only valid if more than 1 audio ES available */
                        if (vc[svc].pmtes > 2) {

/* why not toggle thru instead? now have vc[].acn for modulo now.
    more concise, but it might be annoying if more than 3 audios aaaa
 */
                            sva++;
                            sva %= vc[svc].acn;
                            s->va = cap_va = sva;
                            advrlog( LOG_INFO,
                                    "p %d v %d a %d %% acn %d",
                                    svp, svc, sva, vc[svc].acn);

                            /* 100ms? trying to slow down user input */
                            nanosleep( &console_read_sleep, NULL );
                            key = 0;
                            pmt_built = 0; /* force a new PMT */
                        }
                    }
                }
            }

/* don't allow reset during user or timer captures */
            if ((CAP_NONE == cap_now) || (CAP_INFO == cap_now)) {
                if ( 'r' == key ) {
                    cap_pn = cap_vc = cap_va = -1;
                    s->pn = s->vc = s->va = -1;
                    svc = sva = svp = -1;
                    key = 0;
                }
            }

/* if key was handled, show select and save config */
            if (0 == key) {
                refresh.epg = 1; /* bottom left epg count refresh */
                refresh.vstats = 1; /* line above bottom */

#if 0
                if (CAP_NONE == cap_now) {
                    cap_pn = svp;
                    cap_vc = svc;
                    cap_va = sva;
                    dvrlog( LOG_INFO, "cap p %d v%d a%d",
                            svp, svc, sva ); 
                }
#endif
                set_vc(WHO); /* should set cap_pids */
                show_vc_selection();
                show_event_short();
                save_config( WHO );
                nanosleep( &guide_loop_sleep, NULL ); /* 100ms */

            }

            if ( 'z' == key) {
                if (CAP_INFO == cap_now) {
                    stop_capture( WHO, 0 );
                    display_type = D_TIMERS;
                    if (0 != ovnc) vct_ncs = ovnc;
                    return;
                }               
            }

            /* toggle vct_ncs to zero and back for mpeg-only test display */
            if ( 'm' == key) {
                if (ovnc != 0) {
                    vct_ncs = ovnc;
                    ovnc = 0;
                    vo = 0; /* redraw list from start */
                } else {
                    ovnc = vct_ncs;
                    vct_ncs = 0;
                    vo = 0; /* redraw list froms start */
                }
            }

            if ( 's' == key) {
                display_stat = ~display_stat;
                if (0 != display_stat) refresh.pstats = 1;
                show_status( 0, WHO );
            }

            if ( '?' == key ) show_keyhelp( vchannelskeyhelp );

            if ( 'd' == key ) {
                vct_dtl = ~vct_dtl;     /* toggle detail display */
                vo = 0;                 /* redraw from top of list */
            }
            
            if ( KB_UP == key ) vo -= 1;
            if ( '='   == key ) vo -= 1;

            if ( KB_DN == key ) vo += 1; /* [=] */
            if ( '\''  == key ) vo += 1; /* ['] */

            /* page up down only useful for cable, broadcast hasn't many VCs */
            if ( KB_PU == key ) vo -= user_lines;
            if ( KB_PD == key ) vo += user_lines;

            /* key = 0; */
            /* make it wait til next time */
            
            if (vo < 0) vo = 0; /* sanity limit */
            if ( (vo + user_lines) >= tvct_idx) vo = tvct_idx - user_lines;
            if (vo < 0) vo = 0; /* sanity limit */
/*
            dvrlog( LOG_INFO, "VCT key now %02X vo %d", key, vo);
            if (CAP_NONE != cap_now) continue; / / only set vc when not cap
            continue; / / continue if user needs verify, break if not
*/
            /* moved here in case key changed something */
            build_vc_text();
        }
    }
}


/*
 prompt for a program index and add two words of event name as timer name
 program number is appended to this name for parsing by build outnames
 timer name, start time and len added to timer array and timer_idx inc
 if user tries to set timer on current program, it will adjust that program
 to start later and run shorter to try to handle ts cap in main thread
 ts cap getting own thread with timer test included might [does] help
*/
/* static */
void
get_timer_add_event ( void )
{
    struct qtimer_s *t;
    struct event_s *e;
    char *warn;
    char *p;
    int i, j;
    int pgm_add;                /* add entry from pgm guide # */
    int estart;                 /* event start in epoch seconds */
    int elen;                   /* event len in sec */
    short epn;                  /* event program number for event */
    short evc;                  /* event vc number */
    short pgm_wd;               /* event weekday bits */
    short pgm_r1;               /* EPG start range */
    short pgm_r2;               /* EPG stop range */
    short pgo;                  /* pg[ pgm_add ] shorthand */
    char pgm_in[16];            /* input text */
    char *wdb;                  /* from input, weekday bits text */
    char n[PNZ];                /* event name */
    char pgm_name[PNZ];         /* mangled timer name */


    warn = BW;

    memset( pgm_in, 0, sizeof( pgm_in ));
    test_termsize();

    while (1)
    {
        if (timer_idx >= TIMER_LIST_MAX) {
            aprintf( stderr,
                BR BL "%s"
                "Timers full. Recompile with larger TIMER_LIST_MAX." CEL,
                dca.hstat );
            nanosleep( &msg_long_sleep, NULL);
            return;
        }

        /* input needs cursor visible */
        aprintf( stderr, SCV BL
            "%s%sEPG# index[-index2][ SMTWTFS bits] to add ?" BN " " CEL,
            dca.hstat, warn);

        console_reset(); /* echo and blocked input on */
        fgets( pgm_in, sizeof(pgm_in)-1, stdin );
        console_getch(); /* echo and blocked input off */
        
/* quick exit is [enter] key */
        if ( 10 == *pgm_in ) {
            show_headers(0);
            return;
        }

/* quick exit is blank line */
        if ( 0 == *pgm_in ) {
            show_headers(0);
            return;
        }

/* remove NL and CR, if any */
        p = strchr( pgm_in, '\n');
        if (NULL != p) *p = 0;
        p = strchr( pgm_in, '\r');
        if (NULL != p) *p = 0;

        pgm_r1 = atoi( pgm_in );
        pgm_r2 = pgm_r1;

        p = strchr( pgm_in, '-'); /* dash indicates range */
        if (NULL != p) {
            p++;
            pgm_r2 = atoi( p );
        }               

        wdb = "";

        p = strchr( pgm_in, ' '); /* space indicates weekday bits */
        if (NULL != p) {
            p++;
            wdb = p;
        }

/* is ascii binary? hmm no isbinary()? */
        pgm_wd = 0;
        if ( ( '0' == *wdb) || ('1' == *wdb ) ) pgm_wd = abtou( wdb );

        warn = BR;

/* user input error check */
        if  (  (pgm_r1 >= pgm.idx)
            || (pgm_r2 >= pgm.idx)
            || (pgm_r2 < pgm_r1)
            || (pgm_wd > 127)
            ) continue;

/* add a range of program events (or a single program) */
        for (i = pgm_r1; i <= pgm_r2; i++)
        {
            if (timer_idx >= TIMER_LIST_MAX) break; /* stop if timer list full */
            pgm_add = i;

            pgo = pg[ pgm_add ];
            e = &epg[ pgo ];

            /* copy out the event name for mangling */
            memcpy( n, e->name, sizeof(pgm_name) );
            estart = e->st;
            elen   = e->ls;

/* vc not used anymore. use pgm instead in case of VCT gone PAT fallback */
            evc    = e->vc;
            epn    = e->pn;

            advrlog( LOG_INFO, "adding event %s %d %d %d %d",
                    n, estart, elen, epn, evc);

/* copy first two words of name, ignoring some common words */
            event_truncate( pgm_name, n, 2, sizeof(pgm_name) ); /* two words */

/* add program id to name, so name.pn */
            pgm_name[16] = 0; /* limit the name so @.3 will fit */

            p = pgm_name;
            p += strlen(p);
            asnprintf( p, sizeof(pgm_name), "@.%d", epn );

/* skip duplicates that are already on the timer list */
            if ( 0 == test_timer_dup( WHO, pgm_name, estart, elen) )
                continue;
            
/* set start time far enough ahead so info cap has time to stop and restart
 you don't have this problem if you use guide while not capping.
*/
            if (CAP_INFO == cap_now) {
                get_time();
                if ( ((estart+elen) > utsnow) && (estart < utsnow) ) {
                    elen = ( (estart + elen) - utsnow) - 5;
                    estart = utsnow + 5; /* AOS needs at least 3, using 5 */
                    if (elen < 5) continue; /* dont add if close to end */
                    stop_capture( WHO, FAIL_NONE );
                    display_type = D_TIMERS;
                }
            }

            j = timer_idx;
            timer_idx++;

            t = &timer[ j ];
            
            astrncpy( t->name, pgm_name, TIMER_NAME_MAX );

/* if DST, adjust program start non DST, other functions adjust... */
            trec2 = estart;
            memcpy( &tloc2, localtime( &trec2 ), sizeof( tloc2 ) );

#if 0
/* dst changover from now to timer? no, don't do this */
            if ( tloc.tm_isdst != tloc2.tm_isdst) {
/* NOTE:
    no 2am on dst changeover days. it's easier on spring forward, drop 2am
    but on fall back, how to handle two 0100 hours? one will run and one
    will be ignored, then the other will run, maybe. not worth trouble

    one way is to use UTC only, no DST adjust, but will confuse most users
 */

                if (tloc2.tm_isdst != 0)
                    estart += SECHR; /* spring forward */
                if (tloc2.tm_isdst == 0)
                    estart -= SECHR; /* fall back */
            }
#endif

            t->start = estart;
            t->len   = elen;
            t->chan  = cap_chan;
            t->days  = pgm_wd;

/* the problem with this is config reload will not reload the etmid */
            t->etmid = e->etmid;

/* if weekday bits set, set start time back one day until before now */
            if (0 != t->days)
                while( t->start >= utsnow)
                    t->start -= 86400;

            t->secdt = 5;

/* use program number not timer.vc in case VCT gone and PAT only fallback */
            t->pn   = epn;
/* timer.vc not used anymore */
            t->vc    = evc;

            t->va    = cap_va;
            t->qstat = T_FUTURE;
            *t->ename = 0;
            *t->edesc = 0;

/* faster */
            if (0 != *e->name) {
                astrncpy( t->ename, e->name, PNZ );
                if (0 != *e->desc) {
                    astrncpy( t->edesc, e->desc, PDZ );
                }
            }           
#if 0
/* strlen makes this slower */
            if (0 != strlen( e->name )) {
                astrncpy( t->ename, e->name, PNZ );
                if (0 != strlen( e->desc )) {
                    astrncpy( t->edesc, e->desc, PDZ );
                }
            }           
#endif

        }

/* sort moved outside of range loop */
        timer_sort = ~0;
        sort_timers();

        save_config( WHO );
        break;
    }   

    refresh.timers = 1;
    timer_sort = ~0;
    display_type = D_TIMERS;
    show_headers(0);
}

/* get program index [range] and toggle the spam status for the event(s) */
/* static */
void
get_spam_toggle ( void )
{
    struct event_s *e1;
    char *warn;
    char *p;
    int i, j;
    short pgm_r1;               /* EPG start range */
    short pgm_r2;               /* EPG stop range */
    char pgm_in[16];            /* input text */
    char pgm_name[SPAM_NAME_MAX]; /* from input text, second half of range */
    warn = BW;

    while (1)
    {
        memset( pgm_in, 0, sizeof( pgm_in ));
        test_termsize();
        if (spam_idx >= SPAM_LIST_MAX) {
            aprintf( stderr,
                BR BL "%s"
                "Spam list full. Recompile with larger SPAM_LIST_MAX." CEL,
                dca.hstat );
            nanosleep( &msg_long_sleep, NULL);
            return;
        }

        /* input needs cursor visible */
        aprintf( stderr, SCV BL
            "%s%sEPG# index[-index2] for junk toggle?" BN " " CEL,
            dca.hstat, warn);

        console_reset(); /* echo and blocked input on */
        fgets( pgm_in, sizeof(pgm_in)-1, stdin );
        console_getch(); /* echo and blocked input off */
        
/* quick exit is enter key by itself */
        if ( 10 == *pgm_in ) {
            show_headers(0);
            return;
        }

/* quick exit is blank line */
        if ( 0 == *pgm_in ) {
            show_headers(0);
            return;
        }

/* remove NL and CR if any */
        p = strchr( pgm_in, '\n');
        if (NULL != p) *p = 0;
        p = strchr( pgm_in, '\r');
        if (NULL != p) *p = 0;

        pgm_r1 = atoi( pgm_in );
        pgm_r2 = pgm_r1;


        p = strchr( pgm_in, '-'); /* dash indicates range */
        if (NULL != p) {
            p++;
            pgm_r2 = atoi( p );

/* correct for end-user mistakes by limiting range to 1 item */
            if (0 == pgm_r2) pgm_r2 = pgm_r1;
        }               

/* warning color for 2nd input iteration */
        warn = BR;

/* user input error check */
        if ((pgm_r1 >= pgm.idx) || (pgm_r2 >= pgm.idx) || (pgm_r2 < pgm_r1))
            continue;

/* toggle spam status for a range of events */
        for (i = pgm_r1; i <= pgm_r2; i++) {

/* stop if spam list full */
            if (spam_idx >= SPAM_LIST_MAX) break;

            e1 = &epg[ pg[i] ];

            j = test_spam_event( e1 );

            if (-1 == j) {
                event_truncate( pgm_name, e1->name, 2, SPAM_NAME_MAX );
                add_spam( pgm_name, e1->st );
                sort_spamlist( 0 ); /* sort by name */
            } else {
                delete_spam( j );
            }
        }

        save_spamlist( WHO );
        break;
    }   
    refresh.epg = 1;
    show_headers( 0 );
}


/* if user selected vct program#, find current epg entry matching it */
/* otherwise find first current epg entry matching current time */
/* this is to make [enter] key behave consistently in epg display */
/* this gets current event unless it is hidden by spam filter */
/* returns -1 if not found */
/* static */
int
find_current_epg_pgm( void )
{
    struct event_s *e;
    struct sig_s *s;
    int i, j;

    s = &ptc[cap_chan].sig;

    get_time();
    j = -1; /* should be found */       /* event may be old/filtered */
    for (i = 0; i < pgm.idx; i++) {     /* use pgm.idx for filtered */
        e = &epg[ pg[ i ] ];            /* use epg[pg[i]] for fast xref */

        if (e->st <= utsnow) {                  /* now is after event start? */
            if ((e->st + e->ls) > utsnow) {     /* and now is before stop? */ 
                if (s->pn > 0) {                /* if program selected */
                    if (e->pn != s->pn) {       /* loop until program matches */
                        advrlog( LOG_INFO, "%s %s.%d not.%d",
                        WHO, e->name, e->pn, s->pn);
                        continue;
                    }
                }
                advrlog( LOG_INFO, "%s found %s.%d",
                        WHO, e->name, e->pn);
                j = i;                          /* event match */
                break;                          /* loop is done */
            }
        }
    }
    return j;
}


#define NAM_LIM 25
#define DES_LIM 32

/* show programs found so far, scroller removes need for word wrap */
/* static */
void
show_program_guide ( void )
{
    unsigned int etmid;         /* ETM ID for one event */
    unsigned char key = 0;      /* user input */
    struct event_s *e1;         /* one event */
    struct sig_s *s1;           /* one LCN */
    struct tm stm;              /* time tm structure */
    time_t st;                  /* time_t  */

    char t[512],                /* output string */
        d[32],                  /* date string to be chopped up */
        pn[16],                 /* program.num string */
        name[PNZ],
        desc[PDZ],
        rate[PRZ],
        pgm_id[64],
        *p,                     /* description at scroll offset */
        *ec,                    /* EIT 0-3 get special colors */
        *cec;                   /* current event color hilite */

    int i, k,                   /* loop counts */
        td,                     /* time delta */
        lc,                     /* line counter */
        pgn,                    /* program numer where event resides */
        evc,                    /* vc number where event resides */
        ls,                     /* length in seconds */
        so,                     /* scroll offset */
        po,                     /* page offset */
        sr,                     /* source, also used before then */
        spam,                   /* TESTME: is this used? */
        cp,                     /* current event for [enter] start */
        se;                     /* show event flag, nz shows event */

    cp = -1;
    so = 0;
    po = 0;
    spam = 0;

    if (D_EPG != display_type) return;  /* don't display if not EPG */

    evc = pgn = lc = po = 0;

    get_time();
    s1 = &ptc[ pgm.chan ].sig;

    refresh.epg = 1;
    pgm.idx = 0;

    pgm.pn = 0;

/* current cap sets program view to same as cap, may be all when CAP_INFO */
    if (CAP_NONE != cap_now) {
        pgm.pn = cap_pn;
    } else {

/* FIXME: idle sets to selected program, but not showing VC reset s->pn -1 ?
*/
//      if (s1->pn > 0) pgm.pn = s1->pn;
        pgm.pn = s1->pn;
    }

/* build filtered (or not) pg list from master epg list */
    build_pg_epg( epg, &pgm, pg, WHO);

    if (cap_pn > 0) {
        po = find_current_epg_pgm();
        if (-1 == po) po = 0;
    }

/* no current program if not visible as highlight (stale guide) */
    cp = -1;

/* program guide loop needs output redux, has it now.
   should never pass pgm lines, but stop loop if does
 */
    for (i = 0; i < user_lines;)
    {

        if ( D_EPG != display_type ) return;
        show_status( 1, WHO ); /* 1 is wait */

/* output redux */
        if (0 != refresh.epg)
        {
                if (0 == i) {

/* only show title of current view if no capture in progress.
   the title serves to redraw line3 when resize occurs
    uses ec, sr that are re-used later for other purpose
*/
                    if (CAP_NONE == cap_now) {
                        ec = "ATSC EVENT PROGRAM GUIDE";
                        sr = columns - strlen(ec);
                        sr >>= 1;
                        if (sr < 0) sr = 0;
/* replace signal header */
                        aprintf( stderr, DCARC CEL, 2, 1);
                        aprintf( stderr, DCARC BW "%s" BN, 2, sr, ec);

                        snprintf( pgm_id, sizeof(pgm_id),
                                "LCN %d PTC %d.%d %s %s",
                                s1->chan, s1->ptc, s1->pn, s1->call, s1->sid);
                        sr = columns - strlen(pgm_id);
                        sr >>= 1;
                        if (sr < 0) sr = 0;
/* and strength bar */
                        aprintf( stderr, DCARC CEL, 3, 1);
                        aprintf( stderr, DCARC BY "%s", 3, sr, pgm_id);
                    }

/* short form net.pn for EPG header */
                    snprintf( pgm_id, sizeof(pgm_id)-1,
                                "%s.%d", s1->sid, s1->pn );

                    aprintf( stderr, header_guide, DCA_HEAD4, pgm_id);
                    aprintf( stderr, CEL BN"%s[?] help", dca.ustat);
                }

/* increment po by user lines at end of page */
                k = i + po;
                memset( name, 0, sizeof(name) );
                memset( desc, 0, sizeof(desc) );
                memset( d, ' ', sizeof(d) );
                ls = 0;

/* color for future show more than 12 hours */
                cec = ec = BN;
                se = 1;

                e1 = &epg[ pg[ k ]];

                if (-1 == pg[k]) se = 0;
                if ( (s1->pn > 0) && (e1->pn != s1->pn) ) se = 0;

/* is sorted guide entry non blank, or is the current program? */
                if ( 0 != se )
                {       
                    st = e1->st;
                    ls = e1->ls;

/* needed to be somewhere in the inner loop */
                    get_time();
                    td = st - utsnow;

                    localtime_r( &st, &stm );
                    asctime_r( &stm, d );

                    if ( td < (12*SECHR) ) ec = BG; /* under 12 hours green */
                    if ( td < ( 9*SECHR) ) ec = BC; /* under 9 is cyan */
                    if ( td < ( 6*SECHR) ) ec = BY; /* under 6 is yellow */
                    if ( td < ( 3*SECHR) ) ec = BR; /* under 3 is red */

/* magenta for aged out */
                    if ( td < 0 ) {
                        ec = BM;
                        if (0 != test_mode) ec = BN; /* test needs to see */
                    }

/* low light all spam entries */
                    spam = test_spam_event( e1 ); /* program guide mask */
                    if (-1 < spam) ec = "\033[30;40;1m";
                    
                    cec = ec;

/* whoops lost the current indicator, moved below spam check */
                    if ( (td < 0) && ( (0-td) < ls) ) {

/* current pgm has index pn date/time/len inverse video, rest bright white */
                        ec = BW;
                        cec = BW BV;

/* default to last current program visible */
                        if (-1 == cp) cp = k;

/* pg[k] event number for <enter> add_search_event_timer */
                    }

                    memcpy( rate, e1->rating, PRZ);

/* handle event name. the memset is needed? description uses it so console
    will display blank when scrolling right, but name doesn't scroll?
                    memset( name, 0, sizeof(name) );
                    memcpy( name, e1->name, PNZ);
// pknaggs: memcpy crashes on long name
*/
                    astrncpy( name, e1->name, PNZ); /* chop it to fit */

/* [n] key in EPG makes it show ETMID, len, comp and mode */
                    if  (0 != pgm.etmids)
                    {
                        snprintf( name, sizeof(name),
                                    "E%04X.%04X L%02X C%02X M%02X",
                            0xFFFF & (e1->etmid>>16),
                            0xFFFF & e1->etmid,
                            e1->nchr,
                            e1->ncomp,
                            e1->nmode );
                    } else {
                        if ( 0 == e1->nchr )
                            snprintf( name, sizeof(name) - 1, "%s", "n/a");
                    }

/* description does need 0 fill for scrolling to the right to work */
                    memset( desc, 0, sizeof(desc) );

/* Displays differently if rating included or description blank.
   Inclusion of rating text makes full 255 char description truncate
   to about 236 chars for display. Using asnprintf to append the text.
*/
                    if ( 0 != *e1->rating) {
                        asnprintf( desc, PDZ, "[%s] ", e1->rating);
                    }
                    if ( 0 == e1->dchr) {
                        asnprintf( desc, PDZ, "n/a" );
                    } else {
                        asnprintf( desc, PDZ, "%s", e1->desc );
                    }

/* append numeric description if showing etmid detail */
                    if  (0 != pgm.etmids) {
                        snprintf( desc,  sizeof(desc)-1, 
                            " D%04X.%04X L%02X C%02X M%02X",
                            0xFFFF & ( e1->etmid >> 16 ),
                            0xFFFF & e1->etmid,
                            e1->dchr,
                            e1->dcomp,
                            e1->dmode);
                    }

/* TMI?
                    else {
                        if ( 0 == e1->dchr )
                            snprintf( desc, sizeof(desc) - 1, "%s", "n/a");
                    }
*/
                    etmid = e1->etmid;

                    /* see ETM id's received for multiplex vc station,
                        use epg[n] n = src id * EIT * ETT multiplier
                     */

                    sr = 0xFFFF & (etmid >> 16);

                    pgn = e1->pn; /* new method is pgm# */
                    evc = e1->vc; /* old method was vc# */

/* vc method will not handle the timer properly if vc # changes,
   however program # will stay the same and should be used instead
   to look up the new VC
 */
/*                  snprintf( pn, sizeof(pn)-1, " .%d", evc); */
                    snprintf( pn, sizeof(pn)-1, " .%d", pgn);
                    if (0 < cap_va) {
                        snprintf( pn, sizeof(pn)-1, ".%d,%d", pgn, cap_va);
                    }

/* NOTE: cpu pig: bright white is event already on timer list */
                    if ( -1 != find_timer_epg( e1 )) ec = BW;

                    if (0 == pgn) {
                        snprintf( pn, sizeof(pn)-1, "HIDE");
                    }

                    if (pgn >= 65535) {
                        snprintf( pn, sizeof(pn)-1, "NTSC");
                        ec = BM;
                    }

                    if  (0 != pgm.etmids) {
                        snprintf( pn, sizeof(pn)-1, "%04X", pgn);
                    }
                }

                /* falls thru to here to draw at least a blank string */
                if ( strlen(name) > NAM_LIM ) {
                    name[ NAM_LIM - 2 ] = '>';
                }
                name[ NAM_LIM - 1 ] = 0;

                d[16] = 0;
                d[3] = 0;
                if (so >= PDZ) so = PDZ - 30;


                if ( 0 != se )
                {

/* truncate description by number of columns left to display it */
                    p = &desc[so];
                    if ( strlen(p) >= (columns - 51) ) {
                        p[ columns - 51 ] = 0;
                        p[ columns - 52 ] = '>';
                    }    

                    memset(t, 0, sizeof(t));

                    if (0 == pgm.etmids) {
                        snprintf( t, sizeof(t),
                                "%s%4d %-4s %-3s %-5s %4d%s%s %-24s%c%-30s",
                                cec, k, pn, d, &d[11], ls/60, BN, ec, name,
                                (0 != so) ? '<':' ', p );
                    } else {
                        snprintf( t, sizeof(t), 
                                "%s%04X %-4s %-3s %-5s %4d%s%s %-24s%c%-30s",
                                cec, pg[k], pn, d, &d[11], ls/60, BN, ec, name,
                                (0 != so) ? '<':' ', p );
                    }
                }

/* invalid entry will blank the line (shows blanks at end of list) */
                if ( 0 == se )
                {
                    memset( t, ' ', columns );
                    t[ columns - 1 ] = 0;
                }

/*              aprintf( stderr, "\033[%d;1H%s%s" CEL, 5+i, ec, t); */
                aprintf( stderr, "\033[%d;1H%s%s" CEL BN, 5 + i, ec, t);

                lc++;
        } /* end of refresh.epg != 0  */

        i++;
        i %= user_lines;
        key = 0;

        /* rest of what happens when i == 0 */

/* check pg list after loop iterations */
        if (0 == i)
        {

            if ( 0 != refresh.epg ) {
                build_pg_epg(epg, &pgm, pg, WHO);
                refresh.epg--;
            }

            if (refresh.epg < 0) refresh.epg = 0;
/*
 bottom of rows, see what keys
 hotkeys: '[' scroll left ']' scroll right '=' forward, '-' back
 hotkeys: [0]-[9] and [A]-[Z] for page jump (up to entry 700-719)
 max programs is 768, so you have to manually advance to last 48 :P
*/
            console_getch_fn( &key );
            nanosleep( &console_read_sleep, NULL );
            if (0 == key) continue;

            /* p to get in, p to get out */
            if ( 'p' == key) { 
                save_config( WHO ); /* save any timers added and epg */
                return;
             }

/* any key refreshes */
            refresh.epg = 1;
            i = 0;

            if ('?' == key ) {
                show_keyhelp( programskeyhelp );
            }
            
/* stop info cap and get out of program guide */
            if ( 'z' == key ) {
                if ( CAP_INFO == cap_now )
                    stop_capture( WHO, FAIL_NONE );

                display_type = D_TIMERS;
                save_config( WHO );
                return;
            }

/* trigger guide load */
            if ( 'l' == key ) {
                if ( CAP_NONE == cap_now ) {
/* display_type = 0; */ /* don't kick out */
                    pgmto = utsnow + PGM_INFO_TIMEOUT;
                    pgm_done = 0;
                    cap_now = CAP_INFO;
                    advrlog( LOG_INFO, "load request from EPG");
                    display_type = D_TIMERS;
                    return;
                }
            }

            if ( 's' == key ) {
                get_spam_toggle();
            }

/* add event to timer list */
            if ( 't' == key ) {
                get_timer_add_event();

/*              refresh.timers = 0;     */
/* not redrawing list yet */
/*              timer_sort = ~0; */
/* but sort it for the redraw later */


/* check for when timer 0 goes active and kick out of
    info cap and program guide if timer is active already */
                if ( (CAP_INFO == cap_now)
                  && (timer_idx > 0)
                  && (T_SEARCH != timer[0].qstat) )
                {
                    if ( utsnow >= timer[0].start - timer[0].secdt )
                        stop_capture( WHO, FAIL_NONE );
                    return;
                }
                key = 0;
            }
            
/*
     writes guide info to binary and text file with word wrapping.
     NOTE: this is done automatically when guide capture complete,
     but it is put here as a manual override for debug purposes.
*/
            if ( 'd' == key ) {
                dvrlog( LOG_INFO, "EPG%02d manual guide save", pgm.chan);
                save_guide();
            }

            /* age out, match, hidden, sort and numeric toggles */
            if ( 'a' == key ) {
                pgm.age = ~pgm.age;
                key = 0;
            }
            if ( 'm' == key ) {
                pgm.find = ~pgm.find;
                key = 0;
            }
            if ( 'h' == key ) {
                pgm.hide = ~pgm.hide;
                key = 0;
            }
            if ( 'n' == key ) {
                pgm.etmids = ~pgm.etmids;
                key = 0;
            }

            if (0 == key) {
/* should do it when it refreshes, so don't do it here? */
                build_pg_epg( epg, &pgm, pg, WHO );
                show_event_short();
                refresh.epg = 1;
                refresh.estats = 1;
                show_event_short();
                po = 0;
/*              continue; */ /* TESTME, wastes cpu cycles? */
            }

/* user hits [ENTER] to start current event */
/* NOTE: noticed a crash here if cap EPG and EIT+ETT still incrementing */
/* so force user to wait until EPG cap done before [ENTER] works */
/* This is caused by the new dynamic memory allocation strategy. */

            if ((CAP_NONE == cap_now) && (10 == key)) {
                struct sig_s *sig;
                sig = &ptc[ pgm.chan ].sig;

                /* user overrides last zap program guide timer hold down */
                sig->lzpgt = 0;

                /* find current program for this time or do nothing */
                cp = find_current_epg_pgm();
                if (cp >= 0) {
                    advrlog( LOG_INFO, "%s add search event timer epg[%04X]",
                        WHO, pg[cp] );
                    add_search_event_timer( &epg[ pg[ cp ]] );

                    save_config( WHO );
                    timer_sort = ~0;
                    refresh.timers = 1;
                }
            }

/*********************************** GUIDE SCROLLING AND PAGING */
            /* scroll up and down non arrow */
            if (key == '=') po -= 1;
            if (key == '\'') if ( (po+user_lines) < pgm.idx ) po++;
            /* arrow keys up and down */
            if (key == KB_UP) po -= 1;
            if (key == KB_DN) if ( (po+user_lines) < pgm.idx ) po++;

            /* scroll left and right non arrow */
            if (key == '[') so--;
            if (key == ']') so++;

            /* arrow keys left and right, home returns to left */
            if (key == KB_LF) so--;
            if (key == KB_RT) so++;
            if (key == KB_HM) so = 0;
            
            /* page forward and back non arrow */
            if (key == ' ') po += user_lines;
            if (key == 'b') po -= user_lines;

            /* page up and page down keys */
            if (key == KB_PD) po += user_lines;
            if (key == KB_PU) po -= user_lines;
            
            /* quick jump pages 0-9, A-Z, 768 is max programs, misses last 48 */
            if ((key >= '0') && (key <= '9')) po = user_lines*(key-'0');
            if ((key >= 'A') && (key <= 'Z')) po = user_lines*(10 + (key-'A'));

            /* limit page offset */
            if (po < 0) po = 0;
            if ( (po+user_lines) >= pgm.idx) po = pgm.idx - user_lines;
            if (po < 0) po = 0;

            /* limit description offset */
            if (so < 0) so = 0;
            if (so > (PDZ - DES_LIM)) so = PDZ - DES_LIM;
            if (so < 0) so = 0;

        } /* 0 = i (end of list) */

    } /* for i loop */

    /* should never get here */
}

/* show one line of signal meter info for a channel in sig_s *s */
/* if not arg scan, gets ptc[i] from scanlist */
/* static */
void
show_signal ( struct sig_s *s, int i )
{
        int j, b;
        char k;
    
        char t[16] = ""; /* pointed to by t1 */

        char *t1;       /* text1: %30dB %Peak% MHz Wavelen */
        char *t2;       /* text2: bar  */
        char *tc1;      /* textcolor1: peak is yellow, else normal */
        char *tc2;      /* textcolor2: bar color */
        char *tccl;     /* textcolor: channel lock brite */
        char *tcas; /* textcolor: auto scan timeout lock brite, GTO magenta */

        double cm = 300000000.0;        /* speed of light in m/s */
        double im = 39.367;             /* inches per meter */
        double wlm = 0.0;               /* wavelength meters */
        double wli = 0.0;               /* wavelength inches */
        double f = 0.0;                 /* frequency in megacycles */
        int fi = 0;                     /* frequency in kilocycles */

/* slow link needs this: 

        if (0 == scan_sig) {
                nanosleep( &signal_sleep, NULL );
        }

*/

        /* colors init to normal */
        tc1 = tc2 = tccl = tcas = BN;

        /* text init to blanks */
        t1 = t2 = "";
    
        /* w key toggles this through strength% peak% mhz or wavelen */
        t1 = t;

        /* bar is blank unless it has a real signal */
        t2 = "";

/* normal operation: get channel # from scan_list */
        if (0 == arg_scan) j = scan_list[ i ];

/* strength is 0-100, bar is 50 now, easy math. every 2% */

/* FIXME: sig_col colors might still be a bit off */
        s->sig_col = &bc[ 7 & (s->strength/13) ][0];

        b = (s->strength / 2 );
        if (b > SCALE_BAR) b = SCALE_BAR; /* dont go past end of bar list */
        t2 = &sigbar[b][0];

        /* create strings for display, in t1 with color in tc1 */
        switch( display_sigtype )
        {
        /* V4L2 % of 30dB, needs SNR dB version too */
        case SIG_STR:
                snprintf( t1, 11, "   %3d%%  ", s->strength);
                break;

        /* frequency to device */
        case SIG_FMHZ:
                snprintf( t1, 10, "%9d", s->freq );
                break;

        /* wavelength */
        case SIG_WLEN:
                fi = ptc[ s->chan ].sig.freq; /* LUT */
/* TESTME: was changed from V4L that used freq * 1000.0 */
                f = 1.0 * fi;           /* megahertz */
                wlm = cm / f;           /* wavelength in meters */
                wli = wlm * im;         /* wavelength in inches */
                snprintf( t1, 11, "    %4.1f\042", wli);
                break;

/* 2.2 decimal from 8.8 binary */
        case SIG_SNR:
                snprintf( t1, 11, " %2d.%02d dB", 0xFF & (s->snr>>8),
                         ((0xFF & s->snr) * 100) >> 8 );
                break;

#ifdef USE_DVB_EXPERIMENTAL
        /* frequency returned by new driver */
        case SIG_BER:
                /* only want 5 digits */
                snprintf( t1, 11, "    %5d", s->ber );
                break;

        /* frequency offset calc from new driver return, 6 digits + sign */
        case SIG_FOHZ:
                snprintf( t1, 11, "%+6d Hz", s->fohz);
                break;

#endif
        default:
                break;
        }

        tc2 = s->sig_col;

        /* only change numeric to error text on signal scan */
        if ( SIG_STR == display_sigtype) {

                if (0 == s->lock) {
                        tc1 = BR;
                        tc2 = BR;
                        t1 = " NO LOCK";
                        t2 = "";
                }

                /* test with real device */
                if ( (0 == arg_dummy) && (0 != test_mode) ) {
                        tc1 = BW;
                }

                /* no scan overrides value and sigbar */
                if (0 == scan_sig) {
                        tc1 = BN;
                        t1 = " SCAN OFF" SCV; /* value */
                        tc2 = BN;
                        t2 = "";        /* sigbar */
                        if ( (0 != arg_dummy) && (0 != test_mode) ) {
                                tc1 = BW;
                                t1 = " SCAN ON " SCV;
                        } /* dummy */
                }
        }

/* no scan overrides sigbar
        if (0 == scan_sig) {
                tc2 = BN;
                t2 = "";
        }
*/

        /* channel lock brightens the hotkey */
        if ( (scan_pos == i) && (scan_one != 0) ) tcas = BW;

        /* auto guide colors channel number and callsign */
        if ( 0 != s->pgto) tccl = BM;

        k = ' ';

/* signal strength same as bar color */
        tc1 = tc2;

/* 1 to 9 or A to Z for channel hot-key display */
        if (0 == arg_scan) k = (i<9) ? i + 49 : i + 56;

        if (0 == scan_sig) { tc2 = ""; t2 = ""; }

/* bar isn't really needed for cable, is always 99-100% */
        if (0 != arg_cable) { tc2 = ""; t2 = ""; }

/* Hotkey Channel Call Net SIG% ************ BAR *********** */
        aprintf( stderr,
                BN "%s%c"               /* hotkey */
                BN " %s%3d"             /* color, channel number */
                   " %7s"               /* callsign */
                BN " %3s"               /* net/station id */
                   " %s%7s "            /* color, signal strength % */
                BN " %s%s"              /* color, signal strength bar */
                BN SCV CEL,

                tcas, k,                /* color hotkey */
                tccl, s->chan,          /* color channel */
                s->call,                /* callsign */
                s->sid,                 /* network id */
                tc1, t1,                /* color strength or misc */
                tc2, t2                 /* color strength bar or OFF */
        );
}


/* add text to capture log text array */
/* static */
void
add_cap_text( char *s )
{
    char *t;

    /* ignore blanks */
    if ( 0 == s[0] ) return;

    /* NOTE: silently fails when past line max */
    if (cap_idx < CAP_ROWS) {
        t = &cap_text[cap_idx][0];
        snprintf( t, strlen(s)+1, "%s", s);
        cap_idx++;
    }       
}

/* static */
void
build_cap_text ( void )
{
    char r[ 60 * 8 ]; /* 60 seconds with possible diff color code for each */
    char hms[ CAP_COLS * 8 ];
    int i, j, k, sn, sg, sb;
    char *tc; /* point to text color */
    static char ltc[16]; /* last text color */

    memset( cap_text, 0, sizeof(cap_text));
    cap_idx = 0;
/*    if (utsets < 2) return; // too few seconds? */

    /* anything above 30 transport errors/second may be unwatchable */
    snprintf( r, sizeof(r)-1,
        BN "Errors/sec: " BG "GOOD: .=0,1-9 " BY "OK: a-z=10-35 " BR "BAD: A-Z=36-61 # >61 * >99 " BW "?=na");
    add_cap_text( r );
    snprintf( r, sizeof(r)-1, BN "  Wall    Cap  0         1         2         3         4         5");
    add_cap_text( r );
    snprintf( r, sizeof(r)-1, BN "hh:mm:ss " BW "hh:mm:" BN "012345678901234567890123456789012345678901234567890123456789");
    add_cap_text( r );

    /* step thru every 60 bytes */
    for (i = 0; i < utsets; i += 60 )
    {
        int h,m,s, h1, m1, s1;

        if (i >= CAP_STZ) {
            add_cap_text( "Capture log limit reached.");
            add_cap_text( "Recompile with larger CAP_STZ.");
            break; /* don't go past buffer limit */
        }
        /* show minute at start of line */
        h1 = h = (i / 3600) % 24;
        m1 = m = (i / 60) % 60; 
        s1 = s = i % 60;

        /* tloc3 is start cap timeval */
        s1 += tloc3.tm_sec;
        if ( s1 > 60 ) {
            s1 %= 60;
            m1++;
        }

        m1 += tloc3.tm_min;
        if ( m1 > 60 ) {
            m1 %= 60;
            h1++;
        }

        h1 += tloc3.tm_hour;
        h1 %= 24;

        /* show wall clock and capture clock to the minute */
        snprintf( hms, sizeof(hms)-1, BN "%02d:%02d:%02d " BW "%02d:%02d " BN,
                h1, m1, s1, h, m);

        memset( ltc, 0, sizeof(ltc)); /* reset color so first test will set */
        memset(r, 0, sizeof(r)); /* clear it for this round */
        k = 0;

        /* build text for seconds status for rest of line */
        for (j = 0; j < 60; j++)
        {
            short t; /* match cap stats data type */
            unsigned char t1;

            /* stop at current second of current minute */
            if ( (i+j) >= CAP_STZ) {
                add_cap_text("Capture log limit reached.");
                add_cap_text("Recompile with larger CAP_STZ.");
                break; /* don't go past buffer limit */
            }
            if ( (i+j) >= utsets ) break; /* don't go past current time */

            t = cap_stats[ i + j ];
            
            t1 = ' ';                   /* want to know if still ' ' */
            /* 1-9 a-z A-Z, ASCII */
            if ((t > 0) && (t < 62)) {
                t1 = '0'+t;             /* intermittent 0-9 is watchable */
                if (t > 9) t1 = 'a' + (t-10);  /* not good */
                if (t > 35) t1 = 'A' + (t-36); /* gettin bad */
            }
        
            if (t > 61) t1 = '#';       /* really bad */
            if (t > 99) t1 = '*';       /* doesnt matter after this bad */
            
            if (t == 0 ) t1 = '.';      /* no errors is on the dot */
            if (t < 0  ) t1 = '?';      /* -1 is no data available */

            if (t < 0) {                /* no data collected */
                sn++;                   /* count no data seconds */
            } else {
                if (t < 36 ) {
                    sg++;               /* count good seconds */
                } else {
                    sb++;               /* count bad seconds */
                }
            }

            tc = BN;
            if (t > 35 ) tc = BR;               /* 35 and above is red */
            if ( (t > 0) && (t < 10) ) tc = BG; /* 0-9 is green, good enough */
            if ( (t > 9) && (t < 36) ) tc = BY; /* 10 to 35 is yellow */
            if (-1 == t) tc = BW;               /* no data is white */

            /* check against previous color used */
            if (0 == strncmp( tc, ltc, 8)) { /* FIXME: use constant */
                tc = "";                /* same doesn't emit color again */
            } else {

/* FIXME: constant to describe why it is 8, ECMA_COLOR_LEN */
                astrncpy( ltc, tc, sizeof(ltc) );
                /* diff color copies for next test */
            }

            if (strlen(tc) > 0) {
                memcpy( &r[k], tc, strlen(tc) ); /* emit color */
                k+= strlen(tc);
            }

            r[k] = t1; /* error indication or . for no error */
            k++;
        }
        snprintf( &hms[strlen(hms)], sizeof(hms)-1, "%s", r);
        add_cap_text( hms );
    }
}


/* similar output to dump cap log below, but on-screen instead of to file */
/* static */
void
show_caplog ( void )
{
    int i, j, lo;
    unsigned char key;
    char f[256];
    char *t;
    int now;

    key = 0;
    lo = 0;

    now = utsnow;

    memset( cap_text, 0, sizeof(cap_text));

    if ( (utsets < 2) || (utsets > sizeof(cap_stats)) || (0 == cap_prev) ) {
        dvrlog( LOG_INFO, "%s utsets %d range", WHO, utsets );
        return; /* too many seconds? */
    }

    filebase( f, out_name, F_FILE);

/* NOTE:
    Set log offset start line to legend lines + current minute to make first
    view of >13m log jump ahead to current minute at top line, so it can
    fill up the display for user lines minutes before needing user to scroll.
    Tried lock-follow within loop but it didn't work very well. Logic Puzzles.
    A kind of scroll wrap that clears rest only if top line redrawn might do.
*/
    if ( (utsets / 60) > (user_lines-3) )/* legend if minutes < lines */
        lo = 3 + utsets/60; /* otherwise jump past legend and old minutes */

    refresh.log = 1;
    build_cap_text();

    for (i=0; i<user_lines;)
    {
        if ( D_LOG != display_type ) return; /* kick out */

        show_status( 1, WHO ); /* clock and cap stats need to update */

        j = i + lo;

        if (refresh.log) {
            aprintf( stderr, "\033[%d;1H" "%s" CEL, 5+i, &cap_text[j][0] );
        }

        i++;
        i %= user_lines;
        key = 0;

        /* end of list redraws header, looks for key and sleeps if no key */
        if (0 == i)
        {
            t = chan_name; /*   "Current"; */
            /*if (CAP_NONE == cap_now) t = "Last"; */

/* update is slow and not reflecting current QoS%, hold a key to update fast */
            if (0 != refresh.log)
            {
                aprintf( stderr, DCA_MGT SCI BW
                    "%s Capture Log for %s   "
                    BW BL"Keys: " BN BR " [f] exit" BN CEL, t, f);

                    nanosleep( &console_read_sleep, NULL);
                    /* get_time(); */
                    build_cap_text(); /* might eat cpu */
            }

            refresh.log--;
            if (refresh.log <0) refresh.log = 0;

            console_getch_fn( &key );
            nanosleep( &console_read_sleep, NULL);
            if (0 == key) continue;
                    
            /* any key refreshes */
            refresh.log = 1;

            /* same key in and out */
            if ( 'f'   == key ) return;

            /* z key stops info cap, but only info cap */
            if ( 'z'   == key ) {
                if ( CAP_INFO == cap_now) {
                    stop_capture( WHO, FAIL_NONE );
                }
                return;
            }

            if ( '?'   == key ) show_keyhelp( caplogkeyhelp );

            if ( KB_UP == key ) lo -= 1;
            if (  '='  == key ) lo -= 1;

            if ( KB_DN == key ) lo += 1;                
            if ( '\''  == key ) lo += 1;

            if ( KB_PU == key ) lo -= user_lines;
            if ( KB_PD == key ) lo += user_lines;

            if (lo < 0) lo = 0; /* sanity limit */
            if ( (lo+user_lines) >= cap_idx) lo = cap_idx - user_lines;
            if (lo < 0) lo = 0; /* sanity limit */
        }
    }
}

/* write to .tsx file:
        sequence[] long longs, start byte offsets, list terminated by -1LL.
        frames[] structure of picture types found and packet counts per type.
    This is called at end of cap, so cap_prev is assumed to be valid.
*/
/* static */
void
dump_frame_sequence ( void )
{
        FILE *f;
        int i, ok;
        long long seq;
        struct frame_s frm;

        char n[256];
        char o[256];

/* list of hold-downs. the order is important for this */
        if (CAP_INFO == cap_prev) return; /* not Event Program Guide Load */
        if (0 != cap_zap) return;       /* not zapped files */
        if (cap_prpn < 1) return;       /* not a single program capture */
        if (0 == arg_frames) return;    /* not without -m */
        if (0 == sequence_idx) return;  /* not without sequences */
        if (0 == cap_frames) return;    /* out of frames overflow? */


/* hold downs complete */
        filebase( n, out_name, F_PFILE );
        advrlog( LOG_INFO, "%s %d frames %d sequences",
                WHO, frame_idx, sequence_idx );

/* open .tsx file */
        memset( o, 0, sizeof(o));
        snprintf( o, sizeof(o)-1, "%s.tsx", n );
        f = fopen( o, "w");

        if (NULL != f) {

/* expand and write sequence data */
            seq = 0;
            for (i = 0; i < sequence_idx; i++) {
                seq += 0xFFFFFFFFLL & sequences[i];
                ok = fwrite( &seq, sizeof(seq), 1, f);
                if (1 != ok) {
                    dvrlog( LOG_INFO, "failed to write sequences\n");
                    fclose(f);
                    return;
                }
            }
            seq = -1LL;
            ok = fwrite( &seq, sizeof(seq), 1, f);
            if (1 != ok) {
                dvrlog( LOG_INFO, "failed to write sequence terminator\n");
                fclose(f);
                return;
            }
        
/* expand and write frame data */
            frm.vpn = 0;
            for (i = 0; i < frame_idx; i++) {
                frm.pct = 3 & (frames[i] >> 14);
                frm.vpn += 0x3FFF & frames[i];
                ok = fwrite( &frm, sizeof(frm), 1, f);
                if (1 != ok) {
                    dvrlog( LOG_INFO, "failed to write frames\n");
                    fclose(f);
                    return;
                }
            }
            
            fflush( f );
            fclose( f );
        } else {
            dvrlog( LOG_INFO, "%s error writing %s", WHO, o );
        }

        advrlog( LOG_INFO, "%s done", WHO);
}




/*
 show list of channels with callsigns and sids, DCA to line offset + 3.
 call this after display_type D_CHANNELS picked to draw list of channels.
 */
/* static */
void
show_chanlist ( void )
{
        int i, j;
        struct sig_s *s;
        char c[16];      /* DCA string */

/* if displaying channel list */
        if (D_CHANNELS != display_type) return;
        if (0 == refresh.channels) return;
        refresh.channels = 0;

        show_status( 0, WHO );

/* redraw is easier to notice when cursor is on */
        aprintf( stderr, "%s", SCI );

        for (j=0; j < user_lines; j++) {

/* 7 bytes color, 7 bytes DCA, near 16 byte limit */
                snprintf( c, sizeof(c)-1, BN "\033[%d;1H", 3 + j );
                aprintf( stderr, "%s" CEL, c );

/* blank the usable rows after last channel */
                i = channel_offset + j;
                if (i >= scan_idx) continue;
                s = &ptc[ scan_list[ i ] ].sig;

/* doesn't need sleep here, this is refresh screen only */
//              console_scan();
//              nanosleep(&console_read_sleep, NULL);

/* stop display if not in channel scan display anymore */
                if (D_CHANNELS != display_type) break;
                show_signal( s, i );
        }
}




/*
 TODO FIXME: re-write this to integrate pgm guide, channel list, timer list
 and vct/mgt lists and keys that are active in those screens

 needs to do different things based on display_type
 it's a big restructuring so it may never get done
*/

/*
 this is where you want to do user functions or set flags based on keys
 current key definitions: (incomplete)
 1-9 or A-Z is for channel hotkeys
 see keyhelp[] for rest
 function keys handled above in console esc
*/
/* static */
void
console_scan ( void )
{
        int i;
//      int x, y;
        unsigned char kb;
        struct sig_s *s;
    
        i = 0; // hush compiler
        s = &ptc[cap_chan].sig;

/* sleep done elsewhere
    nanosleep( &console_read_sleep, NULL );
*/

/* do nothing if -d or -s. detach & scripted cap do not need user input */
        if (arg_detach != 0) return;
/*      if (arg_capture != 0) return; */

        console_getch_fn( &kb );

        if (kb == 0) return;

/* force stale auto-guide to wait a few seconds if any key is hit */
        get_time();
        if (utstpg < utsnow) utstpg = utsnow + (300 * (1 + arg_devnum));

/* -K console_getch disables echo first, then get outs */
        if (arg_nokb != 0) return;

        /* any key will reset the no scan timeout */
        if (kb != 0)
/* NOTE: adjust this for at least one pass thru chanlist */
            utsfut = utsnow + SIGNAL_SCAN_TIMEOUT;

    /********************************
        LOOK FOR THESE KEYS ALWAYS
     ********************************/

        switch(kb) {

/* do nothing */
        case 0:
            return;
            break;

        case 'j':
            dump_epg_grid();
#if 0
            for (i=0; i<search_idx; i++)
                dvrlog(LOG_INFO, "%s", search_list[i].name);
#endif
            break;


/* DEBUG: manual force test guides */
        case 'i':
            dvrlog( LOG_INFO, "User requests test guides");
            utstpg = utsnow - 1;

/* let the main show status loop catch it */
/*          test_epgs( WHO ); */
            fprintf( stderr, HOM BC"%-32s", "OK: Guide Test");
            break;

#ifdef USE_MCAST
        case 'u':
            udp_mcast = ~udp_mcast;
            break;
#endif
        
        /* show cap log */
        case 'f':
            if (utsets < 1) break;

            display_type = D_LOG;
            refresh.log = 1;
            show_caplog();
            display_type = D_TIMERS;
            set_refresh();
            show_status( 0, WHO );
            break;

        /* MGT table */
        case 'g':
            if (0 == pkt.fmgt) break;

            display_type = D_MGT;
            refresh.mgt = 1;
            show_master_guide_table();
            display_type = D_TIMERS;
            set_refresh();
            show_status( 0, WHO  );
            break;
        
        /* Virtual Channel Table display */
        case 'v':
            if (0 == vc_ncs) {
                dvrlog( LOG_INFO, "%s no VCT to display", WHO);
                break;
            }
            display_type = D_VCT;
            refresh.vct = 1;
            show_virtual_channels();
            display_type = D_TIMERS;
            set_refresh();
            show_status( 0, WHO );
            break;

        /* Program Guide */
        case 'p':

            scan_sig = 0;       /* sig scan bogs program guide */

#if 0
            if (0 == pgm.idx) break;
/* extra annoying hold-downs */
            /* unselect any guide filters if no valid events */
            if (pgm.idx == 0) {
                pgm.age = 0;
                pgm.hide = 0;
                pgm.find = 0;
            }
#endif
            display_type = D_EPG;
            refresh.epg = 1;
            show_program_guide();

/* in case any new timers added */
/*          dump_epg_html( epg, &pgm, pg, WHO ); */
            display_type = D_TIMERS;
            set_refresh();
            show_status( 0, WHO );  /* no wait for timer list */
            break;

        /* load program guide from current channel */
        case 'l':
            /* only if no cap already in progress */
            if (CAP_NONE == cap_now)
                cap_now = CAP_INFO;

            break;          

/* toggle ATSC/MPEG2 table and packet counts */
        case 's':
            refresh.pstats = 1;
            display_stat = ~display_stat;
            test_termsize(); /* pkt stat changes number of lines to display */
            set_refresh();
            show_status( 0, WHO  );
            break;
            
/* toggle timer time display between user and timer mode */
        case 'e':
            if (CAP_TIME == cap_now) {
                cap_etime = ~cap_etime;
                refresh.headers = 1;
                show_headers(0);
                /* show_status( 0, WHO ); */
            }
            break;
            
/* DEL (BS backspace key in console and aterm) (stop manual cap) */
        case 127:
            if ( (CAP_INFO == cap_now) || (CAP_USER == cap_now) ) {
                stop_capture( WHO, FAIL_NONE );
                scan_sig = ~0;
            }
            break;

/* DEL (BS backspace key in xterm) (stop manual cap) */
        case 8:
            if ( (CAP_INFO == cap_now) || (CAP_USER == cap_now) ) {
                stop_capture( WHO, FAIL_NONE );
                scan_sig = ~0;
            }
            break;

/* override timer, switches to manual cap mode */
        case 'o':
            if (CAP_TIME == cap_now) {

#if 0
/* FIXME: this causes problems with making capture stop
    reque or remove timer0 before going manual
                reschedule_timer(0, WHO);
                refresh.timers = 1;
*/
#endif
                cap_now = CAP_USER;
            }
            break;

/* reschedule weekday or remove volatile timer. stops cap if index is 0 */
        case 'r': 
            timer_reschedule();
/* timer may reschedule or expire, so refresh timer list */
            display_type = D_TIMERS;
            set_refresh();
            timer_sort = ~0;
            break;      

/* same as reschedule for active timer 0 and also deletes the capture */
        case 'z':
            timer_zap();
/* timer may reschedule or expire, so refresh timer list */
            display_type = D_TIMERS;
            set_refresh();
            timer_sort = ~0;

/* without this, if weekday timer zapped before end of timeslot, 
    it reloads it in slot 0 because config file changed?

    TESTME: not supposed to save config on weekday timer reschedule...

*/
            show_timers();

/* wait one minute before doing next test epg */
            if (utsnow > utstpg) utstpg += PROGRAM_GUIDE_TIMEOUT;
            break;

            
#if DEBUG
        /* clear all timers */
        case '!':
            reset_timers();
            aprintf(stderr, "\033[%d;1H" CCE, 4); /* keep header */
            show_headers(0);
            break;
#endif

/* too easy to hit instead of load guide */
#if 0
        /* toggle quiet mode on or off */
        case 'k':
            arg_quiet = ~arg_quiet;
            show_headers(1);
            refresh.timers = 1;
            show_chanlist();
            show_timers();
            break;
#endif
            
        /* toggle timer/channel list */
        case 9:
            if ( CAP_NONE != cap_now ) break; /* not while capture */
/*          if ( 0 != arg_cable ) break; // let cable show the long list */

            /* not as nice as an invert speedwise but doesn't matter here */
            if ( D_TIMERS == display_type ) {
                display_type = D_CHANNELS;
                refresh.channels = 1;
            } else {
                if ( D_CHANNELS == display_type ) {
                    display_type = D_TIMERS;
                    set_refresh();
                }
            }
            
            /* clear from start of line 3 to end */
            snprintf( csp, 16, "\033[3;1H");
            aprintf( stderr, "%s" CCE, csp);
            show_headers(0);

/* enable signal scan for all channels */
            if ( D_CHANNELS == display_type )
            {
                scan_sig = ~0;
                scan_one = 0;
                /* draw initial channel signal list display */
                show_chanlist();
                /* will be updated automatically by signal scan */
            }

            show_status( 0, WHO); /* will call show_timers() */
            break;          

/* FF ^L clears tube, redraws headers */
        case 12:
            set_title();        /* FIXME: doesn't work over ssh + screen */
            set_refresh();
            timer_sort = ~0;

/* will increment to first channel */
/* scan_next = scan_idx; */
/* scan_one = 0; */
            show_status( 0, WHO );
            show_chanlist();
            break;

/* set a timer for the current channel */
        case KB_IN:
        case 't':
            get_timer_add();
            set_refresh();
            timer_sort = ~0;
            break;

        /* delete a timer by # */
        case KB_DL:
        case 'd':
            if (timer_idx > 0) {
                get_timer_delete();
                set_refresh();
            }
            break;      

        /* move a timer by # to config by # */
        case 'm':
            if (timer_idx > 0) {
                get_timer_move();
                set_refresh();
            }
            break;
                        
        /* quit */
        case 'q':
            if (CAP_NONE == cap_now) /* prevent accidental quit */
//              if (0 != arg_tmpfs) save_tmpfs( WHO );
                console_exit(0); 
            break;

/* shift for both of these to prevent accidents */
        /* input configuration file */
        case '_':
            advrlog( LOG_INFO, "user loads cfg" );
/* reset test config update time */
            utstcf = 0; /* clear the hold down */
            test_config(1, WHO ); /* 1 forces load */
            break;

/* output configuration file */
        case '+':
            advrlog( LOG_INFO, "user saves cfg" );
            save_config( WHO );
            break;


/* timer/channel scroll control, up down, ' and = if no edit pad,
    up, down, page up and page down need edit pad or alt keypad
*/
        case KB_UP:
        case '=': /* equal sign */
            if (D_CHANNELS == display_type) {
                if (channel_offset < 0) channel_offset = 0;
                if (channel_offset > 0) channel_offset--;
                scan_pos = channel_offset;
                refresh.channels = 1;
                show_chanlist();
            }
            if (D_TIMERS == display_type) {
                if (timer_offset < 0) timer_offset = 0;
                if (timer_offset > 0) timer_offset--;
                refresh.timers = 1;
                show_timers();
            }
            break;

        case KB_PU:
            if (D_CHANNELS == display_type) {
                if (channel_offset > user_lines) {
                        channel_offset -= user_lines;
                } else {
                        channel_offset = 0;
                }
                scan_pos = channel_offset;
                refresh.channels = 1;
                show_chanlist();
            }

            if (D_TIMERS == display_type) {

                if (timer_offset > user_lines) {
                        timer_offset -= user_lines;
                } else {
                        timer_offset = 0;
                }
                if (timer_offset < 0) timer_offset = 0;
                refresh.timers = 1;
                show_timers();
            }       
            break;

        case KB_DN:
        case '\'': /* single quote */
            if (D_CHANNELS == display_type) {
                if (channel_offset < (channel_idx - user_lines))
                        channel_offset++;
                if (channel_offset >= channel_idx) 
                        channel_offset = channel_idx - user_lines;
                scan_pos = channel_offset;
                refresh.channels = 1;
                show_chanlist();
            }

            if (D_TIMERS == display_type) {
                if (timer_offset < (timer_idx - user_lines))
                        timer_offset++;
//              if (timer_offset >= timer_idx) timer_offset = 0;
                if (timer_offset >= timer_idx)
                            timer_offset = timer_idx - user_lines;
                refresh.timers = 1;
                show_timers();
            }
            break;
            
        case KB_PD:
            if (D_CHANNELS == display_type) {
                if ((channel_offset+user_lines) < (channel_idx-user_lines)) {
                    channel_offset += user_lines;
                } else {
                    channel_offset = channel_idx - user_lines;
                }
                scan_pos = channel_offset;
                refresh.channels = 1;
                show_chanlist();
            }

            if (D_TIMERS == display_type) {
                if ((timer_offset + user_lines) < (timer_idx - user_lines)) {
                        timer_offset += user_lines;
                } else {
                        timer_offset = timer_idx - user_lines;
                }
//              if (timer_offset >= timer_idx) timer_offset = 0;
                if (timer_offset >= timer_idx)
                        timer_offset = timer_idx - user_lines;
                refresh.timers = 1;
                show_timers();
            }
            break;

        case KB_HM:
            if (D_CHANNELS == display_type) {
                channel_offset = 0;
                refresh.channels = 1;
                show_chanlist();
            }

            if (D_TIMERS == display_type) {
                timer_offset = 0;
                refresh.timers = 1;
                show_timers();
            }
            break;

        case KB_EN:
            if (D_CHANNELS == display_type) {
                channel_offset = channel_idx - user_lines;
                refresh.channels = 1;
                show_chanlist();
            }
            if (D_TIMERS == display_type) {
                timer_offset = timer_idx - user_lines;
                refresh.timers = 1;
                show_timers();
            }
            break;
            
        /* keyboard help */
        case '/':
        case '?':
            advrlog( LOG_INFO, "user needs help" );

            refresh.timers = 0;
            show_keyhelp( timerskeyhelp );
            set_refresh();
            show_status( 0, WHO  );         
            break;

        /* range checks would go here if there were any for this mode */
        default:
                /* super debug */
                advrlog( LOG_INFO, "console any scan ignores key 0x%X", kb);
            break;
        }
/* done with keys available during capture */


    /************************************************
     LOOK FOR THESE KEYS IN TIMER/CHANNEL LISTS WITH NO CAPTURE IN PROGRESS
     ************************************************/

    if (CAP_NONE == cap_now) {
        switch( kb ) {

#ifdef USE_POWERDOWN
/* close device within 2s, so you can run something else on dvb device */
        case 'c':
            scan_sig = 0;
            scan_one = ~0;
            utspdd = utsnow + 2;
            break;
#endif


#if 0
/* Start full cap no matter what current pn/vc/va set. */
/* It works, but don't like the vc override. use VCT Guide instead. */
/* It's also too close to the enter key. */
        case '\\':
            cap_now = CAP_USER;
            cap_pn = -1;
            cap_vc = -1;
            cap_va = -1;
            break;
#endif

/* ENTER key: full cap or vid+aud selected in VCT Guide. */
        case 10:
            cap_pn = s->pn;
            cap_vc = s->vc;
            cap_va = s->va;

/* if pn set and epg exists, find current event in EPG and add a timer */
            if ((CAP_NONE == cap_now) && (cap_pn > 0)) {
                int cp;
                cp = find_current_epg_pgm();
                if (cp >= 0) {
                        dvrlog( LOG_INFO,
                                "%s add search event timer epg[%04X]",
                                    WHO, pg[cp] );
                        s->lzpgt = 0;
                        add_search_event_timer( &epg[ pg[ cp ]] );

                        save_config( WHO );
                        timer_sort = ~0;
                        refresh.timers = 1;
                        break;
                }
            }

            cap_now = CAP_USER;

            break;

#if 0
/* this is different than 'x' above that resets signal stats only */
/* reset peaks, refresh */
        case 'x':

/* only for channel list */
            if (D_CHANNELS != display_type) break;
            for ( x=0; x < scan_idx; x++ ) {
                    struct scanlist_s *n;
                    n = ptc;
                    y = scan_list[x];
                    s = &n[y].sig;
                    s->strength = 0;
                    s->str_avg = 0;
                    s->snr = 0;
                    s->lock = s->lock_sum = 0;            
            }
            show_chanlist();
            break;
#endif

        /* SP (spacebar key) channel lock toggle */
        case 32:
            scan_one = ~scan_one;
            /* if unlocking, turn on scan, timer may disable it later */
            if (scan_one == 0) scan_sig = ~0;
            break;

/* auto EPG toggle, new feature for pchdtvr 1.0 */
        case 'a':
            {
                s = &ptc[ scan_list[scan_pos] ].sig;

                if (0 != s->pgto) {
                    s->pgto = 0;
                    s->pgmt = -1;
                } else {
                    s->pgto = 1; /* default is 3 hours */
                    s->pgmt = 0;
/*                  utstpg = utsnow + PROGRAM_GUIDE_TIMEOUT; */
                }
                advrlog( LOG_INFO, "APG%02d AGTO %d", s->chan, s->pgto);
                save_config( WHO );
            }
            break;

/* toggle snr display header/value change */
        case 'w':
            display_sigtype++;
            /* -x goes thru entire list including regular basic info */
            display_sigtype %= SIG_MODREG;
            show_headers(0);
            refresh.channels = 1;
            refresh.headers = 1;
            show_chanlist();
            break;          

/* range check instead of 35 cases for channel hotkeys */


/* first group of channel hotkeys are numeric 1-9 */
#define USE_ISOC_PEDANTIC
#ifdef USE_ISOC_PEDANTIC
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
#else
        case '1' ... '9':
#endif

/* plus one for scan_next to be 1-n instead of 0-n */
                scan_next = kb - '0'; /* 1 - 9 */
                
                /* stay in list */
                if (scan_next > scan_idx) break;

/* loop around */
//              if (scan_next >= scan_idx) scan_next %= scan_idx;

                /* lock and scan for signal */
                scan_freq = 0;
                scan_one = ~0;

/* if hit same channel twice and on bcast toggle scan sig, else set,
    unless esave or cable, then make user hit it twice to open device.
*/
                if (scan_pos == (scan_next - 1) ) {
                    scan_sig = ~scan_sig;
                    scan_next = 0;
                } else {
                    scan_sig = ~0; 
//                  scan_sig = 0; // doesnt change channels correctly

/* channel change resets bottom line table found indicators */
                    pkt.fvct = 0;
                    pkt.fpat = 0;
                    pkt.fpmt = 0;
                    pkt.fmgt = 0;
                    chan_name[0] = 0;
                }

                if (scan_next != 0) {
                    cap_chan = scan_list[ scan_next - 1 ];
                } else {
                    cap_chan = scan_list[ scan_pos ];
                }


/* hot key needs to load guide to make console update faster */
                load_guide( cap_chan, WHO );

/*
                if (0 != vc_ncs)  set_vc(WHO); 
*/

/* faster update than waiting on status */
                if (0 != vc_ncs) {
                    refresh.vstats = 1;
                    show_vc_selection();
                }
                refresh.estats = 1;
                show_event_short();

/* hitting the key should make it set the channel */
                scan_freq = 0;

                break;

/* second group of channel hotkeys are alpha A-Z */
#ifdef USE_ISOC_PEDANTIC
        case 'A':
        case 'B':
        case 'C':
        case 'D':
        case 'E':
        case 'F':
        case 'G':
        case 'H':
        case 'I':
        case 'J':
        case 'K':
        case 'L':
        case 'M':
        case 'N':
        case 'O':
        case 'P':
        case 'Q':
        case 'R':
        case 'S':
        case 'T':
        case 'U':
        case 'V':
        case 'W':
        case 'X':
        case 'Y':
        case 'Z':
#else
        case 'A' ... 'Z':
#endif

                scan_next = kb - 'A'; /* 11 - 36 */
                scan_next += 10;

                /* stay in list */
                if (scan_next > scan_idx) break;

                /* lock and scan for signal */
                scan_freq = 0;
                scan_one = ~0;

/* if hit same channel twice and on bcast toggle scan sig, else set,
    unless esave or cable, then make user hit it twice to open device.
*/
                if (scan_pos == (scan_next - 1) ) {
                    scan_sig = ~scan_sig;
                    scan_next = 0;
                } else {
                    scan_sig = ~0;
//                  scan_sig = 0; // doesn't change channels correctly

#if REMOVEME
                    /* do not reset cap pids */
                    /* cap_vc = cap_va = -1; */
                    /* cap_pidx = 0; */
#endif

                    /* channel change resets bottom line indicators */
                    pkt.fvct = 0;
                    pkt.fpat = 0;
                    pkt.fpmt = 0;
                    pkt.fmgt = 0;
                    chan_name[0] = 0;
                }

                if (0 != scan_next) {
                    cap_chan = scan_list[ scan_next - 1 ];
                } else {
                    cap_chan = scan_list[ scan_pos ];
                }

/* hot key needs to load guide to make console update faster */
                load_guide( cap_chan, WHO );

/*
                if (0 != vc_ncs) set_vc(WHO);
*/

/* faster update than waiting on status */
                if (0 != vc_ncs) {
                    refresh.vstats = 1;
                    show_vc_selection();
                }
                refresh.estats = 1;
                show_event_short();

/* hitting the key should make it reset the channel */
                scan_freq = 0;

                break;

        default:
                advrlog( LOG_INFO, "console chan scan ignored key 0x%X", kb);
                break;
        }
    }
}


/* ATSC TRANSPORT STREAM FUNCTIONS ******************************************/

/************************************************************ ATSC STT helper 
 ATSC uses 32 bit unsigned from 00:00:00 UTC, Jan 6, 1980 for epoch
 unix uses 32 bit unsigned from 00:00:00 UTC, Jan 1, 1970 for epoch
 main calls: inits global utc_offset difference, includes seconds east/west
*/
/* static */
void
atsc_calc_epoch ( void )
{
        struct tm as = { 0,0,0,6,0, 80,0,0,0 }; /* Jan 6, 1980 00:00:00 UTC */
        struct tm uc = { 0,0,0,1,0,107,0,0,0 }; /* Jan 1, 2007 00:00:00 UTC */
        time_t utd;

/* in case Znn config file trusted time source becomes broken */
        utc_check = mktime( &uc ); /* don't let STT set time below this value */
        utsgmt = uc.tm_gmtoff;

/* convert ATSC System epoch date+time into unix system epoch seconds */
        utd = mktime( &as );

        if (-1 != utd) {
/* correct for seconds east of greenwich meridian (negative is west) */
                utc_offset = utd + utsgmt;
                advrlog( LOG_INFO, " UTC offset+DST %d", utc_offset);
        }
}

/* if arg_strict set, this logs the bits that failed */
/* static */
void
atsc_strict_log ( unsigned char *r, char *n )
{
        char t[64];
        int i;
        if (0 == arg_strict) return;

        t[0] = 0;
    
        for (i=0; i< 12; i++) { /* build 33 byte string */
            sprintf( &t[strlen(t)], "%02X ", r[i]);
        }

        dvrlog( LOG_INFO, "%-6s %s", n, t);
}

/* generic build payload:
    For payload tables STT, MGT, VCT, EIT, ETT, RRT, PAT and PMT.

    This only works for payloads with section lengths, not video or audio.

    Also, to be generic, all payloads are allocated 4096 bytes, but
    RRT and VCT only use 1021 bytes. STT is 56 bits but uses one packet.

    RRT may be expanded soon, so there may be a need to parse it instead
    of current use of built-in table with RRT CRC32 used for QoS test.
    
    p is packet, s is payload structure, n is name for logging purposes.
    returns 0 if done, 1 if not done.
*/
/* static */
int
atsc_build_payload ( struct payload_s *s, unsigned char *p, char *n )
{
    unsigned char *r;
    int psi;
    int payout;
    short pid;
    
    r = NULL;
    payout = 0;

    pid = 0x1FFF & ( (p[1] << 8) | p[2] );
    psi = 1 & (p[1] >> 6);

    r = p + 4; /* skip 4 byte TS header */

/* payload start indicator yes */
    if (0 != psi) {
        r++; /* skip past offset byte */
/*      atsc_strict_log( r, n ); */
        s->payoff = 0;
        s->sl = ((0xF & r[1])<<8) | r[2];
        payout = (3 + s->sl) - s->payoff;
        if (payout > 183) payout = 183;
/*
        dvrlog( LOG_INFO, "%s PSI1 payout %03X", n, payout);
*/
        if (payout < 1) return 0;
        memcpy( s->payload, r, payout);
        s->payoff += payout;
/*
        dvrlog( LOG_INFO, "%s PSI1 payoff %03X", n, s->payoff);
*/
        if ( s->payoff >= s->sl+3 ) {
            return 0;
        }
        return 1;
    }   

/* payload start indicator no */
    if (0 == psi) {
        /* first time, or last payload was good? */
        if (0 == s->payoff) { /* last valid payload clears s->payoff */
            return 1;    /* drop payload, it is out of order */
        }

        payout = (3 + s->sl) - s->payoff;
        if (payout > 184) payout = 184;
/*
        dvrlog( LOG_INFO, "%s PSI0 payout %03X", n, payout);
*/
        if (payout < 1) return 0;

        if ( (s->payoff + payout) > 4095 ) {
            advrlog( LOG_INFO, "%s payoff %04X exceeds %03X buffer\n",
                    n, s->payoff + payout, 4095 );
            return 1;
        }
        memcpy( &s->payload[ s->payoff ], r, payout);
        s->payoff += payout;

/*
        dvrlog( LOG_INFO, "%s PSI0 payoff %03X", n, s->payoff);
*/
        if ( s->payoff >= s->sl+3 ) {
            return 0;
        }
        return 1;
    }

/* payload not handled */
    return 1; /* shush compiler */
}


/* FIXME: TODO: if VCT exists, and program not on VCT list,
   add to end of vc[] list and increment vc_ncs
 */
/****************************************************************** MPEG2 PAT
 * rebuild pat to single vc pmt entry
 */
/* static */
void
atsc_build_pat ( unsigned char *p, int pn, int pmtpid )
{
#ifdef USE_MPEG_REBUILD
#warning using MPEG PAT rebuild
    unsigned int new_crc;
    unsigned short sl = 13; /* fixed length for one program */

    if (CAP_INFO == cap_now) return;
    if (pn < 1) return;
    if (pmtpid < 1) return;
    if (cap_pn < 1) return;
    if (cap_pn != pn) return;

    advrlog( LOG_INFO, "%s pn.%d PMT %04X", WHO, pn, pmtpid);

/* copy section control header portion */
    memset( new_pat, 0, sizeof(new_pat));

    memcpy( &new_pat[0], p, 13 );

/* copy section data portion for a specific VC */
/* but only works if pg/nn.vc loaded... */

    memcpy( &new_pat[13], p + 13 + (cap_vc*4), 4);

    new_pat[13] = 0xFF & (pn >> 8);
    new_pat[14] = 0xFF & pn;

/* 0xC0 is reserved bits for pmtpid */
    new_pat[15] = 0xC0 | (0x1F & (pmtpid >> 8));
    new_pat[16] = 0xFF & pmtpid;

/* set new pat section length which is fixed at 13 for a single program. */
//    new_pat[6] = (0xF0 & new_pat[6]) | (0x0F & (sl>>8));
    new_pat[6] = 0xB0; /* syntax, 0, two reserved bits 1, 4 bit top of sl */
/* 1 offset byte from payload start, 8 byte section header, 4 byte data */
    new_pat[7] = 0xFF & sl;

    advrlog( LOG_INFO, "%s new PAT pn.%d pmtpid %04X sl %03X",
            WHO, pn, pmtpid, sl);

/* compute new pat crc */
    new_crc = calc_crc32( &new_pat[5], sl-1 );

/* store crc at end of new pat */
    new_pat[ sl+4 ] = 0xFF & (new_crc>>24);
    new_pat[ sl+5 ] = 0xFF & (new_crc>>16);
    new_pat[ sl+6 ] = 0xFF & (new_crc>>8);
    new_pat[ sl+7 ] = 0xFF & new_crc;

    pat_built = ~0;
#else
    pat_built = 0;
#endif

#if 0
/* only needed for debugging, remove from production for one less crc32 */
    {
        unsigned int chk_crc;
        chk_crc = calc_crc32( &new_pat[5], sl+3);
        if (0 != chk_crc)
            dvrlog( LOG_INFO, "%s chk_crc %08X", WHO, chk_crc);
    }
#endif

}


/****************************************************************** MPEG2 PAT
 There is not a lot of interesting stuff here until/unless have to modify it.
 xine seems ok w/stream not fully matching PAT, i.e. missing program streams.
 Some stations send PAT program # info in a different order  from the VCT.
 Solve by keeping one list for VCT and xref by pgm# 2nd list for PAT+PMT info.
*/
/* static */
void
atsc_parse_pat ( unsigned char *p )
{
    unsigned char *r;
    unsigned short sl;
    unsigned char vn, cni, sn, lsn;
    unsigned short tsi1, pgn, netpid, pmtpid;
    unsigned int pat_crc, vcn;
    short tsx;
    int terr;
    struct tsid_s *tsn;
    struct sig_s *s;

    s = &ptc[cap_chan].sig;

    pkt.patp++;
    pkt.fpat = PAY_READ;
    pat.payok = atsc_build_payload( &pat, p, "PAT" );
    if (0 != pat.payok) return;
    pat.payoff = 0;
    pkt.patt++;

    /* pat is one packet usually, so can get away with this */
    /* point to table id */
    r = pat.payload;

    terr = 0;
    if (MPEG_PAT != r[0]) terr = ~0;            /* PAT table ID 0 */

//    if (0 != (0x80 & r[1])) terr = ~0;                /* syntax bit must be set */

/* -A strict also applies to MPEG. cable reserved bits are wrong */
    if (0 != arg_strict)
    {
        if (   ( 0xB0 != (0xF0 & r[1]) )        /* syntax,0,two reserved */
            || ( 0xC1 != (0xC1 & r[5]) )        /* reserved/cni */
            || ( 0x00 != r[6] )                 /* should be 0 */
            || ( 0x00 != r[7] )                 /* should be 0 */
        )
            terr = ~0;
    }

    if (0 != terr) {
        dvrlog( LOG_INFO, "PAT PID 0000 reserved bits fail");
        atsc_strict_log( r, "PAT reserved bits fail");
        return; /* check reserved bits saves time */
    }

    sl = ((0xF & r[1])<<8) | r[2];      /* 12 bit section length */
    pat.sl = sl;
    pat_crc = calc_crc32( r, sl+3 );    /* want crc to validate it */
    if (0 != pat_crc) {
        pkt.crcpat++;
        dvrlog( LOG_INFO, "PAT CRC error" );
//      return;                         /* ignore if invalid crc */
    }

    tsi1 = (r[3]<<8) | r[4];    /* ts id is now checked */
    vn = 0x1F & (r[5]>>1);      /* version is now checked */
    cni = 1 & r[5];             /* current next not checked. */
    sn = r[6];                  /* section numbers not checked */
    lsn = r[7];                 /* last section number not checked */

    r += 8;

    pkt.fpat = PAY_GOOD;


/* if no version change, still need to change Continuity Counter */
    if (pat.vn == vn) {

/* update pat if it was rebuilt */
        if ((CAP_INFO != cap_now) && (cap_pn>0) && (0 != pat_built)) {
            new_pat[3] &= 0xF0;

/* set Continuity Counter to match current */
            new_pat[3] |= 0x0F & p[3];
            advrlog( LOG_INFO, "%s %04X PAT CC now %1X",
                    WHO, 0, 0x0F & p[3]);

#ifdef USE_MPEG_REBUILD
            memcpy( p, new_pat, 188);
#endif

        }
/* don't update rest of table if no version change to save processing */
        return;
    }



    pkt.fpat = PAY_PARSE;

    pat.vn = vn;
    pkt.pat++;
    
    /* set PAT OK to speed up display but right way is:
        set not found until PAT proven to be found and not obsolete NIT
     */
    pkt.fpat = PAY_GOOD;

    pat_ncs = 0;

    /* start the payload loop, and stop at p+4+sl. */
    /* start with first vc[] and work way up saving PMT data for each */
    while( r < pat.payload + (pat.sl-1)) {
        if ( 0xC0 != (0xC0 & r[2]) ) {
            dvrlog( LOG_INFO, "PAT NCS bad rb %02X", r[2]);
            return; /* stop if no reserved bits */
        }

        pgn = (r[0] << 8) | r[1]; /* should be valid program # */

#ifdef USE_AUTO_TSID
/* no hidden, NTSC or even TSID numbers */
        if ( (0 < pgn)
          && (0xFFFF != pgn)
          && (0x80 > pgn)
          && (1 == (tsi1 & 1))
          && (0 == arg_scan)
            ) {
            tsx = find_tsidx( tsi1, pgn, WHO );

/* -1 is not found */
            if (tsx >= 0)
            {
                tsn = &tsids[tsx];
                if (pgn == s->pn) {
                        snprintf( tsn->call, 8, "%s", s->call);
                        tsn->call[7] = 0;
                        snprintf( tsn->sid, 4, "%s", s->sid);
                        tsn->sid[3] = 0;            
                }
            } else {
                tsn = &tsids[tsidx];
                tsn->tsid = tsi1;
                tsn->ptc = s->ptc;
                tsn->pn = pgn;

                *tsn->call = 0;
                *tsn->sid = 0;

                if (pgn == s->pn) {
                        snprintf( tsn->call, 8, "%s", s->call);
                        tsn->call[7] = 0;
                        snprintf( tsn->sid, 4, "%s", s->sid);
                        tsn->sid[3] = 0;            
                } else {

/* not current program, set Call Sign to TS-TSID and Station ID to PTC */
                        snprintf( tsn->call, 8, "TS-%04X", tsi1 );
                        snprintf( tsn->sid, 4, "%03d", s->ptc); 
                }
                tsidx++;    
/* is found, update the callsign and sid */
            }
        }
#endif



/* program number 0 is obsoleted network information table.
   TESTME: this shows up on cable PTC that has a lot of blank PMTs
    NIT may be an indicator for a list of services?
*/
        if (0 == pgn) {
            netpid = 0x1FFF & ( (r[2]<<8) | r[3] );
            dvrlog( LOG_INFO, "PAT%02d obsoleted NIT %04X", cap_chan, netpid);
            r += 4;
            continue; /* skip NIT */
        };

        pkt.fpat = PAY_GOOD;

        pmtpid = 0x1FFF & ( (r[2]<<8) | r[3] );

        if (pat_ncs >= VCZ) {

/* It's likely this will occur on cable. Need to work on VC/PA abstract,
    but knowing which VC/PA to remove based on CA needs sort_vc + hindsight,
    and could generate all kinds of strange problems if vc index changes.

        Some viewable PMTs at end of big PAT on cable? Most is junk so far.

    For now: Only alert user if PAT is ridiculous size for broadcast.
             Tolerate ridiculous program numbers up to .16, but not higher.
             This will redux the log message for same error on cable.
*/
            if (0 == arg_cable)
                dvrlog( LOG_INFO, "PAT ncs maxed at %d, PGM %04X PMTPID %04X "
                                "and rest ignored", VCZ, pgn, pmtpid);
            break; /* only 8 VC via PAT */
        }

/* vc cap copies out a single program/pmtpid table entry */
        if (cap_pn > 0) {
                if (cap_pn == pgn) {
                        if (sl < 179) {
                                atsc_build_pat( p, pgn, pmtpid );
                        }

/* if vc unset but pn set and matches this vc, use this pa index for vc */
                        if (-1 == cap_vc) {
                                cap_vc = pat_ncs;
                        }
                        cap_pids[1] = pmtpid;
                }
/* if found, put in cap_pids for keeping */
                cap_pids[0] = 0;
        }

        pa[ pat_ncs ].tsid = tsi1;
        pa[ pat_ncs ].pn = pgn;
        pa[ pat_ncs ].pmtpid = pmtpid;

        advrlog( LOG_INFO, "PAT ts id %04X pn %d PMTPID %04X rebuilt %d",
                tsi1, pgn, pmtpid, pat_built);

/* NOTE: don't do this after VCT loads, the order may have changed */
        if (vct_ncs < 1) { /* no vct yet? have to put something in vc[] */
            if (-1 == find_vc_pgm( pgn, WHO) ) {
                advrlog( LOG_INFO, "PAT adds pn.%d new to vc[]", pgn);
                vc[ pat_ncs ].tsid = tsi1;
                vc[ pat_ncs ].pn = pgn;
                vc[ pat_ncs ].pmtpid = pmtpid;
            }
            /* else already added to list */

        } else {

/* NOTE:
    This may be source of KQED issues, and the logic may be incorrect for
    any station that plays the PMT activate and deactivate game. When KQED
    reconfigures, program number order in both VCT and PAT PMT list change.
    the vc ordering changes, but the program number doesn't change.
*/    
        /* have a vct, see if pgm is on it */
            vcn = find_vc_pgm( pgn, WHO);
            if (-1 == vcn) {
                advrlog( LOG_INFO, "PAT adds pn.%04X missing from VCT, vc_ncs %d",
                        pgn, vc_ncs);
                vc[ vc_ncs ].pn = pgn; /* want extra pat+pmt to show at end */
                vc[ vc_ncs ].pmtpid = pmtpid;
                vc[ vc_ncs ].tsid = tsi1;
                vc_ncs++;
            } else {

/* TESTME: This belongs under strict ATSC checking? FOX KRIV gets these? */
/*              if (0 != arg_strict) */
                {
                    if (pgn != vc[vcn].pn)
                        dvrlog( LOG_INFO,
                                "PAT%02d PGM %04X doesn't match VCT %04X",
                                cap_chan, pgn, vc[vcn].pn );

                    if (pmtpid != vc[vcn].pmtpid)
                        dvrlog( LOG_INFO,
                                "PAT%02d PMT %04X doesn't match VCT %04X",
                                cap_chan, pmtpid, vc[vcn].pmtpid );

                    if (tsi1 != vc[vcn].tsid)
                        dvrlog( LOG_INFO,
                                "PAT%02d TSID %04X doesn't match VCT %04X",
                                cap_chan, tsi1, vc[vcn].tsid );
                }
            }
        }

        advrlog( LOG_INFO, "PAT pa%d PMT %04X PGN %04X TS ID %04X",
                pat_ncs, pa[ pat_ncs ].pmtpid,
                pa[ pat_ncs ].pn, pa[ pat_ncs ].tsid );


        /* increment number of channels found in pat */
        pat_ncs++;
        r += 4; /* skip to next program number and PID */
    }

    if (vct_ncs >= pat_ncs) {
        vc_ncs = vct_ncs;
    } else {
        vc_ncs = pat_ncs;
    }

    if (0 != pat_built) memcpy( p, new_pat, 188 );
    refresh.vstats = 1;         /* new PAT refreshes vc status line */

    advrlog( LOG_INFO, "PAT VN %02X found %d programs", vn, pat_ncs);
}
/***************************************************************** MPEG2 PAT */

/* not needed for broadcast, but what about cable? */
/****************************************************************** MPEG2 CAT
 CAT appears when RC flag in PMT. since rc is stuffed, cat is too
*/
/* static */
void
atsc_test_cat ( unsigned char *p, unsigned short pid )
{
    unsigned char *r;
    unsigned int sl;
    unsigned int cat_crc = 0;

    pkt.catp++;
    pkt.fcat = PAY_READ;

    if (0 == arg_cable) return;

    cat.payok = atsc_build_payload( &cat, p, "CAT" );
    if (0 != cat.payok) return;

    advrlog(LOG_INFO, "%s CAT PID %04X payoff %03X", WHO, pid, cat.payoff);
    cat.payoff = 0;

    /* point to table id */
    r = cat.payload;

    if  (MPEG_CAT != r[0]) return;              /* CAT table ID 1 */

    if (0 != arg_strict) {
        if ((0x30 != (0x30 & r[1]))
        ||  (0xC0 != (0xC0 & r[5])) ) {         /* reserved bits */
            atsc_strict_log( r, "CAT bad");
            return; /* check reserved bits saves time */
        }
    }

    sl = ((0xF & r[1])<<8) | r[2];      /* 12 bit section length */
    cat_crc = calc_crc32( r, sl+3 );    /* only want crc to validate it */
    if (cat_crc != 0) {
        pkt.crccat++;
        return;
    }
    pkt.cat++;

/* not doing anything with CAT except counting errors for QoS */
    if (cap_pn > 0) pkt.keep = 0;
}
/***************************************************************** MPEG2 CAT */

/**************************************************************** MPEG2 PMT
 * rebuild pmt to one video and one audio from cap_pn 
 */
/* static */
void
atsc_build_pmt ( unsigned char *p, unsigned int pid, unsigned int osl )
{
#ifdef USE_MPEG_REBUILD
#warning using MPEG PMT rebuild
    unsigned char *r, *d, *s;
    unsigned int i, c, sl, new_crc;

    pmt_built = 0;

    if (cap_pn < 1) return;
    if (CAP_INFO == cap_now) return;
    
    if (pid != cap_pids[1]) return;

/* KQED-HD PMT PID 0030 can't do this because it's too large
   and because the first packet is already written. So far,
   KQED-HD is only known station with this problem. All the
   rest send single packet PMTs.

   One way around is to hold down emit of PMT until rebuilt
   as one packet here, but chasing CC errors will be fun.
*/
    if (osl > 179) {
        dvrlog( LOG_INFO, "Not building multi-packet PMT");
        return;
    }

    memset( new_pmt, 0, sizeof(new_pmt));

    advrlog( LOG_INFO, "%s %04X PMT oldsl %03X newsl %03X",
            WHO, pid, osl, 13);

    d = new_pmt;
    memcpy( d, p, 17);          /* 4 byte header, 13 byte control data */
    d += 17;                    /* new pmt */
    sl = 13;                    /* does not count header */
    r = p + 17;                 /* old pmt */

/* pcr pid is don't care here. should have been set correctly elsewhere */
    c = ( (0x0F & p[15]) << 8 ) | p[16]; /* program info len 12 bottom bits */

/* only copy and increment if program info len non zero */
    if (0 != c) {
        i = c;
        s = r;

/*step thru descriptors */
        for ( i = 0; i < c; ) {
            if (0xAA == *s) {
                *s = 0x80; /* we have no corruption today */
                advrlog( LOG_INFO, "%s %04X  RC stuffed", WHO, pid);
            }
            advrlog( LOG_INFO, "%s %04X PMT PI tag %02X len %02X",
                        WHO, pid, *s, s[1]);
            i += s[1]+2; /* increment count */
            s += s[1]+2; /* increment pointer */
        }       
        memcpy( d, r, c );
        r += c; /* next place in old pmt */
        sl += c; /* section len in new pmt */
    }
    advrlog( LOG_INFO,"%s %04X PMT pilen %03X newsl %03X",
            WHO, pid, c, sl );

/* ok to add zero, not ok to memcpy size 0 */
    d += c; /* next place in new pmt */
    
    while (r < (p + (osl-1)) ) {
        unsigned int e;
        if ( (0xE0 == (0xE0 & r[1])) && (0xF0 == (0xF0 & r[3])) ) {
            e = ((0x1F & r[1]) << 8 ) | r[2]; /* es pid bottom 13 bits */
            c = ((0x0F & r[3]) << 8 ) | r[4]; /* es info len 10 bottom bits */

/* preamble 5 bytes, copy this much at least, es info len may be zero */
            c += 5;

/* if es pid matches vc or va pid copy entry to new pmt */
            if ( (e == cap_pids[2]) || (e == cap_pids[3]) ) {

/* needs a strict boundary check. the while above is not enough */
                memcpy( d, r, c );

                d += c; /* next place in new pmt */
                sl += c; /* section len in new pmt */
                advrlog(LOG_INFO,"%s %04X PMT pid %04X esi %03X newsl %03X",
                        WHO, pid, e, c, sl);
            }
            r += c; /* next place in old pmt */

        } else {
            /* no reserved bits stops loop */
            advrlog( LOG_INFO, "%s %04X no reserved bits",
                    WHO, pid);
            break;
        }
    }    

/* set the following:
    set syntax and reseserved bits in top 4 bits of r[6]
    0 in bottom 4 bits of r[6]

    section length in all 8 bits of r[7].
    only handling sections < 179 bytes so 8 bits is enough.
*/

// this only copies the bad reserved bits
//    new_pmt[6] = (0xF0 & new_pmt[6]) | (0x0F & (sl>>8));

    new_pmt[6] = 0xB0;
    new_pmt[7] = 0xFF & sl;

/* compute new pmt crc */
    new_crc = calc_crc32( &new_pmt[5], sl-1 );

/* store crc at end of new pmt */
    new_pmt[ sl+4 ] = 0xFF & (new_crc>>24);
    new_pmt[ sl+5 ] = 0xFF & (new_crc>>16);
    new_pmt[ sl+6 ] = 0xFF & (new_crc>>8);
    new_pmt[ sl+7 ] = 0xFF & new_crc;

/* tell the caller the new pmt has been built */
    pmt_built = ~0;

    advrlog( LOG_INFO, "PMT%02d %04X v %04X a %04X",
            cap_chan, pid, cap_pids[2], cap_pids[3]);
#else
    pmt_built = 0;

#endif

#if 0
/* only needed for debugging, remove from production for one less crc32 */
    {
        unsigned int chk_crc;
        chk_crc = calc_crc32( &new_pmt[5], sl+3);
        if (0 != chk_crc)
            dvrlog( LOG_INFO, "%s %04X chk_crc %08X",
                    WHO, pid, chk_crc);
    }
#endif
}

/******************************************************** MPEG COMPONENT NAME
A/65b Table 6.38 Multiple String Structure
 does Huffman decomp
 r points to start of descriptor after tag and count bytes
 puts result in vc[n].cname, truncated to 8 chars
 TESTME: These are not compressed and do not need huffman decode?
*/
/* static */
void
atsc_parse_mss_cname ( unsigned char *r, int n )
{
    unsigned int nstr, nseg, comp, mode, nchr;
    unsigned int i,j;
    char lang[4];
    char t[512];
    char *d;
    
    d = t; /* stupid compiler tricks */

    r += 2;

    memset( t, 0, sizeof(t));
    nstr = r[0];
    for (i = 0; i < nstr; i++) {
        memcpy(lang, &r[1], 3);
        lang[3] = 0;
        r += 4;                         /* 3? */
        nseg = *r++;
        for (j = 0; j < nseg; j++) {
            comp = *r++;
            mode = *r++;
            nchr = *r++;

/* nchr should never be above 255 with no compression */
            if ( (0 == comp) && (0 == mode) ) {
                nchr++;
                if (nchr > 256) nchr = 256;
                astrncpy( t, (char *)r, nchr );
            }

/* FIXME: KPXB kludge, mode 0xFF. requires non-strict mode */
/* Haven't been able to receive KPXB for > year, not sure if this works. */
            if ( (0 == arg_strict) || ((0 != arg_strict) && (0xFF == mode)) )
            {
/* nchr should never be above 512 with compression */
                if ((1 == comp) || (2 == comp)) {
                    if (nchr > sizeof(t) ) nchr = sizeof( t );
                    huffman_decode( d, r, sizeof(t)-1, nchr, comp);
                }
            }
            if (comp > 2) snprintf( t, sizeof(t)-1, "[%s] L%02X C%02X M%02X",
                                    lang, nchr, comp, mode);
        }
    }

/* truncate PMT component name at 7 chars */
    t[7] = 0;
    strncpy( vc[n].cname, t, 8);
    advrlog( LOG_INFO, "PMT vc[%d].cname %s", n, vc[n].cname);
}

/**************************************************************** MPEG2 PMT */
/* The MPEG2 Program Map Table gives the following information on a single VC:
 *      Video and Audio PID list and which PID for the clock reference.
 *      Descriptors containing stream format parameters for Video and Audio.
 */
/* static */
void
atsc_parse_pmt ( unsigned char *p, short pan )
{
    unsigned char *r, *s, *b;
    unsigned short sl, pgn, pcrpid, pilen, pid, espid, esilen, acn;
    unsigned char vn, cni, sn, lsn, st, numes, stm;
    unsigned int pmt_crc;
    unsigned int pmt_crc0;
    int pmtvc, pmtpa;
    int i, terr;
    struct payload_s *pmp;
    short tsx;

    pkt.pmtp++;
    acn = 0;

    pmtpa = pan;                /* program association index */
    pmp = &pmt[pan];

/* single program cap needs one PAT as first packet */
    if (cap_pn > 0) {

/* hold down output until PAT seen */
        if (0 == pkt.pat) {
            pkt.keep = 0;
            return;
        }
    }

    pid = 0x1FFF & ((p[1] << 8) | p[2]);

    pan &= (VCZ - 1);

    pkt.fpmt = PAY_READ;

    pmp->payok = atsc_build_payload( pmp, p, "PMT" );
    if (0 != pmp->payok) return;
    pmp->payoff = 0;
    pkt.pmtt++;

    /* point to table id */
    r = pmp->payload;

    terr = 0;
//    if (MPEG_PMT != r[0]) terr = ~0;          /* PMT table ID 2 */
    if (MPEG_PMT != r[0]) return;

/* -A option enables strict reserved bits check */
    if (0 != arg_strict)
    {
        if (   ( 0xB0 != (0xF0 & r[1]) )        /* syntax, 0, two reserved */
            || ( 0xC1 != (0xC1 & r[5]) )        /* reserved/cni */
            || ( 0x00 != r[6] )                 /* should be 0 */
            || ( 0x00 != r[7] )                 /* should be 0 */
            || ( 0xE0 != (0xE0 & r[8]) )        /* reserved */
            || ( 0xF0 != (0xF0 & r[10]) )       /* reserved */
        )
                terr = ~0;
    }

    if (0 != terr) {
        dvrlog( LOG_INFO, "PMT PID %04X reserved bits fail", pid);
        atsc_strict_log( r, "PMT reserved bits fail" );
        return; /* check reserved bits saves time */
    }

    pmp->sl = sl = ((0xF & r[1])<<8) | r[2];    /* 12 bit section length */
    pmt_crc0 = 0;

#define DEBUG_PMT_CRC
#ifdef DEBUG_PMT_CRC
    pmt_crc = calc_crc32( r, sl-1 );            /* computed crc is non zero */
    pmt_crc0 |= r[ sl - 1];
    pmt_crc0 <<= 8;
    pmt_crc0 |= r[ sl ];
    pmt_crc0 <<= 8;
    pmt_crc0 |= r[ sl + 1 ];
    pmt_crc0 <<= 8;
    pmt_crc0 |= r[ sl + 2 ];
#else
    pmt_crc = calc_crc32( r, sl+3 );            /* full crc validate = 0 */
#endif
/* does computed match received? */
    if (pmt_crc0 != pmt_crc) {
        pkt.crcpmt++;
        dvrlog( LOG_INFO, "PMT PID %04X bad CRC32 RCVD %08X CALC %08X",
                pid, pmt_crc0, pmt_crc);
//      return;
    }

    pgn = r[3] << 8;
    pgn |= r[4];                        /* 16 bit program number */

    vn = 0x1F & (r[5] >> 1);
    cni = 1 & r[5];
    sn = r[6];
    lsn = r[7];

    advrlog( LOG_INFO, "%s %04X PMT SLen %03X  PAT ncs %d",
            WHO, pid, sl, pat_ncs);

    pcrpid = (0x1F & r[8]) << 8;
    pcrpid |= r[9]; /* PID of stream with PCR */

    pilen = (0x0F & r[10]) << 8;
    pilen |= r[11]; /* program info len */

    r += 12; /* start of program info descriptors */

    /* do until PAT ncs says done */

    pmtvc = find_vc_pgm( pgn, WHO );
    pmtpa = find_pa_pgm( pgn, WHO );

/* no vct, so pmt has to fill in */
    if (vct_ncs < 1) {
            pmtvc = pmtpa;
    }
    
/* will see this error if PMT arrives before PAT. this ok */
    if (-1 == pmtpa) {
        advrlog( LOG_INFO, "ch %02d PMT %04X no PAT pa[].pn stop",
                cap_chan, pid );
        return; /* get out because no PAT vc/pa means no place to put data */
    }

/* this one is more important to log for user to see */
    if ( pmtpa >= VCZ ) {
        dvrlog( LOG_INFO, "ch %02d PMT ncs %u over limit VCZ %d stop",
                cap_chan, pmtpa, VCZ);
        return;
    }

/* don't update vc[] if no version change */

    if ( vn == pa[ pmtpa ].vn ) {

        advrlog( LOG_INFO, "%s %04X pa%d.vn %02X no chg", WHO, pid, pmtpa, vn );

/* update pmt if program search set vc #, pmt matches vc and was rebuilt */
/* KQED-HD fix: but only if section len indicates PMT is a single packet */
        if ( (CAP_INFO != cap_now)
          && (cap_pn > 0)
          && (pid == cap_pids[1])
          && (sl < 180) /* 188 - (4 byte header + 4 byte crc) */
          && (0 != pmt_built) ) {

/* set Continuity Counter to match current */
                new_pmt[3] &= 0xF0;
                new_pmt[3] |= 0x0F & p[3];

#ifdef USE_MPEG_REBUILD
                memcpy( p, new_pmt, 188 );
#endif
        }
        if (vct_ncs < 1) return;

/* should return if VCT vn same as last VCT vn, but fall thru if different */
/* KQED-HD fix: handle new VCT arriving after PMT and needing update */
/* hmm get rid of need to udpate vc[] and all those problems go away */
        if (vct.vn == vct.lv) {
                advrlog( LOG_INFO, "PMT %04X vct.vn %02X no chg",
                            pid, vct.vn);

#ifdef USE_MEPG_REBUILD
//              if (0 != pmt_built)
#endif
                    return; /* rebuild if need to */
        } else {
            dvrlog( LOG_INFO, "PMT %04X vct.vn %02X %02X chg",
                        pid, vct.lv, vct.vn);
        }
    }

    advrlog( LOG_INFO, "PMT PID %04X pn %d pa %d patncs %d vc %d vcncs %d vctncs %d PCR %04X",
            pid, pgn, pmtpa, pat_ncs, pmtvc, vc_ncs, vct_ncs, vn, pcrpid);

    pa[ pmtpa ].lv = pa[ pmtpa ].vn;
    pa[ pmtpa ].vn = vn;
    if (pmtvc >= 0) vc[ pmtvc ].pmtvn = vn;

    pa[ pmtpa ].pcrpid = pcrpid;
    if (pmtvc >= 0) vc[ pmtvc ].pcrpid = pcrpid;

    if (pa[ pmtpa ].lv != pa[ pmtpa ].vn)
        pkt.pmt++;

/* each PAT vc has separate PMT descriptor, copy to pa[] */
    if ( ((sl - 12) < 1021) && ((sl - 12) > 0) ) {
        pa[ pmtpa ].pilen = pilen;
        memcpy( pa[ pmtpa ].pidesc, r, pilen );

/* if VCT vc found that matches, copy there as well */
        if (pmtvc >= 0) {
            vc[ pmtvc ].pilen = pilen;
            memcpy( vc[ pmtvc ].pidesc, r, pilen );
        }
    }   

    pa[ pmtpa ].ca = 0;
    if (pmtvc >= 0) vc[ pmtvc ].ca = 0;

/* parse program info descriptors for interesting flags */
    for ( ; r < (pmp->payload + 11 + pilen); ) {

/* conditional access descriptor exists for cable PMT and also in ES info.
   indicate the VC is scrambled so build vc text can skip it.
*/
        if (0x09 == *r) {
            pa[ pmtpa ].ca = 1;
            if (pmtvc >= 0) vc[ pmtvc ].ca = 1;
        }
/* corrupt hollywood, trying to establish a government appointed monopoly */
        if (0xAA == *r) { /* The Justice: "What's next? Washing machines?" */
            pkt.pmtrc = ~0; /* washingdone */
            pkt.rc++;
        }

/* Program Component Name, might be wrong. Ideally should be callsign. */
        if (0xA3 == *r) { /* component name */
            atsc_parse_mss_cname( r, pmtvc ); /* puts 7 chars in vc[i].cname */
        }

        r += r[1]+2; /* step past junk */
    }

    /* save out stream types with pids and descriptors */
    numes = 0; /* start with first vc */

    s = r; /* hey nettles have a cigar! */

/* first loop is to put video first */
    for ( ; r < (pmp->payload + (sl-1)); ) {
        if  (0xE0 != (0xE0 & r[1])) { /* reserved bits */
            dvrlog( LOG_INFO, "%s %04X MPEG ES rb[1] fail %02X",
                        WHO, pid, r[1]);
            break;
        }

/* FIXME: cable has r[3] = 0, test it only under strict for now */
        if (0 != arg_strict) {
            if (0xF0 != (0xF0 & r[3])) {
                dvrlog( LOG_INFO, "%s %04X MPEG ES rb[3] fail %02X",
                        WHO, pid, r[3]);
                break;
            }
        }

        st = r[0]; /* stream type */
        espid  = 0x1FFF & ( (r[1] << 8) | r[2] );
        esilen = 0x0FFF & ( (r[3] << 8) | r[4] ); /* ES info len */

        /* video first */
        if (2 != st) {
            r += 5 + esilen;
            advrlog( LOG_INFO, "%s %04X MPEG not 1st ES", WHO, pid );
            continue;
        }
        advrlog( LOG_INFO, "%s %04X pa%d.%d t %02X pid %04X esi %03X",
                WHO, pid, pmtpa, numes, st, espid, esilen);

        r += 5; /* skip parsed */
        pa[ pmtpa ].estype[ numes ] = st;
        pa[ pmtpa ].espid[  numes ] = espid;
        pa[ pmtpa ].esilen[ numes ] = esilen;

/* single program capture needs to set the video pid to keep */
        if (cap_pn == pa[ pmtpa ].pn) {
            cap_pids[2] = espid;
            advrlog( LOG_INFO, "PMT VID PID %04X", espid);
        }

/* stream type no match */
        stm = 0;

        if (pmtvc >= 0) {

#if 0
/* NO: MPEG PMT should override possibly incorrect VCT */
/* only copy to vc[] if stream type and espid match */
            if ( st == vc[ pmtvc ].estype[ numes ])
                if (espid == vc[ pmtvc ].espid[ numes ])
#endif
                    stm = ~0; /* stream type is match */

            /* no vct, so pmt has to fill in */
            if (vct_ncs < 1) stm = ~0;
            if (0 != stm) {
                advrlog( LOG_INFO, "PMT backfills vc ES info");
                vc[ pmtvc ].estype[ numes ] = st;
                vc[ pmtvc ].espid[  numes ] = espid;
                vc[ pmtvc ].esilen[ numes ] = esilen;
            }
        }

/* is the ES info descriptor length sane? */
        if ( (esilen > 0) && (esilen < 1024) ) {

            if (0 != stm)
                vc[ pmtvc ].esilen[ numes ] = esilen;

/* copy ES descriptor in case no VCT with same */
            memcpy( &pa[ pmtpa ].esdesc[ numes ][ 0 ], r, esilen );
            if (0 != stm)
                memcpy( &vc[ pmtvc ].esdesc[ numes ][ 0 ], r, esilen );

/* always keep lang code */
            for (i = 0; i < esilen; ) { /* bump i manually here */

/* if has conditonal access, set whole VC scrambled */
                if (0x09 == r[ i ]) vc[ pmtvc ].ca = pa[ pmtpa ].ca = 1;

/* copy iso 639 lang code in case VCT has it missing */
                if (0x0A == r[ i ]) {

                    memcpy( &pa[ pmtpa ].eslang[ numes ][0], &r[ i + 2 ], 3);
                    pa[ pmtpa ].eslang[ numes ][3] = 0;

/* FIXME: and vc[].eslang is blank, or different? or leave in pa[] only */
                    if (0 != stm) {
                        memcpy( &vc[ pmtvc ].eslang[ numes ][0], &r[ i + 2 ], 3);
                        vc[ pmtvc ].eslang[ numes ][3] = 0;
                    }

                }
                i += r[ i + 1 ] + 2; /* add data len + header len */
            }
        }
        r += esilen;
        numes++;
        break; /* do not loop */
    }

    r = s; /* hey nettles have a cigar! */


/* second loop is to put audio after video */
    for ( ; r < (pmp->payload + (sl-1)); ) {

        if  (0xE0 != (0xE0 & r[1])) {   /* reserved bits */
            dvrlog( LOG_INFO, "%s %04X A/52 ES rb[1] fail %02X",
                    WHO, pid, r[1]);
            break;
        }

/* cable has r[3] = 0 */
        if (0 != arg_strict) {
            if (0xF0 != (0xF0 & r[3])) {
                dvrlog( LOG_INFO, "%s %04X A/52 ES rb[3] fail %02X",
                        WHO, pid, r[3]);
                break;
            }
        }
        
        st = r[0]; /* stream type */
        espid  = 0x1FFF & ( (r[1] << 8) | r[2] );
        esilen = 0x0FFF & ( (r[3] << 8) | r[4] ); /* ES info len */

/* skip video already parsed in first loop above */
        if (0x81 != st) {
            r += 5 + esilen;
            continue;
        }

/* count the audio channels in this vc for show vct to have correct audio # */
        
        advrlog( LOG_INFO, "%s %04X pa%d.%d t %02X pid %04X esi %03X",
                WHO, pid, pmtpa, numes, st, espid, esilen );

        r += 5; /* skip parsed */
        pa[ pmtpa ].estype[numes] = st;
        pa[ pmtpa ].espid[numes] = espid;
        pa[ pmtpa ].esilen[numes] = esilen;

/* single program capture needs to set the audio pid to keep */
        if (cap_pn == pa[ pmtpa ].pn)
            if (acn == cap_va) {
                cap_pids[3] = espid;
                advrlog( LOG_INFO, "PMT AUD PID %04X", espid);
            }
        stm = 0;
        if (pmtvc >= 0) {

#if 0
/* only copy to vc[] if stream type and espid match */
            if (st == vc[ pmtvc ].estype[ numes ])
                if (espid ==  vc[ pmtvc ].espid[ numes ])
#endif
                    stm = ~0;

            /* no vct, so pmt has to fill in */
            if (vct_ncs < 1) stm = ~0;
            if (0 != stm) {
                advrlog( LOG_INFO, "PMT backfills audio ES info");
                vc[ pmtvc ].estype[numes] = st;
                vc[ pmtvc ].espid[numes] = espid;
                vc[ pmtvc ].esilen[numes] = esilen;
            }
        }

        if ( (0 != esilen) && (esilen < 1024) ) {
            if (0 != stm)
                vc[ pmtvc ].esilen[ numes ] = esilen;
/* copy ES descriptor to vc[] for display */
            memcpy( &pa[ pmtpa ].esdesc[ numes ][0], r, esilen );
            if (0 != stm)
                memcpy( &vc[ pmtvc ].esdesc[ numes ][0], r, esilen );
/* always keep lang code */
            for (i = 0; i < esilen; ) { /* bump i manually here */

/* Extract audio rates and compute channels if available via descriptor.
   It may not be very accurate. some stations send 2.0 as 5.1 but only
   use the front left and front right audio channels.
*/
                if (0x81 == r[ i ]) {
                    unsigned char brc, nch;
                    int brv;
                    int brt[32] = {
                                  32,  40,  48,  56,  64,  80,  96, 112,
                                 128, 160, 192, 224, 256, 320, 384, 448,
                                 512, 576, 640,  -1,  -1,  -1,  -1,  -1,
                                  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 };
                    b = r + i + 2;
                    brc = 0x1F & ( b[1] >> 2);  /* bit rate code */
                    if (brc > 19) brc = 19;
                    brv = brt[brc];
                    if (brv > 0) brv *= 1000;
                    pa[ pmtpa ].abr[ numes ] = brv;
                    vc[ pmtvc ].abr[ numes ] = brv;

/* default: 1.0 is monaural at 48kHz */
                    nch = 1;

/* detected enough for stereo */
                    if (brv >= 192000) nch = 2;

/* 5.1 is 6 speakers. Broadcast can switch to 448kbits from 384kbits.
   384kbits might be the mode used when no full surround is available.
   They'll be called 5.1 Low and 5.1 High until I figure out the rest.
*/
                    if (brv >= 384000) nch = 5;
                    if (brv >= 448000) nch = 6;

                    pa[ pmtpa ].ach[ numes ] = nch;
                    vc[ pmtvc ].ach[ numes ] = nch;

                }

/* if has conditonal access, set whole VC scrambled */
                if (0x09 == r[ i ]) vc[ pmtvc ].ca = pa[ pmtpa ].ca = 1;

/* copy iso 639 lang code in case no VCT with same */
                if (0x0A == r[ i ]) {
                    memcpy( &pa[ pmtpa ].eslang[ numes ][0], &r[ i+2 ], 3);
                    pa[ pmtpa ].eslang[ numes ][3] = 0;
                    if (0 != stm) {
                        memcpy( &vc[ pmtvc ].eslang[ numes ][0], &r[ i+2 ], 3);
                        vc[ pmtvc ].eslang[ numes ][3] = 0;
                    }                   
                }
                i += r[ i+1 ] + 2; /* add data len + header len */
            }
        }
        r += esilen;
        numes++;
        acn++;
    }


/* third loop is to put non video and non audio last on the list */
/* lumping all non-video non-audio under A/90 category, even if incorrect */
    for ( ; r < (pmp->payload + (sl-1)); ) {
    
        if (numes >= VCZ) break;

        if  (0xE0 != (0xE0 & r[1])) { /* reserved bits */
            dvrlog( LOG_INFO, "%s %04X A/90 ES rb[1] fail %02X",
                    WHO, pid, r[1]);
            break;
        }
        if (0 != arg_strict) {
            if (0xF0 != (0xF0 & r[3])) {
                dvrlog( LOG_INFO, "%s %04X A/90 ES rb[3] fail %02X",
                        WHO, pid, r[3]);
                break;
            }
        }
        
        st = r[0]; /* stream type */
        espid  = 0x1FFF & ( (r[1] << 8) | r[2] );
        esilen = 0x0FFF & ( (r[3] << 8) | r[4] ); /* ES info len */

        /* skip video and audio already parsed above */
        if ( (0x02 == st) || (0x81 == st) ) {
            r += 5 +esilen;
            continue;
        }

        advrlog( LOG_INFO, "%s %04X pa%d.%d t %02X pid %04X esi %03X",
                WHO, pid, pmtpa, numes, st, espid, esilen );

        /* non-video next */
        r += 5; /* skip parsed */
        pa[ pmtpa ].estype[numes] = st;
        pa[ pmtpa ].espid[numes] = espid;
        pa[ pmtpa ].esilen[numes] = esilen;

/* shouldn't be any of these, log if they show up */
        advrlog( LOG_INFO, "PMT non-av type %02X PID %04X ILen %04X",
                st, espid, esilen);

/* TESTME: possible contention point if PMT has different order for
     non-av than VCT, but is moot if they never show up here
 */
        stm = 0; /* now means "ok to add" instead of "is match" */
        if (pmtvc >= 0) {

/* only update vc[] if blank */
/*          if (0 == vc[ pmtvc ].estype) */
            {
                vc[ pmtvc ].estype[numes] = st;
                vc[ pmtvc ].espid[numes] = espid;
                vc[ pmtvc ].esilen[numes] = esilen;
                stm = ~0;
            }

            /* no vct, so pmt has to fill in */
            if (vct_ncs < 1) stm = ~0;
        }

        if ( (0 != esilen) && (esilen < 1024) ) {
/* copy ES descriptor to vc[] for display */
            memcpy( &pa[ pmtpa ].esdesc[ numes ][0], r, esilen );
            if (0 != stm)
                memcpy( &vc[ pmtvc ].esdesc[ numes ][0], r, esilen );
/* always keep lang code */
            for (i = 0; i < esilen; ) { /* bump i manually here */

/* if has conditonal access, set whole VC scrambled */
                if (0x09 == r[ i ]) vc[ pmtvc ].ca = pa[ pmtpa ].ca = 1;

/* copy iso 639 lang code in case no VCT with same */
                if (0x0A == r[ i ]) {
                    memcpy( &pa[ pmtpa ].eslang[ numes ][0], &r[ i+2 ], 3);
                    pa[ pmtpa ].eslang[ numes ][3] = 0;
                    if (0 != stm) {
                        memcpy( &vc[ pmtvc ].eslang[ numes ][0], &r[ i+2 ], 3);
                        vc[ pmtvc ].eslang[ numes ][3] = 0;
                    }
                }
                i += r[ i+1 ] + 2; /* add data len + header len */
            }
        }
        r += esilen;
        numes++;


    }
    for (i = 0; i < pat_ncs; i++) {
        if (0 != pa[i].ca) {
            tsx = find_tsidx( pa[i].tsid, pa[i].pn, WHO );
            if (tsx >= 0) remove_tsid(tsx);
        }
    }

    for (i = 0; i < vc_ncs; i++) {
        if (0 != vc[i].ca) {
            tsx = find_tsidx( vc[i].tsid, vc[i].pn, WHO );
            if (tsx >= 0) remove_tsid(tsx);
        }
    }

    pa[ pmtpa ].pmtes = numes;
    pa[ pmtpa ].acn = acn;

    if (pmtvc >= 0) {
        vc[ pmtvc ].pmtes = numes;
        vc[ pmtvc ].acn = acn;
    }

    pkt.fpmt = PAY_GOOD;    
    
/* determine if this packet should be kept, full cap does not change keep */
    if (cap_pn >= 0) {
        pkt.keep = 0;
        if ( pid == cap_pids[1] ) {

/* PMT not built? Can only rebuild if it's a single packet */
            if (0 == pmt_built) {
                if (sl < 179) atsc_build_pmt( p, pid, sl );
/* if PMT is built, use it */
                if (0 != pmt_built) memcpy( p, new_pmt, 188 );
            }
            pkt.keep = ~0; /* set by parse pat */
        }
    }
    refresh.vstats = 1; /* PMT updates the PIDs status display */
    advrlog( LOG_INFO, "PMT %04X done", pid);
}
/***************************************************************** MPEG2 PMT */



/*********************************************************** MPEG2 VIDEO PES */
/* Looks for Sequence starts and Picture types in single Program capture.
 * Tracks Sequence starts and Picture type write byte offset from vc cap start.
 * If either frame or sequence counts exceed allocations, cap_frames is reset
 * so that dump_frame_sequence() will not write incorrect bogus data.
 * This is a memory optimization to reduce the running atscap footprint.
 * 'atscut -m' and xtscut use larger arrays and should be OK in most cases.
 */
/* static */
void
atsc_test_mpeg2_video_pes ( unsigned char *p, unsigned int pid )
{
        unsigned char psi, pct;
        unsigned int b;
        unsigned int vpn;
        int pav, vcv;
        long long seq;
        int i;
        struct sig_s *s;

        s = &ptc[cap_chan].sig;

        psi = 1 & (p[1]>>6);

/* hold down until PAT and PMT have been seen */
        if ( (0 == pkt.pat) || (0 == pkt.pmt) ) {
            pkt.keep = 0;
            return;
        }

/* if psi set, check for sequence */
        b = 0xFFFFFFFFUL;
/* payload start set should mean SEQ+I, P or B picture */
        if (0 != psi) {

/* only if found pa index for video es pid */
            pav = find_pa_vespid( pid );
            vcv = find_vc_vespid( pid );

            if (pav >= 0) {
                advrlog( LOG_INFO, "%s ESPID %04X PS1 SEQ", WHO, pid);
                for (i = 4; i < 188; i++) {
                    b = (b<<8) | p[i];
/* look for start code */
                    if (0x00000100UL != (0xFFFFFF00UL & b)) continue;
/* Sequence Start code 000001B3 */
                    if ( 0x1B3 == b ) {
                        unsigned char frc;
/* point to SEQ data */
                        i++;
/* marker bit */
                        if (0 == (0x20 & p[i+6])) continue;
/* 12 bits for width */
                        pa[pav].hres = 0xFFF & ((p[i+0] << 4) | (p[i+1] >> 4));
/* 12 bits for height */
                        pa[pav].vres = 0xFFF & ((p[i+1] << 8) |  p[i+2]);
                        s->hres = pa[pav].hres;

/* frame rate code, 4 bits */
                        frc = 0x0F & p[i+3];
                        if (frc > 8) frc = 0;

                        if (vcv >= 0) {
                            vc[vcv].vfr = frame_rate_table[frc];
                            vc[vcv].hres = pa[pav].hres;
                            vc[vcv].vres = pa[pav].vres;
                        }
/* set picture type so next loop doesn't need to run */
                        break; /* found it, stop the loop */
                    }
                }
            }
        }


/* not -m (or frames exceeded) or info cap, or not VC cap: do nothing */
        if (0 == cap_frames) return;
        if (CAP_INFO == cap_now) return;

/* count single pgm vc video packets separately */
        if (cap_pn < 1) return;

/*  is safe to assume cap_pids[2] is video pid.
    it does not get set until pmt is parsed, so acts as another hold down
 */
        if (pid != cap_pids[2]) {
            pkt.keep = 0;
            return;
        }

/* passed allocation and vc test and payload start indicator test */

/* TESTME: not using Physical Clock Reference so this doesn't matter. */
        pkt.afcpcr = ~0; /* first pcr is loaded, ok to process rest */

        b = 0xFFFFFFFFUL;
        if (0 != psi)
        {
                for (i = 4; i < 188; i++)
                {
                    b = (b<<8) | p[i];

                    /* look for start code */
                    if (0x00000100UL != (0xFFFFFF00UL & b)) continue;

                    /* Sequence Start code 000001B3 */
                    if ( 0x1B3 == b ) {

                        /* output byte count at sequence start */
                        if ( sequence_idx < SEQUENCE_MAX ) {

/* This tracks the number of bytes since last sequence to save memory,
   because the offset between sequences will never need more than 32 bits.
   In actual practice, it seems to vary between 18 and 20 bits wide for HD.
*/
                                seq = outbc - last_sbo;
                                sequences[ sequence_idx ] = 0xFFFFFFFFLL & seq;
                                sequence_idx++;
                                last_sbo = outbc;
                        } else {
                                dvrlog( LOG_INFO, "use larger SEQUENCE_MAX");
                                dvrlog( LOG_INFO, ".tsx write disabled");

/* ts capture must set cap_frames to arg_frames or else all captures
   that follow the capture that exceeded FRAME_MAX and/or SEQUENCE_MAX will
   not have sequence data saved, even if they may fit in sequnces[]/frames[].
*/
                                cap_frames = 0;
                        }

/* Intra frame picture type */
                        if ( frame_idx < FRAME_MAX ) {
                                vpn = pkt.vcvid - last_vpn;

/* top 2 bits hold picture type. 1 is Intra frame picture type */
                                frames[ frame_idx ]  = 1 << 14;

/* packet count since last picture (should never exceed 16k packets) */
                                frames[ frame_idx ] |= 0x3FFF & vpn;
                                frame_idx++;
                                last_vpn = pkt.vcvid;
                        } else {
                                dvrlog( LOG_INFO, "use larger FRAME_MAX");
                                dvrlog( LOG_INFO, ".tsx write disabled");
                                cap_frames = 0;
                                break; /* save cycles, stop looping */
                        }
/* break because using Sequence as boundary instead of Intra picture */
                        break;
                    }

/* Picture start code means I P or B frame */
                    if ( 0x100 == b ) {

/* wait for first sequence */
                        if (0 != sequence_idx) {
//                          pct = 7 & (p[i+2] >> 3);
                            pct = 3 & (p[i+2] >> 3);

/* I frame handled above, only check P and B frames */
                            if ( (2 == pct) || (3 == pct) ) {
                                pict[ pct ]++;
                                if (frame_idx < FRAME_MAX) {
                                    vpn = pkt.vcvid - last_vpn;

/* top 2 bits hold picture type. 2 is P type, 3 is B type picture */
                                    frames[ frame_idx ]  = pct << 14;;

/* packet count since last picture (should never exceed 16k packets) */
                                    frames[ frame_idx ] |= 0x3FFF & vpn;
                                    frame_idx++;
                                    last_vpn = pkt.vcvid;
                                } else {
                                    dvrlog( LOG_INFO, "use larger FRAME_MAX");
                                    dvrlog( LOG_INFO, ".tsx write disabled");
                                    cap_frames = 0;
                                    break; /* save cycles, stop looping */
                                }
                            }
                        }
/* break when picture type found */
                        break;
                    } /* keep looping past headers for picture start code */

                } /* end of packet test loop */
        } /* end of payload start indicator 1 */

/* hold down output until first sequence start */
        if ( 0 == sequence_idx) {
                pkt.keep = 0;
                return;
        }

        pkt.vcvid++;
}

/*********************************************************** A/52 AUDIO PES */
/* Single Program capture holds down output until first video sequence.
   Full capture gets all the packets regardless of any other setting.
   No CRC32 to use for QoS. The CRC16 is buried too deep to be quick.
*/
/* static */
void
atsc_test_a52_audio_pes ( unsigned char *p, unsigned int pid )
{
    unsigned char psi;
    psi = 1 & (p[1]>>6);

/* count single vc audio packets separately */
    if (cap_va >= 0) {
        pkt.vcaud++;

/* hold down until pid matches cap_pids[3] (implies vc set or will be set) */
        if (pid != cap_pids[3]) {
                pkt.keep = 0;
                return;
        }

/* hold down until AFTER first video sequence */
        if (0 == sequence_idx) {
                pkt.keep = 0;
                return;
        }

/* hold down until first payload start */
        if (0 != psi) pkt.audps = ~0;
        if (0 == pkt.audps) pkt.keep = 0;
    }
}
/*****************************************************************************/

/* test pid against vc[] video ES PIDs, z if match, nz otherwise */
/* static */
int
atsc_test_vc_vid( short pid )
{
    int i, j;
    for (i = 0; i < vc_ncs; i++)
        for (j = 0; j < vc[ i ].pmtes; j++)

            if ( 0x02 == vc[ i ].estype[ j ] )

                if ( pid == vc[ i ].espid[ j ] )
                    return 0;   
    return ~0;
}

/* test pid against vc[] audio ES PIDs, z if match, nz otherwise */
/* static */
int
atsc_test_vc_aud( short pid )
{
    int i, j;
    for (i = 0; i < vc_ncs; i++)
        for (j = 0; j < vc[ i ].pmtes; j++)

            if ( 0x81 == vc[ i ].estype[ j ] )

                if ( pid == vc[ i ].espid[ j ] )
                    return 0;   
    return ~0;
}


/***************************************************************** MPEG2 PES */
/* ATSC parsed out, whats left is PAT, CAT, PMT, MPEG2 Video and A/52 Audio ES
  TEI should have been checked in test packet. Control PIDs are PAT CAT PMT.
  Control PIDs have CRC32 check done, and some may be filtered if user
  has selected a specific program to capture in show virtual channels..
 */
/* static */
void
atsc_test_mpeg2 ( unsigned char *p, unsigned short pid )
{
    unsigned char *r;
    unsigned char psi;
    int t, pan;

    t = 0;

    psi = 1 & (p[1]>>6);
    r = p+5;

/* have to do these keep checks here or else may miss keeping */
/* packets in any multi-packet payload */

/* full cap keeps everything */
    if (-1 == cap_pn) {
        pkt.keep = ~0;
    } else {
/* single program cap keeps only PAT+PMT+AUD+VID */
        t = find_cap_pid( pid );
        if (t == 0) pkt.keep = ~0;
    }

/* update counters */
    pkt.mpeg2++;

/***************************************************************** MPEG2 PES */


/********************************************************* MPEG2 PAT/CAT/PMT */

    /* Program Association Table ID 0 in PID 0 */


    if (0 == pid) {
        atsc_parse_pat( p ); /* has Program Map PIDs */
        return;
    }

/* is not pid == 1, is table id == 1 */
/* not seen in terrestrial? definitely in cable */
    /* Controlled Access Table ID 1 in PID 1 */
    if (1 == pid) {
        atsc_test_cat( p, pid ); /* crc check at least */
        return;
    }

/* Program Map Table ID 2 in variable PID packet byte 5 */
    pan = find_pa_pmtpid( pid );
    if (-1 < pan) {
/* has video and audio PIDs & descriptors */
        atsc_parse_pmt( p, pan );
        return;
    }

/********************************************************* MPEG2 PAT/CAT/PMT */


/***************************************************************** MPEG2 PES */
/* PAT CAT PMT checks done. Only thing left is video, audio and unknown PIDs.
 * Full capture checks against all pa[] PMT ES PIDs, counts matches and exits;
 *  VC/Program capture counts only current selected matching PIDs.
 * Only thing left after this point is handling the unknown data types
 *  which will not be done because they do not affect playback.
 */

    if (0 == atsc_test_vc_vid(pid)) pkt.vid++; /* overall video count */
    if (0 == atsc_test_vc_aud(pid)) pkt.aud++; /* overall audio count */


    atsc_test_mpeg2_video_pes( p, pid );

    if (cap_pn < 1) {
        pkt.pes++; /* count overall PES */
        return;
    }

/* no VC video until first sequence start seen */

    /* is selected video? */
    if ( pid == cap_pids[2] ) {
//        atsc_test_mpeg2_video_pes( p, pid );
        if (0 != pkt.keep) {
            pkt.pes++;
        }
        return;
    }

/* no VC audio until video first then audio psi 1 */

    /* is selected audio? */
    if ( pid == cap_pids[3] ) {

        /* still waiting for video? */
        if (0 == sequence_idx) {
            pkt.keep = 0;
            return;
        } else {

            /* have video, ok to add audio */
            pkt.keep = ~0;
            /* fall thru to test a52 */
        }
    } else {

        /* not cap pid[2 or 3], don't keep it */
        pkt.keep = 0;
        return;
    }

    atsc_test_a52_audio_pes( p, pid );
    if (0 != pkt.keep) pkt.pes++;
    return;
}
/***************************************************************** MPEG2 PES */


/***************************************************************** ATSC MGT */
/* static */
int
atsc_find_mg_tt( unsigned int tt )
{
        int i;
        tt &= 0x1FFF;

        for (i = 0; i < mg_idx; i++)
                if (tt == mg[i].tt)
                        return i;
        return -1;
}


/***************************************************************** ATSC DCCSCT
  not using directed channel change selection code table
 */
/* static */
void
atsc_test_dccsct ( unsigned char *p )
{
        pkt.dccsct++;
        return;
}

/***************************************************************** ATSC DCCT
  not using directed channel change table
 */
/* static */
void
atsc_test_dcct ( unsigned char *p )
{
        pkt.dcct++;
        return;
}


/******************************************************************* ATSC RRT
 * FIXME: RRT is about to change, need to stop using built-in table.
 * Check the payload bits and check CRC32 for QoS
 *
 * NOTE: this does not handle more than a single RRT
*/
/* static */
void
atsc_test_rrt ( unsigned char *p, int tn )
{
        struct sig_s *s;
        unsigned char *r, vn;
        unsigned short sl; /*, sr; */
/*    unsigned char rr, vn, cni, sn, lsn, pv; */
        unsigned int rrt_crc, pid;
        int terr, mi;

        pkt.rrtp++;
        sl = 0;
        rrt_crc = 0;

        pid = ((0x1F & p[1]) << 8) | p[2];

/* returns 0 if packet done, else 1 */
        pkt.frrt = PAY_READ;
        rrt.payok = atsc_build_payload( &rrt, p, "RRT" );
/* no checking until payload built */
        if (0 != rrt.payok) return;

        rrt.payoff = 0;

        r = rrt.payload;

        terr = 0;

/* RRT table ID CA CA, protocol version 0 */
        if (  (ATSC_RRT != r[0]) || (0x00 != r[8]) ) terr = ~0;

        if (0 != arg_strict) {                          /* strict ATSC check */
                if ( ( 0xF0 != (0xF0 & r[1]) )          /* syntax/priv/rsvd */
                  || ( 0xFF != r[3] )                   /* reserved */
                  || ( 0xC1 != (0xC1 & r[5]) )          /* reserved/cni */
                  || ( 0x00 != r[6] )                   /* must be 0 */
                  || ( 0x00 != r[7] )                   /* must be 0 */
                ) terr = ~0;
        }

/* reserved bits wrong */
        if (0 != terr) {
                atsc_strict_log( r, "RRT BAD TT/RB");
                return;
        }
                                        /* 12 bit section length */
        r++;                            /* r[1] */
        sl = (0xF & *r) << 8;
        r++;                            /* r[2] */
        sl |= *r;

        r++;                            /* r[3]; */
        r++;                            /* r[4]; */
        r++;                            /* r[5] version */
        vn = 0x1F & (*r >> 1);

        rrt_crc = calc_crc32( rrt.payload, sl+3 );

        if (rrt_crc != 0) {
                pkt.crcrrt++;
                advrlog( LOG_INFO, "RRT bad CRC");
                pkt.frrt = PAY_DROP;
                return;
        }

/* because it's not parsed, flag it as good and done */
        pkt.frrt = PAY_GOOD;
        s = &ptc[cap_chan].sig;
        s->psip &= 0x7f;
        s->psip |= 16;
        pkt.rrt++; /* not displaying these counts yet */

        if (vn == rrt.vn) return;

/* build mgt text */
        mi = atsc_find_mg_tt( 0x300 + tn );
        if (-1 < mi) {
                mg[ mi ].vn1 = vn;
                if (sl > mg[ mi ].nb1)
                        mg[ mi ].nb1 = sl;
        }

        rrt.vn = vn;
        return;
}


/**************************************************************** ATSC ETT MSS
 A/65b Table 6.38 Multiple String Structure
 does Huffman decomp
 find pgo index via etmid and adds description to it
 r has source buffer
*/
/* static */
void
atsc_parse_mss_ett ( unsigned char *r, unsigned int n, unsigned int etmid, int pgo )
{
    struct event_s *e;
    unsigned int dstr, dseg, dcomp, dmode, dchr;
    unsigned int i,j;
    char *t;
    char *d;
    char lang[4];

/* e is event, t is description buffer */
    e = &epg[pgo];
    t = e->desc;
    d = t;

    dstr = r[0];
    for (i = 0; i < dstr; i++) {
        memcpy(lang, &r[1], 3);
        lang[3] = 0;
        r += 4;                         /* 3? */
        dseg = *r++;
        for (j = 0; j < dseg; j++) {
            dcomp = *r++;
            dmode = *r++;
            dchr = *r++;

            t[0] = 0; /* need a blank if nothing done */

/* no compression and unicode page 0 */
            if ( (0 == dcomp) && (0 == dmode) && (dchr > 0) ) {
                dchr++;
                if (dchr > PDZ) dchr = PDZ;
/* uncompressed should never be over PDZ bytes */
                astrncpy( t, (char *)r, dchr );
            }

/*
     decompress huffman encoded description text
     no check for mode=0xFF because KPXB is non-compliant at 0.
     but was only source of Huffman compressed EPG in my area.
     the spec says mode=0xFF so KPXB is off-spec.
     can't seem to pull KPXB in anymore. it was always very weak.
*/

/* KPXB requires non-strict mode */
            if ( (0 == arg_strict) || ((0 != arg_strict) && (0xFF == dmode)) )
            {
                if ( (1 == dcomp) || (2 == dcomp) ) {
                    if (dchr > PDZ) dchr = PDZ;
                    huffman_decode( d, r, PDZ-1, dchr, dcomp);
                }
            }

/* it's not huffman, it's compressed with something else */
            if ( (dcomp > 2) || ((dmode > 0) && (dmode < 255)) )
            {
                snprintf( t, 20, "[%s] L%02X C%02X M%02X",
                            lang, dchr, dcomp, dmode);
            }

/* NUL term enforcement */
            t[PDZ-1] = 0;
            e->dmode = dmode;
            e->dchr = dchr;
            e->dcomp = dcomp;
            astrncpy( e->dlang, lang, 4 );
        }
    }

}


/******************************************************************** ATSC ETT
 process ett packet and copy the description to EPG if ETMID found
*/
/* static */
void
atsc_parse_ett ( unsigned char *p, unsigned int n )
{
    struct sig_s *s;
    char t[16];
    unsigned char *r;
    unsigned short sl, etidx, pid, sr;
    unsigned char vn, cni, sn, lsn, pv;
    unsigned int ett_crc = 0;
    unsigned int etmid = 0;
    int sv, mi, pgo, terr;

    if (NULL == ett) return;            /* prevent [l] [p] [enter] crash */
    pkt.ettp++;

    snprintf( t, 7, "ETT-%02X", n);

    vn = cni = sn = lsn = pv = sl = etidx = 0;

    pid = ((0x1F & p[1]) << 8) | p[2];

    pkt.fett = PAY_READ;
    /* returns 0 if packet done, else 1 */
    ett[n].payok = atsc_build_payload( &ett[n], p, t );
    /* no parsing until payload built */
    if (0 != ett[n].payok) return;
    ett[n].payoff = 0;

    /* hold down until an eit seen */
    if (0 == pkt.eit) return;

/* hold down until eit_vn for eit-0 vc 0 is set.
   hmm no. vc could be anything
    if ( 0xFF == eit_vn[0][0] ) return;
*/
    /* keep track of last ETT-n seen */
    if ( (n+1) > ett_idx) ett_idx = n+1;

    r = ett[n].payload;

    terr = 0;
    /* ETT table ID CC, protocol version 0 */
    if ( (ATSC_ETT != r[0]) || (0x00 != r[8]) ) terr = ~0;
    
    if (0 != arg_strict) {                      /* strict ATSC check? */
        if (   ( 0xF0 != (0xF0 & r[1]) )        /* syntax/private/reserved */
            || ( 0x00 != r[3] )                 /* zero extID? not KHOU */
            || ( 0x00 != r[4] )                 /* zero extID? not KHOU */
            || ( 0xC1 != (0xC1 & r[5]) )        /* reserved/cni */
            || ( 0x00 != r[6] )                 /* must be 0 */
            || ( 0x00 != r[7] )                 /* must be 0 */
            )
                terr = ~0;
    }

/* reserved bits wrong */
    if (0 != terr) {
        t[6] = ' ';
        t[7] = 'b';
        t[8] = 'a';
        t[9] = 'd';
        t[10] = 0;

        atsc_strict_log( r, t );
        pkt.crcett++; /* hmm need different error category rbiett */
        return; /* check reserved bits first saves time */
    }

    /* 12 bit section length */
    r++;                                /* r[1] */
    sl = (0xF & *r) << 8;
    r++;                                /* r[2] */
    sl |= *r;

    ett_crc = calc_crc32( ett[n].payload, sl+3 );
    if (ett_crc != 0) {
        pkt.crcett++;
        advrlog( LOG_INFO, "%s bad CRC", t);
        pkt.fett = PAY_DROP;
        return;
    }

    /* ett table id extension */
    etidx = (r[3] << 8) | r[4];         /* should be 0 */
    r++;                                /* r[3] */
    etidx = *r << 8;
    r++;                                /* r[4] */
    etidx |= *r;

/* these show up pretty often on CBS, they seem to be some kind of extra
   identifier for CBS ETT, but not using it, and apparently don't need it.
*/
#if 1
/* two extra branch predictions */
    if (etidx != 0) {
        advrlog( LOG_INFO, "ETT-%02X tid ext %04X not 0", n, etidx);
    }
#endif

    r++;                                /* r[5] */
    vn = 0x1F & (*r >> 1);

    pkt.fett = PAY_PARSE;               /* indicator for parse */

                                        /* stay on r[5] */
    cni = 1 & *r;                       /* current next indicator */
    r++;                                /* r[6] */
    sn = *r;                            /* section number */
    r++;                                /* r[7] */
    lsn = *r;                           /* last section number */

    r++;                                /* r[8] */
    pv = *r;
    if (pv != 0) return;                /* protocol version 0 only */

    /* etmid in 32 bits, top 16 are src */
    r++;                                /* r[9] */
    etmid = *r << 24;
    r++;                                /* r[10] */
    etmid |= *r << 16;
    r++;                                /* r[11] */
    etmid |= *r << 8;
    r++;                                /* r[12] */
    etmid |= *r;

    r++;                                /* r[13] */
                                        /* start of text to extract */

#if 1
/* extra check to save further processing if no VCT or PAT with Source IDs */
    sr = 0xFFFF & (etmid >> 16);
    sv = find_vc_src( sr );
    if (-1 == sv) return; /* hold down until the Source ID is valid */
/* demoth */
   advrlog( LOG_INFO, "ETT-%02X VN %02X ETMID %08X ETIDX %04X",
            n, vn, etmid, etidx);
#endif

/* find ETMID in epg[] array if EIT put it there */
    pgo = find_epg_etmid( etmid );
    if (pgo < 0) return; /* -1 or offset */

/* but even if it doesn't change the payload is counted good */
    pkt.fett = PAY_GOOD;

    s = &ptc[cap_chan].sig;
    s->psip &= 0x7f;
    s->psip |= 8;

/* if version doesn't change, do nothing */
    if (vn == epg[ pgo ].ettvn) return;

/* fix KUHT KRIV KPRC with vn switching between values, bad psip encoder */
    if (0xFF != epg[pgo].ettvn) return;         /* ignore it version set */

    mi = atsc_find_mg_tt( 0x200 + n );
    if (-1 < mi) {
            mg[ mi ].vn1 = vn;
            if (sl > mg[ mi ].nb1)
                    mg[ mi ].nb1 = sl;
    }

/* debug ett vn issues with some stations */
/* you should only see log lines with VN FF */
    advrlog( LOG_INFO, "ETT %02X VN %02X ETMID %08X PGO %04X VN %02X",
                    n, vn, etmid, pgo, epg[pgo].ettvn );

    epg[ pgo ].ettn = n;
    epg[ pgo ].ettvn = vn;
    atsc_parse_mss_ett( r, n, etmid, pgo );
    pkt.ett++;

}

/* bubble sort PEZ entries from epg offset pgo. FOX sends a confused EIT */
/* swapping pointers would be faster. EIT version check limits processing */
/* eit locks prevent race condition with UI thread running build pg epg */
/* static */
void
atsc_sort_eit_epg ( unsigned int pgo )
{
    int i, j, p, pi, pj, v, e, z;
    struct event_s et;
    char s1[32], s2[32];

    z = sizeof(struct event_s);
    p = pgo;
    e = p / PEZ; /* div pgo by 8 to find which EIT lock */
    p = e * PEZ; /* mul result by 8 to find start of 8 entry EIT in epg[] */
    v = e / EIZ; /* div pgo by (8 * 128) to find which VC # */
    v &= 0x07;
    advrlog( LOG_INFO, "%s VC %d EIT-%02X %s", WHO, v, 0x7F & e,
             (0 == epg_locks[e])?"free":"lock" );

/* stopping at epg[].st = 0 is same? not for FOX.  They are non-compliant.   */
/* FOX must practice the GIGO management rule. Garbage rolls downhill to us. */
    for (i=0; i < PEZ; i++) { /* why make standards if FOX won't use them?   */
        if (0 == epg[ p + i ].st) /* set FOX broken blank events to future   */
            epg[ p + i ].st = ~0; /* it really must suck bad to work for FOX */
    } /* FOX is a perfect example of the motto: Quality does not exist here. */
/* What can you expect from FOX? They show 4:3 widescreen with pillarboxes.  */

#define TP1 0
    for (i = 0; i < (PEZ - 1); i++) {
        pi = p + i;
        for (j = i + 1; j < PEZ; j++) {
            pj = p + j;
            text_time( s1, epg[ pi ].st, 0);
            text_time( s2, epg[ pj ].st, 0);
            if ( epg[ pj ].st < epg[ pi ].st) {
                if (p <= TP1) {
                    advrlog( LOG_INFO,
                        "swap pgo[%04X] %s <> pgo[%04X] %s",
                        pi, s1, pj, s2);
                }
                memcpy( &et, &epg[ pi ], z );
                memcpy( &epg[ pi ], &epg[ pj ], z );
                memcpy( &epg[ pj ], &et, z );
            }
        }
        if ( ~0 == epg[ pi ].st ) break; /* end of last loop */
        text_time( s1, epg[ pi ].st, 0 );
        if (p <= TP1) advrlog( LOG_INFO, "sort pgo[%04X] %s", pi, s1 );
    }

    epg_locks[ e ] = 0; /* ok for build pg pgm to use this EIT info */
    advrlog( LOG_INFO, "EPG%02d VC %d EIT-%02X release", cap_chan, v, 0x7F & e);
}

/************************************************************* ATSC EIT RR MSS
 A/65b Table 6.38 Multiple String Structure
 does Huffman decomp
 put EIT content advisory description text in epg[pgo].rating.
 vchip rating is truncated to 15 chars + NUL
*/
/* static */
void
atsc_test_eit_rr_mss ( unsigned char *r, unsigned int pgo )
{
    unsigned int nstr, nseg, comp, mode, nchr;
    unsigned int i,j;
    char lang[4];
    char *t;
    char *d;

    t = epg[pgo].rating;
    d = t;    

    /* get mss number of strings, only using the last one seen */
    nstr = r[0];
    for (i = 0; i < nstr; i++)
    {
        memcpy( lang, &r[1], 3 ); /* copy out language for this string */
        lang[3] = 0; /* and terminate with nul for display */

        r += 4;
        /* get number of segments for this string. not one, not handled */
        nseg = *r;
        r++;
        for (j = 0; j < nseg; j++)
        {
            comp = *r++;
            mode = *r++;
            nchr = *r++;
/* keeps last nul if t cut down to nchr size */
            if (nchr > PRZ) nchr = PRZ;

            t[0] = 0; /* need a blank if nothing done */

/* uncompressed text unicode page 0 */
            if ( (comp == 0) && (mode == 0) && (nchr > 0) ) {
                nchr++;
                astrncpy( t, (char *)r, nchr );
            }       

/* what huffman tree would rating text use? this is short text "TV-14-V-CC" */
/* KPXB requires non-strict mode */
            if ( (0 == arg_strict) || ((0 != arg_strict) && (0xFF == mode)) )
            {
                if ((1 == comp) || (2 == comp)) {
                    huffman_decode( d, r, PRZ, nchr, comp);
                }
            }

/* it's compressed with something else */
            if ( (comp > 2) || ((mode > 0) && (mode < 255)) )
            {
                snprintf( t, PRZ-1, "L%02X C%02X M%02X", nchr, comp, mode);
            }
        }
    }

#define USE_FOX_RR_FIX
#ifdef USE_FOX_RR_FIX
/* UPN KTXH used to do this but they're gone now. faster without it. */
/* convert ';' separator to - like everyone else */
    for (i=0;i<PRZ;i++) {
        if (t[i] == ';') t[i] = '-';
    }
#endif

}

/*************************************************************** ATSC EIT MSS
 A/65b Table 6.38 Multiple String Structure
 does Huffman decomp
 NOTE: this one does need to use multiplex math so find etmid will work
*/
/* static */
void
atsc_parse_mss_eit ( unsigned char *r, unsigned int pgo, unsigned int etmid,
                unsigned int est, unsigned int els )
{
    struct event_s *e;
    unsigned int nstr, nseg, comp, mode, nchr, sr, i, j;
    char *d;
    char *t;
    char lang[4];
    int v;
    time_t st;
    
    e = &epg[pgo];
    t = e->name;
    d = t;
    
    nstr = r[0];
    nchr = 0;

    for (i = 0; i < nstr; i++)
    {
        memcpy(lang, &r[1], 3);
        lang[3] = 0;
        r += 4;
        nseg = *r++;

/* FIXME: No multi-segment. A/65[?] says not used in broadcast.
          This does not handle multiple segments properly.
          It will keep only the last segment. Cable might need?
*/
        for (j = 0; j < nseg; j++)
        {
            comp = *r++;
            mode = *r++;
            nchr = *r++;

            t[0] = 0; /* need a blank if nothing done */

/* no compression, unicode page 0 */
            if ((comp == 0) && (mode == 0) && (nchr > 0) ) {

                nchr++;
/* nchr can't be over PNZ */
                if (nchr > PNZ) nchr = PNZ;
                astrncpy( t, (char *)r, nchr );
            }

/* KPXB requires non-strict mode */
            if ( (0 == arg_strict) || ((0 != arg_strict) && (0xFF == mode)) )
            {
                if ((1 == comp) || (2 == comp)) {
                    if (nchr > PNZ) nchr = PNZ;
                    huffman_decode( d, r, PNZ-1, nchr, comp );
                }
            }

/* fall back to numeric mode compressed with something else */
            if ( (comp > 2) || ((mode>0) && (mode<255)) )
            {
                snprintf( t, PNZ-1, "[%s] L%02X C%02X M%02X",
                            lang, nchr, comp, mode);
            }

/* save truncated event name to reduce processing later */
            event_truncate( e->tname, e->name, 2, sizeof(e->tname) );
            e->tname[16] = 0; /* limit to 16 bytes */
/*
     use only the hours and minutes advertised.
     start time seconds is almost always wrong here.
*/
            est -= (est % 60);

            e->etmid = etmid;   /* event text message id */
            e->st = est;        /* event start time */
            st = (time_t) est;

            localtime_r( &st, &e->stm );

            e->ls = els;        /* event length in seconds */
            e->ncomp = comp;    /* compression type */
            e->nmode = mode;    /* unicode mode */
            e->nchr = nchr;     /* number of bytes */
            e->ettn = 0xFF;     /* waiting for ETT */
            e->ettvn = 0xFF;    /* waiting for ETT */

            astrncpy( e->nlang, lang, 4 ); /* event name language */

/* this WILL bog the capture, even if logging to ram drive */
#if 0
 dvrlog( LOG_INFO, "pgo %04X time %u etmid %08X %s", pgo, est, etmid, s);
#endif
        }

/*
 get source id to find out which VC it belongs to
 so program number can be looked up from there

 VCT check maybe is not needed. if there is no VCT, will not be here?
 or could be here but with PAT+PMT and a broken VCT
 without the source id cross-reference, the EIT can't be assigned
 the correct slot in the EPG and will generate trash entries.
*/

        if ( (0 != vct_ncs) || (0 != pat_ncs) )
        {
            sr = 0xFFFF & ( etmid >> 16 );
            v = find_vc_src( sr ); /* if no vc, returns -1 */
            advrlog( LOG_INFO, "EIT mss ETMID %08X sr %d %d", etmid, sr, v );
            /* get program add needs to set timer name to name.pn */
            if (-1 < v) {
                advrlog( LOG_INFO, "ETMID %08X sr %d v %d pgm %d",
                            etmid, sr, v, vc[v].pn );
                e->pn = vc[ v ].pn;
                e->vc = v;
                e->va = 0; /* first audio only */
            }
        }

/* not needed unless nseg > 1, which is never is, so far
        r += nchr;
*/
    }

#if 1
/* see if event exists in search list. if it does, add to timers */
    search_events( e, &pgm, WHO ); 
/* NO: not here? wastes CPU? looks ok so far */
#endif

}

/************************************************************* ATSC EIT DESC */
/*
 p points to start of EIT descriptor(s)
 do until len exhausted
 there might be some rating text in EIT event to save RRT lookup,
 would like to find the HD descriptor. now that would be useful.
 some stations send AC-3 descriptors per event

*/
/* static */
void
atsc_parse_eit_descriptors ( unsigned char *p, int len, int pgo,
                             int eitn, int evn )
{
    unsigned char *r, *q;
    unsigned char n, l;
    unsigned int i,j, dlen;
    int atcc, z;
    
    atcc = 0;
    dlen = len;

    r = p;
    n = *p;

    epg[pgo].rating[0] = 0;

    while ( dlen > 0 ) {
        n = *r++;
        l = *r++;       
        dlen -= 2;

/* r points to start of descriptor data */
        switch( n ) {

            /* useful? yes, to waste space in program guide */

/* stuffing */
            case 0x80:
                break;

/* MPEG video descriptor. Probably not used in EIT, but could be
    used for MPEG parameters to determine SD or HD or widescreen.
*/
            case 0x02:
                dvrlog( LOG_INFO, "EIT %02X Event %d %s has MPEG desc?",
                        eitn, evn, epg[pgo].name);
                break;

/* A52 audio descriptor. If given, it may help determine if the event
    will have 2.0 or 5.1 audio, can add this info to web EPG?   NO

    One problem is stations that actually send this in the EIT, and also
    have SAP, get two descriptors for the audio for one event. It's not
    clearly laid out in the A/65b spec how to tell which is which, but most
    examples list main audio first. If the station sends the order backwards,
    then trying to select one audio from the EPG will get it backwards, too.
    It could be possible to list the 'main audio' descriptors first.

    What's worse is the station doesn't send the future 2.0/5.1 info. It's
    all the same audio descriptor info that you get from any station cap.

    This makes it junk until bcasters put correct data in EIT event descriptor.
*/
            case 0x81:
                break;

/* Caption service descriptor. This seems to actually work per EIT event. */
            case 0x86:
                if ( 0xC0 == (0xC0 & r[0]) ) { /* reserved bits check */
                    unsigned char nos, cct, l21f, csn, er, war;
                    char lang[4];

                    q = r;
                    nos = 0x1F & q[0];
                    q += 1; /* skip parsed */

                    for (i = 0; i < nos; i++) {
                        if ( 0x40 == (0x40 & q[3]) ) { /* reserved bit */
                            memcpy( lang, q, 3 );
                            lang[3] = 0; /* 3 char lang code per ISO 639.2/B */
                            q += 3; /* skip lang */
                            cct = 1 & (q[0]>>7);
                            atcc = cct;
                            if (1 == cct) {
                                /* see if it's EIA-708-A ATVCC */
                                csn = 0x3F & q[0];
                                /* add CC to description if ATVCC type found */
                                /* atcc = ~0; */
                            } else {
                            /* don't care about EIA/CEA-608-B. that's NTSC */
                                if ( 0x3E == (0x3E & q[0]) ) { /* reserved */
                                    l21f = 1 & q[0];
                                }                               
                            }
                            if ( (0x3F == (0x3F & q[1])) && (0xFF == q[2]) ) {
                                er = 1 & (q[1]>>7);
                                war = 1 & (q[1]>>6);
                                q += 3;
                            }                       
                        }
                    }
                }
                break;

/* content advisory descriptor */
            case 0x87:
                q = r; /* dont want to change r */
                if ( 0xC0 == (0xC0 & q[0]) ) {
                    unsigned char rrc, rr, rd, rdj, rv, rdl;

                    rrc = 0x3F & q[0];
                    q++; /* skip to loop vals */

/* i number of rating regions. should be 1 for US ATSC, but may have more */
                    for (i = 0; i < rrc; i++) {
                        rr = q[0]; /* rating region */
                        rd = q[1]; /* rated dimensions */
                        q += 2;

/* uses built-in RRT table rather than mess with RRT parse right now */
                        for (j = 0; j < rd; j++) {
                            if ( 0xF0 == (0xF0 & q[1]) ) {
                                rdj = q[0]; /* rating dimension j */
                                rv = 0xF & q[1]; /* rating value */
                                q += 2;

/* save to pgm struct from built-in table offsets
                                dvrlog( LOG_INFO, "rdj %02X rv %02X", rdj, rv);
*/
                                snprintf( epg[pgo].rating, PRZ-1, "%s",
                                            ratings[(rdj*10)+rv+1] );
/* truncated event name.png? */
                                epg[pgo].movie = 0;
/* movie[rv].png? */
                                if (7 == rdj) epg[pgo].movie = rv;
                            }
                        }
/* trying also for events with rating text provided, will override above */
                        rdl = q[0]; /* rating descriptor length */
                        q++; /* point to mss for this EIT */
                        if (rdl != 0) {
                        /* add rr text to epg[].rating */
                            atsc_test_eit_rr_mss( q, pgo );
                        }
                    }
                }
                break;

/* they are *supposed* to flag the shows in the EIT too, but
   that doesn't seem to be happening in any streams seen so far.
   station either has flag on all the time or off all the time.
 */
            case 0xAA:
                dvrlog( LOG_INFO, "Ch %02X EIT-%02X has RC", cap_chan, eitn);
                break;

            /* needs parsing if shows up here */
            default:
                break;
        }
        r += l;
        dlen -= l;
    }

/* add CC to rating if caption descriptor found for ATVCC in EIT or PMT */
    if ( (atcc != 0) || (pmt_atcc) ) {

        epg[pgo].rating[ PRZ - 5 ] = 0;
        z = strlen( epg[pgo].rating );

/* append -CC or CC by itself */
        asnprintf( epg[pgo].rating, PRZ, "%sCC", (0 == z) ? "":"-" );
    }
}

/****************************************************************** ATSC EIT */
/*
 process eit[n] packet based on payload start indicator
 n is EIT # from MGT
*/
/* static */
void
atsc_parse_eit ( unsigned char *p, unsigned int n )
{
        struct sig_s *s;
        unsigned char *r;
        unsigned short sl, sr, pid;
        unsigned char sn, lsn, pv, numevs, cni, vn;
        unsigned int eit_crc = 0;
        unsigned int pgo = 0;
        unsigned short eid;                     /* event id */
        unsigned char etmloc;           /* etm location */
        unsigned int els;                       /* length in seconds */
        unsigned char tlen;                     /* title length */
        unsigned int etmid;                     /* match val for text descripton */
        int i, v, mi;
        char t[16];
        int terr;
        time_t est;                             /* event start time */


    if (NULL == eit) return;            /* prevent [l] [p] [enter] crash */
    pkt.eitp++;
    snprintf( t, 7, "EIT-%02X", n);

    pid = ( (0x1F & p[1]) << 8) | p[2];

    pkt.feit = PAY_READ;

    eit[n].payok = atsc_build_payload( &eit[n], p, t);

/* if payok is 0, eit payload is done, so parse it else get next packet */
    if (0 != eit[n].payok) return;

    eit[n].payoff = 0;


    if (0 == vct_ncs) return; /* no vct, no srcid, no etmid, no epg */

/* keep track of last EIT-n seen, so EIT-0 gives eit_idx 1 */
    if ((n+1) > eit_idx) eit_idx = n+1;

    r = eit[n].payload;

    terr = 0;

/* EIT table ID 0xCB, protocol version 0 */
    if ( (ATSC_EIT != r[0]) || (0x00 != r[8]) ) terr = ~0;

    if (0 != arg_strict) {                      /* strict ATSC check? */

        if (   ( 0xF0 != (0xF0 & r[1]) )        /* syntax/private/reserved */

            || ( 0xC1 != (0xC1 & r[5]) )        /* reserved/cni */
/*          || ( 0x01 != (0x01 & r[5]) ) */     /* KTXH was missing bits7:6 */

            || ( 0x00 != r[6] )                 /* must be 0? */
            || ( 0x00 != r[7] )                 /* must be 0? */
            )
                terr = ~0;
    }

/* reserved bits wrong */
    if (0 != terr) {    
        t[6] = ' ';
        t[7] = 'b';
        t[8] = 'a';
        t[9] = 'd';
        t[10] = 0;

        atsc_strict_log( r, t );
        pkt.crceit++;
        return;
    }

/* 12 bit section length */
    r++;                                        /* r[1] */
    sl = (0xF & *r) << 8;
    r++;                                        /* r[2] */
    sl |= *r;

    eit_crc = calc_crc32( eit[n].payload, sl+3);

    if (eit_crc != 0) {
        pkt.crceit++;
        advrlog( LOG_INFO, "%s bad CRC", t );
        pkt.feit = PAY_DROP;
        return;
    }

/* 16 bit source id, used to compute etmid and to check versions */
    r++; /* r[3] */
    sr = *r << 8;
    r++; /* r[4] */
    sr |= *r;

    r++; /* r[5] */
    vn = 0x1F & (*r >> 1);                      /* 5 bit version number */

/* tvct has source info for epg to match, so hold down until have tvct */
    if (0 == pkt.tvct) return;

#if 0
/* is there a need for this other than making it wait longer to start? */
    if ((0 == pkt.eit) && (0 != n)) return;     /* hold down until rx eit 0 */
#endif

    v = find_vc_src( sr );                      /* find vc from src pgm */
    if (-1 == v) {
        dvrlog( LOG_INFO, "%s EIT-%02X can't find vc for src %04X",
                WHO, n, sr);
        return; /* abort if can't find, better luck next time */
    }

/* comment this line for debug to see all the unviewable entries
 skip the EIT if it's NTSC or INACTIVE
*/
    if ( (0 == vc[v].pn) || (0xFFFF == vc[v].pn) ) return;

/*
 NOTE:
 vc.pn shall not be interpreted as pointing to a Program Map Table entry
 instead it should be the lookup into the Program Association Table,
 which will in turn have the index for the Program Map table entry
*/

    if ( (eit_vn[n][v % VCZ] == vn) ) { /* already have this vn? */
        pkt.feit = PAY_GOOD;            /* green is good */
        return;                         /* nothing done, payload same */
    }

    mi = atsc_find_mg_tt( 0x100 + n );
    if (-1 < mi) {
            mg[ mi ].vn1 = vn;
            if (sl > mg[ mi ].nb1)
                    mg[ mi ].nb1 = sl;
    }

    eit_vn[n][v % VCZ] = vn;

    pkt.feit = PAY_PARSE;               /* set indicator to parse */
    pkt.eit++;

    s = &ptc[cap_chan].sig;
    s->psip &= 0x7f;
    s->psip |= 4;

/*
    if ( -1 < cap_vc ) {
        if ( CAP_TIME == cap_now ) return;
        if ( CAP_USER == cap_now ) return;
    }
*/
                                        /* stay on r[5] */
    cni = 1 & *r;                       /* current next indicator */

    /* multiple sections are supported by the spec but not by this code */
    r++;                                /* r[6]; */
    sn = *r;                            /* section number */
    r++;                                /* r[7]; */
    lsn = *r;                           /* last section number */

    r++;                                /* r[8] */
    pv = *r;
    if (pv != 0) return ;               /* protocol version 0 only */

    r++;                                /* r[9] */
    numevs = *r;                        /* number of events in section */

    r++;                                /* r[10] */

/* sanity limit with a log warning, always want to know if this happens */
    if (numevs > PEZ) {
        advrlog( LOG_INFO, "VC %d EIT-%02X has > %d events, %d ignored",
                v, n, PEZ-1, numevs-PEZ );
        numevs = PEZ-1; 
    }

    advrlog( LOG_INFO, "VC %d EIT-%02X has %d events", v, n, numevs );

/* keep the one usually bad event so user can tell it is working.
   want to see the one doppler program that's 720 minutes long if there.
    This: if (numevs > 1) numevs--;
    or this: (i=0; i<(numevs-1); i++)
    causes breakage now, but keep comment here as reminder
*/
    for (i=0; i<numevs; i++)
    {

/* reserved bits. stop the event loop if any not set */
        if ( (0xC0 != (0xC0 & r[0]))                
          || (0xC0 != (0xC0 & r[6]))
           ) break;

                                                /* r[0] */
        eid = (0x3F & *r) << 8;                 /* Event ID */
        r++;                                    /* r[1] */
        eid |= *r;

/* 32 bit A/65b Table 6.14 ETM ID */
        etmid = (sr<<16) | (eid<<2) | 2;        /* ETMID from SR and EID */

/* 32 bit event start time */
        r++;                                    /* r[2] */
        est = *r << 24;
        r++;                                    /* r[3] */
        est |= *r << 16;
        r++;                                    /* r[4] */
        est |= *r << 8;
        r++;                                    /* r[5] */
        est |= *r;

        r++;                                    /* r[6] */
        etmloc = 3 & (*r >> 4);                 /* ETM location */

/* 20 bit event length in seconds, limit to 1024 * 1024 seconds */
        els = (0xF & *r) << 16;                 /* stay on r[6] */
        r++;                                    /* r[7] */
        els |= *r << 8;
        r++;                                    /* r[8] */
        els |= *r;

        r++;                                    /* r[9] */
        tlen = *r;
        
        r++;                                    /* r[10] */

/* recalibrate for unix time */
        est += utc_offset;

        n &= 0x7f;                              /* sanity limit eit-n */

        v = find_vc_src( sr );                  /* sr already set above */

        if (-1 != v) {
            pgo = ( v * EIZ * PEZ ) + ( n * PEZ ) + i; 

/* KPXB fix for source id above 7 sanity limit */
            if (pgo >= PGZ) pgo %= PGZ;

            epg[pgo].eitn = n;          /* used for guide done check */
            epg[pgo].eitvn = vn;        /* used for guide done check */
            epg[pgo].chan = cap_chan;

/* save event name, start time, length and etmid in epg[] structure
   duplicate check so don't have to remove it later
   (KRIV bad EIT event order fix)
*/

/* multi VC stations were not updating in order, look OK now.
   [?] only newest etmids count (ABC/CBS missing EIT-0 fix)
 */
            if (-1 == find_epg_etmid( etmid )) { /* -1 is not found in list */
                atsc_parse_mss_eit( r, pgo, etmid, est, els );
            }
            r += tlen;

/* events have additional descriptors if these reserved bits set */
            if ( 0xF0 == (0xF0 & r[0]) )
            {
                unsigned int dlen;
                dlen = ((0xF & r[0])<<8) | r[1];
                r += 2;

/* V-Chip Rating indices are found in this descriptor */
/* NOTE: Ratings are display-only, but the most obvious
   use would be to save captures in specific directories
   and only allow the kids access to the Y-rated directory.
*/
                
                atsc_parse_eit_descriptors( r, dlen, pgo, n, i );
                r += dlen;
            }
        }
    }

/* FOX needs epg sorted here because FOX is sending broken EITs.
   This has been independently verified with user in New York, so if FOX
   in the largest market is broken, and mine, they are probably all broken.
   ATSC A/65b mentions the EIT events should be chronologically sequential.
*/
    atsc_sort_eit_epg( pgo );

/* uses 1/7 of the calls to epg index if done outside of event loop */
    build_pg_epg( epg, &pgm, pg, WHO);
    pkt.feit = PAY_GOOD;

/* one good eit clears program fail indication */
    pgm.fail = 0;
}

/***************************************************************** ATSC ETM MSS
A/65b Table 6.38 Multiple String Structure
 does Huffman decomp
*/
/* static */
void
atsc_parse_channel_etm_mss ( unsigned char *r )
{
    unsigned int nstr, nseg, comp, mode, nchr;
    unsigned int i,j;
    char lang[4];
    char t[512];
    char *d;

    return; /* no point in wasting cpu cycles on unused data */
    
    d = t;
    
    memset( t, 0, sizeof(t));
    nstr = r[0];
    for (i = 0; i < nstr; i++) {
        memcpy(lang, &r[1], 3);
        lang[3] = 0;
        r += 4;                         /* 3? */
        nseg = *r++;
        for (j = 0; j < nseg; j++) {
            comp = *r++;
            mode = *r++;
            nchr = *r++;

            if ( (0 == comp) && (0 == mode) ) {
                nchr++;
                if (nchr > 256) nchr = 256;
                astrncpy( t, (char *)r, nchr);
            }

/* KPXB requires non-strict mode. not sure that still applies */
            if ( (0 == arg_strict) || ((0 != arg_strict) && (0xFF == mode)) )
            {
                if ((1 == comp) || (2 == comp)) {
                    if (nchr > 511) nchr = 511;
                    huffman_decode( d, r, sizeof(t)-1, nchr, comp);
                }
            }
            if (comp > 2) snprintf( t, sizeof(t)-1, "[%s] L%02X C%02X M%02X",
                                    lang, nchr, comp, mode);

            /* all that work and nothing done with result?!? */
        }
    }
}
/***************************************************************** ATSC PTC ETT
 This is the Extended Text Table for the Physical Transmission Channel.
 It is checked for Quality of Service via CRC32 but mss is not parsed.
 The information located in the mss has nothing useful to the capture.
*/
/* static */
void
atsc_parse_channel_ett ( unsigned char *p )
{
    unsigned char *r;
    unsigned int sl, idx, vn, etmid, pid;
    int terr, mi;

    ctt.payok = atsc_build_payload( &ctt, p, "PTCETT");
    if (0 != ctt.payok) return;
    ctt.payoff = 0;

    r = ctt.payload;

    terr = 0;

    pid = 0x1FFF & ( (p[1] << 8) | p[2] );

    /* all must be valid or nothing done */
    if ( 
         ( 0xF0 != (0xF0 & r[1]) )
      || ( 0xC1 != (0xC1 & r[5]) )
      || ( 0x00 != r[8] )
       )
            terr = ~0;

/* reserved bits wrong */
    if (0 != terr) {
        atsc_strict_log( r, "PTCETT bad");
        return;
    }

    sl = ((0xF & r[1]) << 8) | r[2];                    /* 12bit section len */

    ctt.crc = calc_crc32( r, sl+3 );
    if (ctt.crc != 0) {
        pkt.crcett++;                                   /* should count this */
        advrlog( LOG_INFO, "PTCETT bad CRC");
        return;                                         /* crc for QoS only */
    }

/* the rest is for build mgt text */
    idx = (r[3] << 8) | r[4]; /* TESTME: what is this index? */
    vn = (0x3E & r[5]) >> 1;                            /* version */
    etmid = r[9]<<24 | r[10]<<16 | r[11]<<8 | r[12];    /* ETMID unused */

/* build mgt text */
    mi = atsc_find_mg_tt( 4 );
    if (-1 < mi) {
            mg[ mi ].vn1 = vn;
            if (sl > mg[ mi ].nb1)
                    mg[ mi ].nb1 = sl;
    }

/* rest is unused because some stations put really long useless text in */
    r += 13;
    atsc_parse_channel_etm_mss( r );                    /* nop */
}


/************************************************************** ATSC VCT SLD 
A/65b Table 6.26 Service Location Descriptor for n'th VCT
*/
/* static */
void
atsc_parse_vct_svloc ( unsigned char *r, unsigned int n )
{
    unsigned short pcrpid;              /* program clock reference pid */
    unsigned short numes;               /* number of elementary streams */
    unsigned short espid;               /* elementary stream pid */
    unsigned char est;                  /* stream type */
    char eslang[4];             /* stream language */
    unsigned char i, j;
    unsigned char *p;
    int acn;

    acn = 0;    

    if (0xE0 != (0xE0 & r[0])) return;  /* reserved bits */
    pcrpid = ((0x1F & r[0]) << 8) | r[1];
    numes = r[2];

    if (numes > 7 ) return; /* 8 VC limit */
    vc[n].vctes = numes;
    vc[n].pcrpid = pcrpid;

    /* MPEG2 limited to 0-FFF, assume PMT is 0 anchor for PCR PID range */
    vc[n].pmtpid = 0x0FF0 & pcrpid;

    r += 3;
    p = r; /* save for video and audio type loops */
    j = 0; /* starting with first ES */

/* do video type loop first to correct any vct / pmt mismatch */
/* KTRK has a bad habit of sending the VCT ES info backwards from PMT ES */
    for (i=0; i<numes; i++) {

        if (0xE0 == (0xE0 & p[1])) {    /* reserved bits */
            est = *p++;                 /* ES type */
            espid = ((0x1F & p[0])<<8) | p[1];
            p += 2;
            memcpy( eslang, p, 3);
            eslang[3] = 0;
            p += 3;

            if (est != 2) continue;     /* not video? keep going */
            vc[n].estype[j] = est;
            vc[n].espid[j] = espid;
            memcpy( &vc[n].eslang[j][0], eslang, sizeof(eslang));
            j++;
        }
    }                                   
/* should be only one video per vc, so don't need vc[].vcn */    

    for (i=0; i<numes; i++) {

        if (0xE0 == (0xE0 & r[1])) { /* reserved bits */
            memset(eslang, 0, sizeof(eslang) );
            est = *r++;                 /* ES type */
            espid = ((0x1F & r[0])<<8) | r[1];
            r += 2;
            memcpy( eslang, r, 3);
            eslang[3] = 0;
            r += 3;
            if (0x81 != est) continue; /* skip video done above */
            acn++;
            vc[n].estype[j] = est;
            vc[n].espid[j] = espid;
            memcpy( &vc[n].eslang[j][0], eslang, sizeof(eslang));
            j++;    
        }
    }                                   
    vc[n].acn = acn; /* number of audio channels in this vc */

/* everything not video and not audio gets listed last */
    for (i=0; i<numes; i++) {

        if (0xE0 == (0xE0 & r[1])) { /* reserved bits */
            memset(eslang, 0, sizeof(eslang) );
            est = *r++;                 /* ES type */
            espid = ((0x1F & r[0])<<8) | r[1];
            r += 2;
            memcpy( eslang, r, 3);
            eslang[3] = 0;
            r += 3;
            /* skip video and audio done above */
            if ( (0x02 == est) || (0x81 == est)) continue;
            vc[n].estype[j] = est;
            vc[n].espid[j] = espid;
            memcpy( &vc[n].eslang[j][0], eslang, sizeof(eslang));
            j++;    
        }
    }                                   
}

#if 0
/****************************************************************** ATSC ECN
A/65b Table 6.38 Multiple String Structure
 does Huffman decomp
  Does nothing but waste cycles. Extended Channel name is not displayed.
  All that work and nothing done with result.
*/
/* static */
void
atsc_parse_mss_vct ( unsigned char *r )
{
    unsigned int nstr, nseg, comp, mode, nchr;
    unsigned int i,j; 
    char lang[4];
    char t[512];

/*    return; */ /* see build vct text for where this is parsed */

    memset( t, 0, sizeof(t) );
    nstr = r[0];
    for (i = 0; i < nstr; i++) {
        memcpy(lang, &r[1], 3);
        lang[3] = 0;
        r += 4;
        nseg = *r++;
        for (j = 0; j < nseg; j++ ) {
            comp = *r++;
            mode = *r++;
            nchr = *r++;

            t[0] = 0;

            if ( (0 == comp) && (0 == mode) && (nchr > 0) ) {
                nchr++;
                if (nchr > 256) nchr = 256;
                astrncpy( t, r, nchr );
            }

/* KPXB requires non-strict mode */
            if ( (0 == arg_strict) || ((0 != arg_strict) && (0xFF == mode)) )
            {
                if ((comp == 1) || (comp == 2)) {
                    if (nchr > sizeof(t) ) nchr = sizeof(t);
                    huffman_decode( t, r, sizeof(t)-1, nchr, comp);
                }
            }

            if ( (comp > 2) || ((mode > 0) && (mode < 0xFF)) )
                snprintf( t, sizeof(t)-1, "[%s] L%02X C%02X M%02X", 
                            lang, nchr, comp, mode );
        }
    }
}
#endif

/********************************************************** ATSC VCT DESCRIPTOR
 r points to start of descriptors. vct may have: ecn sl tss
 do until len exhausted
 n is VC[n] for svloc, rest are text dont care about

 Time shifted service descriptor is currently unused for broadcast.
 Service location descriptor has superset of PAT+PMT info with VC PIDs.
*/
/* static */
void
atsc_parse_vct_descriptor ( unsigned char *r, unsigned int n, unsigned int len )
{
    unsigned char dtag, dlen;
    
    dtag = dlen = 0;
        
    while ( len > 0 ) {
        dtag = *r++;
        dlen = *r++;    
        len -= 2;
        switch( dtag ) {

/* Extended Channel Name descriptor is multiple string structure */
            case 0xA0:
/*              atsc_parse_mss_vct( r ); // no useful information, is nop */
                break;

/* service location descriptor, equivalent to MPEG PMT with ES PIDs */
            case 0xA1:
                atsc_parse_vct_svloc( r, n );
                break;

/* time shifted service descriptor, log if seen but still ignores it */
            case 0xA2:
                dvrlog( LOG_INFO, "TSSD ignored");
                break;

/* ignore anything else. see table of where descriptors are allowed */
            default:
                break;
        }
        r += dlen;
        len -= dlen;
    }
}

/******************************************************************** ATSC VCT
 * Cable and Terrestrial Virtual Channel Tables. tt is table type.
 * This table gives information on which PIDs are for which Virtual Channel.
 * 400ms is maximum (longest delay allowed) cycle time, according to A/65b.
 * Cable has 2 bits following hidden bit in virtual channel loop.
 *   Path select is for telling it which tuner to use in 2-tuner cable STB.
 *   Out-of-band may indicate TSID isn't on the PTC where CVCT was found.
 * Terrestrial reserves these bits (set 1). Do not use as extra markers?
 */
/* static */
void
atsc_parse_vct ( unsigned char *p, int tn )
{
    struct sig_s *s;
    unsigned char *r, *t;
    unsigned short sl, tsi0, adl, pid;
      signed short sr; /*  -1 is NTSC, 0 is HIDDEN */
    unsigned char vn, cni, sn, lsn, pv;
    int c, i, j, mi;
    int terr;
    int has_name = 0;

    short tsx;
    struct tsid_s *tsn;

    c = 0;

    if (ATSC_CVCT == tn) {
        c = 2;
        t = "CVCT";
        pkt.cvctp++;
    } else {
        c = 0;
        t = "TVCT";
        pkt.tvctp++;
    }

    i = 0;

#ifdef USE_MPEG_ONLY
#warning using MPEG ONLY --- NO ATSC PSIP
    return; /* no ATSC guide with this */
#endif

    pid = 0x1FFF & ((p[1] << 8) | p[2]);

    pkt.fvct = PAY_READ;
    vct.payok = atsc_build_payload( &vct, p, t );
    if (0 != vct.payok) return;
    vct.payoff = 0;

    r = vct.payload;

    terr = 0;

    if (ATSC_TVCT == tn) {
    /* TVCT table ID C8, protocol version 0 */
        if ( (ATSC_TVCT != r[0]) || (0x00 != r[8]) ) terr = ~0;
    } else {
    /* TVCT table ID C8, protocol version 0 */
        if ( (ATSC_CVCT != r[0]) || (0x00 != r[8]) ) terr = ~0;
    }

/* cable disables this by setting r[1] to 0xC0 */
    if (0xF0 != (0xF0 & r[1])) terr = ~0; /* syntax,private,reserved */

    if (0 != arg_strict) {                      /* strict ATSC check */
        if (   ( 0xC1 != (0xC1 & r[5]) )        /* reserved/cni */
            || ( 0x00 != r[6] )                 /* CSN should be 0 */
            || ( 0x00 != r[7] )                 /* LSN should be 0 */
            )
                terr = ~0;
    }

/* reserved bits wrong */
    if (0 != terr) {
        advrlog( LOG_INFO, "%s:%d %s reserved bits not set", WHO, __LINE__, t);
        atsc_strict_log( r, t );
        pkt.crctvct++;
        return;                 /* check reserved bits saves time */
    }

    r++;                                /* r[1] */
    sl = (0xF & *r) << 8;
    r++;                                /* r[2] */
    sl |= *r;                           /* section length may not be > 1021 */

    if (sl > 1021) return;              /* if it is > 1021, ignore packet */

    vct_crc = calc_crc32( vct.payload, sl+3 );  /* crc check to qualify */
    if (vct_crc != 0) {
        pkt.crctvct++;
                                        /* TEI should have caught? */
        advrlog( LOG_INFO, "%s bad CRC", t);
        pkt.fvct = PAY_DROP;
        return;                         /* bad packet do not process */
    }

    r++;                                /* r[3] */
    tsi0 = *r << 8;                     /* transport stream id */
    r++;                                /* r[4] */
    tsi0 |= *r;

    r++;                                /* r[5] */
    vn  = 0x1F & (*r >> 1);             /* version number limits processing */

    vct.lv = vct.vn;
    if (vn == vct.vn) {                 /* version hasn't changed */
        pkt.fvct = PAY_GOOD;

/*      pkt.tvct++; */ /* only count new ones */
        return;
    }

/* set a bit to indicate channel has VCT */
    s = &ptc[ cap_chan ].sig;
    s->psip &= 0x7f;
    s->psip |= 2;

    mi = atsc_find_mg_tt( c );
    if (-1 < mi) {
        mg[ mi ].vn1 = vn;
        mg[ mi ].nb1 = sl;
    }

    advrlog( LOG_INFO, "%s new %s VN %02X", WHO, t, vn);

    vct.vn = vn;                        /* version has changed */
    pkt.fvct = PAY_PARSE;
    pkt.tvct++;                         /* indicate parse and bump count */

                                        /* keep er steady r[5] */
    cni = 1 & *r & 1;                   /* current/next indicator */
    r++;                                /* r[6] */
    sn  = *r;                           /* section number */
    r++;                                /* r[7] */
    lsn = *r;                           /* last section number */
    r++;                                /* r[8] */
    pv  = *r;                           /* protocol version */
    if (pv != 0) return;                /* only supporting protocol 0 */

    r++;                                /* r[9] */
    vct_ncs = *r;                       /* number of channels in section */

    if (vct_ncs > VCZ) {
        vct_ncs = VCZ;  /* 7 is enough? not for cable or sat */
        dvrlog( LOG_INFO, "%s limits %s to %d entries", WHO, t, VCZ);
    }

//    vc_ncs = vct_ncs;                 /* is also max vc[] index */

    if (vct_ncs >= pat_ncs) {
        vc_ncs = vct_ncs;
    } else {
        vc_ncs = pat_ncs;
    }


/* NOTE: vc[] build from VCT overrides anything PAT+PMT made before,
        and then PAT+PMT has to reference what VCT made, if it can.
        If it can't, the extra PMTs are added to vc[] after VCT ones.
*/

    r++;

    for (j = 0; j < vct_ncs; j++)
    {
        char *n;
        unsigned char mode;
        unsigned int freq;
        unsigned short major, minor, pgn, tsi1;

/* all these reserved bits have to be set or nothing done */
        if  ( (0xF0 != (0xF0 & r[14] )) /* after short name */
//            || (0x0D != (0x0D & r[26] )) /* +12 bytes after name */
              || (0xC0 != (0xC0 & r[27] )) /* +13 bytes after name */
                ) {
            dvrlog( LOG_INFO, "%s:%d %s reserved bits not set",
                        WHO, __LINE__, t);
            return;
        }
                
/* pmt may have to check for non-zero instead of here */
        n = vc[j].name;

/* 7 shorts of UTF-16 big endian, but only want bottom 8 bits */
        *n++ = r[1];
        *n++ = r[3];
        *n++ = r[5];
        *n++ = r[7];
        *n++ = r[9];
        *n++ = r[11];
        *n++ = r[13];
        *n = 0;
        n = vc[j].name;

        has_name = 0;
        if (' ' == *n) *n = 0;
        if (0 != *n) has_name = 1;

/* global channel name is chopped down copy of first VC name */
/* ignore bud paxons 'i' first channel and look for K or W callsign */
        if ( (0 == j)
          && (0 != has_name)
          && (0 == (0x20 & n[1]))   /* 2nd char uppercase? */
          && ( ('K' == *n) || ('W' == *n) ) ) {

        
/* first VC name will be chan name, but may be wrong if 2+ stations on PTC */
                memcpy( chan_name, n, 8);


#if USE_CALLSIGN_TRUNC
/* term the station name at first non alphanumeric */
                int k;
                for (k=0; k< 7; k++) {
                    if (0 == isalnum(chan_name[k]))
                        chan_name[k]=0; 
                }
#endif

        }

#if USE_AUTO_CALLSIGN
/* might be 3 char call signs, maybe */
        if (strlen(chan_name)>2) {

/* handle the station getting a new call sign:
    (KHWB to KHCW) or user forgetting to enter it
*/
                astrncpy( s->call, chan_name, 8 );
                s->call[7] = 0;
                has_name = ~0;
        }
#endif
        advrlog( LOG_INFO, "VCT vc[%d].name %s", j, vc[j].name);

/* skip past virtual channel name */
        r += 14;                        /* r[0] */

/* HAVE to keep these fields local until program number known */

        major = (0xF & *r) << 6;
        r++;                            /* r[1] */
        major |= 0x3F & (*r >>2);       /* major channel number 10 bits */
        s->major = major;               /* update station list */

        minor = (3 & *r) << 8;
        r++;                            /* r[2] */
        minor |= *r;                    /* minor channel number 10 bits */
        
        r++;                            /* r[3]; */
        mode = *r;                      /* modulation mode 8 bits */
        
        r++;                            /* r[4] */
        freq = *r << 24;
        r++;                            /* r[5] */
        freq |= *r << 16;
        r++;                            /* r[6] */
        freq |= *r << 8;
        r++;                            /* r[7] */
        freq |= *r;                     /* frequency 32 bits (obsoleted) */
        
        r++;                            /* r[8] */
        tsi1 = *r << 8;
        r++;                            /* r[9] */
        tsi1 |= *r;                     /* transport stream ID 16 bits */
//      if (cap_pn > 0)
            cap_tsid = tsi1;

        r++;                            /* r[10] */
        pgn = *r << 8;
        r++;                            /* r[11] */
        pgn |= *r;                      /* program number 16 bits*/

#ifdef USE_AUTO_TSID
/* no hidden, NTSC or even TSID numbers */
        if ( (0 != pgn) && (0xFFFF != pgn) && (1 == (tsi1 & 1)) ) {
            tsx = find_tsidx( tsi1, pgn, WHO );
            if ( (tsx < 0) && (0 == arg_scan) ) {
                tsn = &tsids[tsidx];
                tsn->tsid = tsi1;
                tsn->ptc = s->ptc;
                tsn->pn = pgn;
                if (0 != has_name) {
                    snprintf( tsn->call, 8, "%s", n);
                } else {
                    snprintf( tsn->call, 8, "TS-%04X", tsi1 );
                }
                snprintf( tsn->sid, 8, "%03d", s->ptc); 
                tsidx++;    
            }
        }
#endif

#ifdef USE_VC_PA_MISMATCH
/* if PAT already loaded, have to store in PAT index order */
/* if VCT is first, will sort by pgn at end */
        if (0 != pkt.pat) {
            i = find_vc_pgm( pgn, WHO);
            if (-1 == i) {
                dvrlog( LOG_INFO, "VCT/PAT Program mismatch %s", WHO);
                return;  /* nothing left to do if it's too broken */
            }
        }
#endif

/* force vct to set the order for vc[]. parse pat/pmt will have to adjust */
        i = j;

        vc[i].major = major;
        vc[i].minor = minor;
        vc[i].mode = mode;
        vc[i].freq = freq;              /* obsoleted */
        vc[i].tsid = tsi1;
        vc[i].pn = pgn;

        r++;                            /* r[12] */
        vc[i].etm = 3 & (*r >> 6);      /* extended text message location/ 0 */

                                        /* stay on r[12] */
        vc[i].actrl = 1 & (*r >> 5);    /* access control */
        vc[i].hide = 1 & (*r >> 4);     /* hide channel */

        vc[i].psel = 0;
        vc[i].oob = 0;

/* FIXME: build vc text will not show this yet, but may not have CVCT's? */
        if (ATSC_CVCT == tn) {
            vc[i].psel = 1 & (*r >> 3);
            vc[i].oob =  1 & (*r >> 2);
        }

        vc[i].hideg = 1 & (*r >> 1);    /* hide guide for this channel */

        r++;                            /* r[13] */
        vc[i].svct = 0x3F & *r;         /* service type */

        r++;                            /* r[14] */
        sr = *r << 8;                   /* KPXB has large killer source id */
        r++;                            /* r[15] */
        sr |= *r;

        vc[i].src = sr;

        r++;                            /* r[16] */
        vc[i].vcdlen = (3 & *r) << 8;
        r++;                            /* r[17] */
        vc[i].vcdlen |= *r;             /* descriptor length */

        r++;                            /* r[18] */

        /* parse descriptor for a/v */
        if (0 != vc[ i ].vcdlen) {
            /* make copy for display */
            memcpy( vc[i].vcdescr, r, vc[i].vcdlen);
            atsc_parse_vct_descriptor( r, i, vc[i].vcdlen);
            /* skip to next descriptor */
            r += vc[i].vcdlen;
        }
    }

/* NOTE: not seeing this in local streams.
    Look for additional descriptors, but spec says may be 0.
*/
    if (0xFC == (r[0] & 0xFC)) {

        adl = ((0x3 & r[0]) << 8) | r[1];

/* never seen in my local streams? */
        if (0 != adl) {
#if 0
            char t[80];
            *t = 0;
/* not doing anything with add'l descriptors, shouldn't bother */
            for ( j = 0; j < adl; j++) {
                asnprintf( t, 80, " %02X", *r);
                r++;
            }
            dvrlog( LOG_INFO, "Add'l hex:%s", t);
#endif
            dvrlog( LOG_INFO, "TVCT add'l descriptor exists\n");
        }
    }

    for (i=0; i < vct_ncs; i++) {
        j = find_pa_pgm( vc[i].pn, WHO );
        advrlog( LOG_INFO, "vc %2d vct.vn %02X pn %d pa %d",
                i, vct.vn, vc[i].pn, j );
    }
    vct.lv = vct.vn;

/* NOTE: VC capture now starts at first PAT. may be smoother? */
    pkt.fvct = PAY_GOOD;
}

/***************************************************************** ATSC MGT */
/* Master Guide Table
 * This table gives information on which PIDs are for which Table Types,
 * as well as the expected Table version and number of bytes in Table.
 * Tables can be one of the following: TVCT CVCT EIT ETT RRT PTC_ETT.
 * s->mgt_hrs is computed from number of EITs listed * 3 hrs
 *
 * NOTE: DCCT and DCCSCT are not currently used. Directed Channel Change
 *       is a feature that is not being used by any ATSC broadcasters.
 *
 * NOTE: The "number of bytes in Table" field is not always being encoded
 *       correctly by all broadcasters. It is display only and not used for
 *       any allocation of table space. The incorrect values are displayed
 *       in red by the show master guide function.
 */
/* static */
void
atsc_parse_mgt ( unsigned char *p )
{
        struct sig_s *s;
        unsigned char *r;
        unsigned short sl, tidx, td, dl, i, j, pid;
        unsigned char vn, cni, sn, lsn, pv;
        int eitnum;
        int terr;
        struct mg_s *m1, *m2;

        pkt.mgtp++;
        pid = ((0x1F & p[1])<<8) | p[2];

        pkt.fmgt = PAY_READ;
        mgt.payok = atsc_build_payload( &mgt, p, "MGT" );
        if (0 != mgt.payok) return;
        mgt.payoff = 0;

        r = mgt.payload;

        terr = 0;

/* MGT table ID C7, protocol version 0 */
        if ( (ATSC_MGT != r[0]) || (0x00 != r[8]) ) terr = ~0;

/* cable disables this by using 0xC0 instead of 0xF0 */
        if (0xF0 != (0xF0 & r[1])) terr = ~0;   /* syntax,private,reserved */

/* strict ATSC check? */
        if (0 != arg_strict) {
            if (   ( 0x00 != r[3] )             /* must be 0 */
                || ( 0x00 != r[4] )             /* must be 0 */
                || ( 0xC1 != (0xC1 & r[5]) )    /* reserved/cni */
                || ( 0x00 != r[6] )             /* must be 0 */
                || ( 0x00 != r[7] )             /* must be 0 */
                )
                    terr = ~0;
        }

/* reserved bits wrong */
        if (0 != terr) {
                atsc_strict_log( r, "MGT bad" );
                pkt.crcmgt++;
                return; /* check reserved bits saves time */
        }

/* 12 bit section length */
        r++;                            /* r[1] */
        sl = (0xF & *r) << 8;           
        r++;                            /* r[2] */
        sl |= *r;                       /* bytes after section header */

        if (sl > 4093) return;          /* payload limit */

        mgt.crc = mgt_crc = calc_crc32( mgt.payload, sl+3 );

/* TEI should have caught? */
        if (mgt_crc != 0) {
            pkt.crcmgt++;
            advrlog( LOG_INFO, "MGT bad CRC");
            pkt.fmgt = PAY_DROP;
            return;
        }

        r++;                            /* r[3] */
        tidx = *r << 8;
        r++;                            /* r[4] */
        tidx |= *r;                     /* table id extension / 0 */
    
        r++;                            /* r[5] */
        vn = 0x1F & (*r >> 1);          /* 5 bit version number */

/* vn is also in mgt.vn, but that's for payload build. ui wants mgt_vn */

        if (mgt_vn == vn) {                     /* already have this vn? */
                pkt.fmgt = PAY_GOOD;            /* green is good */
/*              pkt.mgt++;                      *//* count it as good */
            return;                             /* nothing done, payload same */
        }
        mgt_vn = vn;

/* refresh the mgt in case user is in mgt display */
        refresh.mgt = 1;

        s = &ptc[ cap_chan ].sig;
        s->psip &= 0x7f;
        s->psip |= 1;                           /* bit 0 is mgt flag */

        s->mgt_hrs = 0;
        
/* build payload is only thing that sets mgt.vn.  Use mgt_vn for UI
    to isolate the spurious version changes to mgt.vn
*/

#ifdef USE_CRAZY_MGT_HOLD
/* KHCW fix: too many MGT version changes preventing guide from building */
//    if (utsmgt > utsnow) return;      /* hold down same as guide timeout */
/* What happens if you don't init the mgt here? it is done elsewhere... */
//    init_mg();
/* What happens if you don't clear the guide? EIT clear is enough? */
//    init_pgm();                               /* clear program guide */
/* KHCW Fix: three minute hold down for next MGT until info cap done */
//    utsmgt = utsnow + 180;            
#endif

/* Show KHCW breakage. User should know that the station is goofy. */
/*      init_mg();                      */ /* clear master guide structs */

        reset_mg();
        reset_atsc();                   /* init atsc allocs, reset clears */
        init_pgm();                     /* clear program guide */

        pkt.fmgt = PAY_PARSE;
        pkt.mgt++;
                                        /* stay on r[5] */
        cni = 1 & *r;                   /* current/next indicator */

        r++;                            /* r[6] */
        sn = *r;                        /* 8 bit section number */

        r++;                            /* r[7] */
        lsn = *r;                               /* 8 bit last section number */

        r++;                            /* r[8] */
        pv = *r;                                /* 8 bit protocol version */
        if (pv != 0) return;            /* should always be zero */

        r++;                            /* r[9] */
        td = *r << 8;                   /* 16 bit tables defined */
        r++;                            /* r[10] */
        td |= *r;
    
        r++;

        mg_idx = 0;
        mg_eit = 0;
        eitnum = 0;

        for (i=0; i<td; i++)
        {
                unsigned short tt;
                unsigned short ttpid;
                unsigned char ttvn;
                unsigned short ttdl;
                unsigned int nb;

                if ( ( 0xE0 != (0xE0 & r[2]))
                  || ( 0xE0 != (0xE0 & r[4]))
                  || ( 0xF0 != (0xF0 & r[9]))
                  ) return;

                tt = *r << 8;
                r++;                            /* r[1] */
                tt |= *r;                       /* table type */
        
                r++;                            /* r[2] */
                ttpid = (0x1F & *r) << 8;
                r++;                            /* r[3] */
                ttpid |= *r;                    /* table type PID */
        
                r++;                            /* r[4] */
                ttvn = 0x1F & *r;               /* table type version number */
        
                r++;                            /* r[5] */
                nb = *r << 24;
                r++;                            /* r[6] */
                nb |= *r << 16;
                r++;                            /* r[7] */
                nb |= *r << 8;
                r++;                            /* r[8] */
                nb |= *r;                       /* number of bytes in table */
        
                r++;                            /* r[9] */
                ttdl = (0xF & *r) << 8;
                r++;                            /* r[10] */
                ttdl |= *r;                     /* table type descriptor length */
        
                r++;                            /* r[11] */
                r += ttdl;                      /* FIXME: skip past tt descriptor */
                                        /* ADDME: registration descriptor parse */
/* descriptors are not present in my local MGTs, see A/65b page 27
 mg is raw received order
*/
                j = mg_idx;
                mg_idx++;

                m1 = &mg[j];
                m2 = &mgp[ttpid];

                m1->tt = tt;
                m1->pid = ttpid;
                m1->dl = ttdl;
                m1->vn = ttvn;
                m1->nb = nb;
                m1->vn1 = 0xFF;
                m1->nb1 = 0;

/* mgp is mg cross-reference by PID for parsing and build mgt text,
   but is not useful for table types below 6 because all on same PID 1FFB
*/
                m2->tt = tt;
                m2->pid = ttpid;
#if 0
                m2->vn = ttvn;
                m2->nb = nb;
                m2->vn1 = 0xFF;
                m2->nb1 = 0;
#endif

/* mgs is sorted by table type from entry 0-n, done in build mgt text
   set if eit found in mgt
   will add them as they occur in test mg ttpid packet
 */
/* set a flag to indicate some events may exist. */
                if ( (tt >= 0x100) && (tt <= 0x17F) ) {
                    mg_eit = ~0;
                    eitnum++;
                }
/* otherwise it triggers an EIT missing error in build mgt text */
        }

        s->mgt_hrs = 3 * eitnum;

/* FIXME: missing MGT registration descriptor parse, see A/65b page 27
    13818-1 page 59 section 2.6.9 too. have't ever seen it non-zero. */
/* more reserved bit validate */

        if (0xF0 == (0xF0 & r[0])) {
/* A65/b says only one additional descriptor here, so no for loop */
                dl = ((0xF & r[0])<<8) | r[1];
                mgt_dl = dl;
/* one descriptor starts immediately following length */
                r += 2;

/* not parsing mgt descriptors */
/* test_mpeg2_registration_descriptor( r, dl ); */
                r += dl;
        }

        pkt.fmgt = PAY_GOOD;
}

/* test for MGT table by PIDs to get table type, but not 1FFB ATSC System */
/* static */
int
atsc_test_mg_ttpid ( unsigned char *p, unsigned int pid )
{
        unsigned char *r;
        unsigned int tt, ttidx;
        unsigned char tei;
        tei = 1 & (p[1]>>7);
        tt = 0;
/*
 sanity limit pid, if in mg pid copy, set the index same as pid
 inlined method of above using lookup table method that is faster
 this is to reduce processing on (anticipated) larger program guides
*/  
        ttidx = -1;
        if ( pid == mgp[ 0x1FFF & pid ].pid ) ttidx = pid;
        if (ttidx == -1) return ~0;
        tt = mgp[ 0x1FFF & pid ].tt;    /* get table type */

        r = p+5;

#if 0
/* see A/65b Table 6.3 Table Types: all of these are on PID 1FFB */

/* Terrestrial Virtual Channel Table C1 */
        if (tt == 0) return 0;

/* Terrestrial Virtual Channel Table C0 */
        if (tt == 1) return 0;

/* Cable Virtual Channel Table C1 */
        if (tt == 2) return 0;

/* Cable Virtual Channel Table C0 */
        if (tt == 3) return 0;

/* Directed Channel Change Selection Code Table */
        if (tt == 5) return 0;
#endif

/* Channel Extended Text Table isn't usually on PID 1FFB but it can be */
        if (tt == 4) {
                atsc_parse_channel_ett( p );
                return 0;
        }

/* Event Information Table */
        if ( (tt >= 0x100) && (tt <= 0x17F) ) {
                atsc_parse_eit( p, 0x7F & tt );
                return 0;
        }

/* Extended Text Table */
        if ( (tt >= 0x200) && (tt <= 0x27F) ) {
                atsc_parse_ett( p, 0x7F & tt );
                return 0;
        }

/* Rating Region Table, a.k.a. V-Chips n Gub'ment Cheese */
        if ( (tt >= 0x300) && (tt <= 0x3FF) ) {
                atsc_test_rrt( p, 0xFF & tt );
                return 0;
        }

/* Directed Channel Change Table */
        if ( (tt >= 0x1400) && (tt <= 0x14FF) ) {
                atsc_test_dcct( p );
                return 0;
        }

        return ~0;
}
/***************************************************************** ATSC MGT */



/***************************************************************** ATSC STT
System Time Table Parse
  This would obviate need for ntpd, IF your local stations are accurate.
  Time is used for display in bottom right. It is not used for anything
  else unless config file Z-line specifies channel[:delta] to sync with.
  CRC32 is done for QoS. Use config file Z line non zero to try it.
*/
/* static */
void
atsc_parse_stt ( unsigned char *p )
{
        unsigned char *r;
        unsigned short sl = 0;
        unsigned char guo = 0;
        unsigned short ds = 0;
        struct timeval stt_sys;
    
        int diff = 0; /* should be time_t */
        int avgdiff; /* should be time_t, will break in 2008 maybe */
        int terr;

        avgdiff = terr = 0;

        pkt.fstt = PAY_READ;
        stt.payok = atsc_build_payload( &stt, p, "STT");
        if (0 != stt.payok) return;
        stt.payoff = 0;
    
        r = stt.payload;

        /* STT table ID CD and protocol version 0 */
        if ( (ATSC_STT != r[0]) || (0x00 != r[8]) ) terr = ~0;

        if (0 != arg_strict) {

            if ( (0xF0 != (r[1] & 0xF0))        /* syntax,private,reserved  = 1 */
                || (0x00 != r[3])               /* table_id_extension msB   = 0 */
                || (0x00 != r[4])               /* table_id_extension lsB   = 0 */
                || (0xC1 != (r[5] & 0xC1))      /* reserved,current_next=1  = 0 */
                || (0x00 != r[6])               /* section number           = 0 */
                || (0x00 != r[7])               /* last section number      = 0 */
                )
                    terr = ~0;
        }

/* reserved bits wrong */
        if (0 != terr) {
                atsc_strict_log( r, "STT bad");
                return; /* reserved bits check saves time */
        }

        sl = ((0xF & r[1]) <<8) | r[2]; /* 12 bit section length */
        stt.crc = calc_crc32( r, sl + 3 );
        if (stt.crc != 0) {
                pkt.crcstt++;
                advrlog( LOG_INFO, "STT bad CRC");
                return;
        }

/* version always 0 */
        pkt.fstt = PAY_GOOD;                    /* status indicator */
        pkt.stt++;

/* atsc system time value, not unix time */
        atsc_stt = (r[9]<<24) | (r[10]<<16) | (r[11]<<8) | r[12];

        astt.st = atsc_stt;
        astt.guo = r[13];                       /* GPS UTC offset */
        ds = (r[14]<<8) | r[15];                /* daylight_savings() */
        astt.ds = ds;                           /* A/65b Annex A */

/* NOTE: Don't depend on DST bits. Not all stations set the bits correctly. */
        if (0x60 == (0x60 & r[14])) {
                astt.dss = 1 & (ds>>15);        /* 1 is daylight savings on */
                astt.dsd = 0x1F & (ds>>8);      /* nz day of month DST flips */
                astt.dsh = 0x1F & ds;           /* nz hour of day DST flips */
/* NOTE: dsd and dsh only use 5 bits each */
        }

/* GPS UTC offset correction, +- any time Bureau of Standards says so */
        atsc_stt -= guo;
/* adjust for difference between ATSC and unix epoch */
        atsc_stt += utc_offset;

/* time delta for station delay */
        if (cap_zc == ptc[cap_chan].sig.ptc) atsc_stt -= cap_zd;
        localtime_r( &atsc_stt, &atsc_stt_tm );

/* this is where the config file Z line is used */
/* adjust for known clock drift from this station */
/* fill stt_tm structure with corrected time */
/* CAPTUREME: DST changeover in realtime, 2 chances a year */

/* various hold downs for config Z-line */
        if (0 == cap_zc) return;                /* config is Z0 ? */
        if (cap_zto > utsnow) return;           /* timeout not reached? */
        if (cap_zc != ptc[cap_chan].sig.ptc) return; /* Zchan not PTC? */
        if (atsc_stt < utc_check) return;       /* time is invalid? */
        if (CAP_INFO != cap_now) return;        /* not info cap? */
        if (0 != test_mode) return;             /* test mode? */

/* 30 min max update rate, use reload config [_] key to reset it NOW,
    If you want to know what the drift is, within the 3hr meridian hit [_].

    NTP would be a better solution to be used on volume wakeup code.
    If the ATSC times were actually good enough they could be used for
    samples to NTP external clock souce plugin, but not good enough yet.
*/
        cap_zto = utsnow + 1800;

        advrlog( LOG_INFO, "chan %d zc %d stt %d check %d zto %d",
                cap_chan, cap_zc, (int)atsc_stt, utc_check, cap_zto);

/*  NOTE: this only works if you have this C ptc line GTO value set with
    same ptc on Z ptc line. or else it won't look at the stream for STT.
*/

/* cause of bumpiness if used? will be changed real soon anyway */
/*      get_time(); */

/* Z config line correction offset. Use - so user can match polarity. */
        diff = utsnow - atsc_stt;
/* config is opposite polarity of what observed drift is */

/* Ahead or behind by more than 1s triggers system clock set.
    NOTE: KHCW jumps ahead 6 hours every so often. Ignore changes over 2hrs.
    This means it won't set the clock if you're too far out.
*/
        if (diff < 1) return;
        if (diff > SEC3HR) return;
        
        stt_sys.tv_sec = atsc_stt;
        stt_sys.tv_usec = 0;

/* NOTE: settimeofday requires root, just like SCHED_FIFO  */

/* only root user guide capture is allowed to set the time */
        if (0 == euid) {
                settimeofday( &stt_sys, NULL );

/* update utsnow and tloc */
                get_time();

/* log this so we can see that it's working */
                dvrlog( LOG_INFO, "STT%02d %d utsnow %d diff %d",
                        cap_chan, (int)atsc_stt, utsnow, (int)diff);
        }
}
/****************************************************************** STT */


/****************************************************************** ATSC */
/* static */
void
atsc_test_table ( unsigned char *p )
{
    unsigned int psi;
    
    pkt.atsc++;

    psi = 1 & (p[1]>>6);

/* PSI 1 means it's the start of the payload */
    if (psi != 0)
    {
        pkt.atsctid = p[5]; /* save table id of payload start */
        switch( pkt.atsctid ) {

/* System Time Table */
            case ATSC_STT:
                atsc_parse_stt( p );
            break;

/* Master Guide Table */
            case ATSC_MGT:
                atsc_parse_mgt( p );
                break;

/* Terrestrial Virtual Channel Table */
            case ATSC_TVCT:
                atsc_parse_vct( p, ATSC_TVCT );
                break;

/* Cable Virtual Channel Table */
/* only difference from TVCT is path_select and out-of-band bits for CVCT */
            case ATSC_CVCT:
                atsc_parse_vct( p, ATSC_CVCT );
                break;

/* Rating Region Table: count these and use for QoS */
            case ATSC_RRT:
                atsc_test_rrt( p, 1 );
                break;

/* Directed Channel Change Table: unused and uncounted */
            case 0xD3:
                atsc_test_dcct( p );
                break;

/* Directed Channel Change Selection Code Table: unused and uncounted */
            case 0xD4:
                atsc_test_dccsct( p );
                break;

            default:
                break;
        }
        return;
    }

/* PSI 0 indicates more payload, see what last pkt.tid needed payload.
   This works because payloads are sent from start to finish before the
   PID changes. Drop out causes CRC32 errors that are caught by parser.
*/
    if (psi == 0)
    {
        switch( pkt.atsctid ) {
/*
 mgt is likely overflow suspect now, as stt/vct handled as single section.
 rrt might be further candidate, but rating tricks are for kids. blah.
 NOTE: A/65b mentions it can support multiple tables in one payload
 but so far not seeing that. maybe need to look closer?
*/
            /* should be one packet STT only but just in case */
            case ATSC_STT:
                atsc_parse_stt( p );
            break;

            case ATSC_MGT:
                atsc_parse_mgt( p );
                break;

/* KPXB has multi-packet VCT */
            case ATSC_TVCT:
                atsc_parse_vct( p, ATSC_TVCT );
                break;

/* cable virtual channel table */
            case ATSC_CVCT:
                atsc_parse_vct( p, ATSC_CVCT );
                break;

/* counted for QoS, using built-in RRT */
            case ATSC_RRT:
                atsc_test_rrt( p, 1 );
                break;

/* directed channel change table */
            case 0xD3:
                atsc_test_dcct( p );
                break;

/* directed channel change selection code table */
            case 0xD4:
                atsc_test_dccsct( p );
                break;

            default:
                break;
        }
    }
    return;
}
/****************************************************************** ATSC */



/****************************************************************** MPEG2
MPEG2 payload related, usefulness yet to be determined for capture.
 AFC 2 is afc only, no payload data following
 AFC 3 is afc, then payload afterwards
 These are interleaved throughout the video and audio stream for timing.

 NOTE: ATSC packets should not see these, as there is no need for timing.
       All of this is Too Much Information For This Application
*/
/* static */
void
atsc_parse_adaptation_field ( unsigned char *p )
{
/* NOTE: These flags not used here. They are skipped during capture parse. */
#if 0

    unsigned char *r;
    unsigned char afl, di, rai, espi, pcr, opcr, sp, tpd;
    unsigned char afx = 0;
    unsigned long long pcrb, opcrb, pwr, dtsnau;
    unsigned short pcrx, opcrx;
    char sc;                            /* splice countdown is signed */
    unsigned char tpdl;
    unsigned char afxl, ltw, pwrf, ssf, ltwv, ltwo, st;

    unsigned char ph, pm, ps;           /* pcr h m s */
    unsigned int pr, pw;                /* pcr remainder, pcr wall time */
    
    pcrb = opcrb = pwr = dtsnau = pcrx = opcrx = 0;

    ph = pm = ps = pr = pw = 0;

    /* adaptation field starts immediately after continuity counter */
    r = p + 4;

    afl = *r++;

    if (afl == 0) return; /* nothing to do */

    di   = 1 & (*r>>7); /* discontinuity if set */
    rai  = 1 & (*r>>6); /* random access if set */
    espi = 1 & (*r>>5); /* elementary stream priority if set */

    pcr  = 1 & (*r>>4); /* has program clock reference */
    opcr = 1 & (*r>>3); /* has old program clock reference */
    sp   = 1 & (*r>>2); /* has splicing point */
    tpd  = 1 & (*r>>1); /* has transport private data */
    afx  = 1 & (*r);    /* has adaptation field extension (decoder time stamps) */

    fprintf( stdout, " FLAGS %02X", *r);
    if (0 != di)   fprintf( stdout, " DI");

/* PCR is the only flag seen in ATSC. Decoders use it, capture does not. */
    if (0 != rai)  fprintf( stdout, " RAI");
    if (0 != espi) fprintf( stdout, " ESPI");
    if (0 != pcr)  fprintf( stdout, " PCR");
    if (0 != opcr) fprintf( stdout, " OPCR");
    if (0 != sp)   fprintf( stdout, " SP");
    if (0 != tpd)  fprintf( stdout, " TPD");
    if (0 != afx)  fprintf( stdout, " AFX");

/* parsing some but not keeping anything but pcr and opcr
     r steps forward with each section done, in spec order
*/
    r++;

/* program clock reference, main mpeg system clock */
    if (0 != pcr) {
        if (0x7E == (0x7E & r[4])) { /* bad reserved should abort? */
                                /* 33 bit PCR */
            pcrb  = (*r++)<<25; /* bits 32 . 31 30 29 28 . 27 26 25 */
            pcrb |= (*r++)<<17; /* bits 24 . 23 22 21 20 . 19 18 17 */
            pcrb |= (*r++)<<9;  /* bits 16 . 15 14 13 12 . 11 10  9 */
            pcrb |= (*r++)<<1;  /* bits  8 .  7  6  5  4    3  2  1 */ 
            pcrb |= 1 & (*r>>7); /* bit  0 */

            /* 9 bit PCR extension */
            pcrx  = (1 & *r++) << 8; /* bit 9 */
            pcrx |= 0xFF & *r++;
        }
    }

    /* original program clock reference, from previous multiplex or source? */
    if (0 != opcr) {
        if (0x7E == (0x7E & r[4])) { /* bad reserved should abort? */
                                 /* 33 bit Original PCR */
            opcrb  = (*r++)<<25; /* bits 32 . 31 30 29 28 . 27 26 25 */
            opcrb |= (*r++)<<17; /* bits 24 . 23 22 21 20 . 19 18 17 */
            opcrb |= (*r++)<<9;  /* bits 16 . 15 14 13 12 . 11 10  9 */
            opcrb |= (*r++)<<1;  /* bits  8 .  7  6  5  4    3  2  1 */ 
            opcrb |= 1 & (*r>>7); /* bit  0 */

            /* 9 bit Original PCR extension */
            opcrx  = (1 & *r++) << 8; /* bit 9 */
            opcrx |= 0xFF & *r++;
        }
    }

    /* splicing point */
    if (0 != sp) {
        sc = *r++; /* 8 bit signed */
    }
    /* transport private data, skips and does not keep private data bytes */
    if (0 != tpd) {
        int i, pdb;
        tpdl = *r++;
        for (i = 0; i < tpdl; i++) pdb = *r++;
    }
    /* adaptation field extension */
    if (0 != afx) {
        afxl = *r++;
        if ( 0x1F == (0x1F & *r) ) {            /* reserved */
            ltw  = 1 & (*r >> 7);               /* ltw flag */
            pwrf = 1 & (*r >> 6);               /* piecewise rate flag */
            ssf  = 1 & (*r >> 5);               /* seamless splice flag */
            r++;

            if (0 != ltw) {
                ltwv  = 1 & (*r >> 7);          /* 1 bit ltw valid */
                ltwo  = (0x7F & *r++) << 8;     /* 15 bit ltw offset */
                ltwo |= 0xFF & *r++;
            }
            if (0 != pwrf) {
                if (0xC0 == (0xC0 & *r)) {      /* reserved */
                    pwr  = 0x3F & *r++;         /* 22 bit piecewise rate */
                    pwr |= (*r++) << 16;
                    pwr |= (*r++) << 8;
                    pwr |= *r++;

                }
            }

            /* seamless splice, DTS next access unit */
            if (0 != ssf) {
                if  (  (1 == (1 & r[0])) /* marker bits */
                    || (1 == (1 & r[2]))
                    || (1 == (1 & r[4]))
                    )
                {
                    /* splice type */
                    st = 0xF & (*r>>4); /* blech spec mess */

                    /* dts next access unit */
                    /* 32 31 30 */
                    dtsnau  = (7 & (*r++ >> 1 )) << 30;

                    /* 29 28 27 26 . 25 24 23 22 */
                    dtsnau |= *r++ << 22;

                    /* 21 20 19 18 . 17 16 15 14 */
                    dtsnau |= (0x7F & (*r++ >> 1)) << 14;

                    /* 13 12 11 10 .  9  8  7  6 */
                    dtsnau |= *r++ << 6;

                    /*  5  4  3  2 .  1  0 */
                    dtsnau |= 0x3F & (*r++ >> 1);
                }
            }   
        }
    }

    if (pcrb != 0) {
        pr = pcrb % 90000;
        pw = pcrb / 90000;
    
        ps = pw % 60;
        pm = (pw / 60 % 60);
        ph = (pw / 3600 % 24);

        fprintf( stdout, "\n  PCR %02d:%02d:%02d.%05d ext %3d",
                ph, pm, ps, pr, pcrx );
    }

    if (opcrb != 0) {
        pr = opcrb % 90000;
        pw = opcrb / 90000;
    
        ps = pw % 60;
        pm = (pw / 60 % 60);
        ph = (pw / 3600 % 24);

        fprintf( stdout, "\n  OPCR %02d:%02d:%02d.%05d ext %3d",
                ph, pm, ps, pr, opcrx);
    }

    if (dtsnau != 0) {
        pr = dtsnau % 90000;
        pw = dtsnau / 90000;
    
        ps = pw % 60;
        pm = (pw / 60 % 60);
        ph = (pw / 3600 % 24);

        fprintf( stdout, "\n  DTS NAU %02d:%02d:%02d.%05d",
                ph, pm, ps, pr );
    }   

/* rest are supposed to be reserved
     must be rest of payload if afc=3
     or nothing if afc=2
     getting kind of odd looking numbers to be length field at p[4+afl]?
*/

#endif

}
/***************************************************************** MPEG2 */



/****************************************************** TOP LEVEL TRANSPORT
 check transport packet for errors and route packet to function
*/
/* static */
void
atsc_test_packet ( unsigned char *p )
{
    unsigned int tei, psi, pri, cc, tsc, afc, vn;
    unsigned short pid;
    /* minimal transport header bits */

    pkt.keep = 0; /* default is packet not validated */

    /* each packet validated by each section which sets ~0 if applicable,
     unless cap pgm -1 is selected in which case you get everything
    */
//    if (-1 == cap_vc) pkt.keep = ~0;
    if (-1 == cap_pn) pkt.keep = ~0;

    pkt.count++;

    tei = 1 & (p[1] >> 7);              /* transport error indicator */
    pkt.psi = psi = 1 & (p[1] >> 6);    /* payload start indicator */
    pri = 1 & (p[1] >> 5);              /* priority (unused?) */
    pid = 0x1FFF & ( (p[1] << 8) | p[2] ); /* part of p1 and p2 are PID */
    tsc = 3 & (p[3]>>6);                /* MPEG2: p3 transport scramble control */
    pkt.afc = afc = 3 & (p[3]>>4);      /* MPEG2: p3 adaptation field control */
    cc = 15 & p[3];                     /* ANY:   p3 continuity counter */
    vn = 0x1F & (p[10]>>1);             /* version p10 for help with cc */

    psi_pids[ pid ] += psi;

    if (pri != 0) pkt.tsprit++;
    
/* transport error indicator is counted as error */
    if (tei != 0) {
        pkt.teiert++;
        return;
    }

/* transport scramble control non zero is counted as error */
    if (tsc != 0) {
/* single vc cap only counts scramble if it matches Vid or Aud PID */
        if (cap_pn > 0) {
            if ((pid == cap_pids[2]) || (pid == cap_pids[3]))
                pkt.tscert++;
        } else {
/* full cap counts all the scrambled packets */
            pkt.tscert++;
        }
/* don't try to parse this packet */
        return;

    }

/* no reserved adaptation field control */
    if (afc == 0) return;

/* if it's NULL packet, nothing more to do */
    if (pid == 0x1FFF) {
        pkt.null++;

/* -n option: hardware players need nulls */
        if (0 != arg_nulls) pkt.keep = ~0;

/* VC cap PID filter converts non matches to nulls, too */
        return;
    }

//    if (0 != psi) advrlog( LOG_INFO, "%s PS1 PID %04X", WHO, pid);

/* clear adaptation field length */
    pkt.afl = 0;

/* adaptation field only, no payload */
    if (afc == 2) {
        pkt.afl = p[4];
        if (0 != pkt.afl) {
            atsc_parse_adaptation_field( p );
        }
    }

/* MPEG2 uses but only in PES packets, not for PAT CAT or PMT
   ATSC PSIP does not use afc=3 nor afc=2
*/
    if (afc == 3) {
        pkt.afl = p[4];
        if (0 != pkt.afl) {
            int paylen = 0;
            paylen = p[4+pkt.afl];
/*
            fprintf( stdout, "\n PID %04X PSI %d AFC 3 AFL %02X PL %02X",
                        pid, psi, pkt.afl, paylen );
*/
            atsc_parse_adaptation_field( p );
        }
    }

/* NOTE: No duplicate packets seen in ATSC that match 13818-1 criteria..
    MPEG2 spec said this about continuity counters:
    Continuity counter does not increment on duplicate MPEG2 packet
    but PCR and ext are expected to be correct for the new packet.

    TODO[?]:    Continuity counter allowed to be discontinuous when
                adaptation field control discontinuity indicator is set.
                This condition has not yet been observed in ATSC.

    AFC                 Continuity Counter

    0   reserved        does not increment
    1   payload only    increments
    2   afc only        does not increment
    3   afc & payload   increments

    See ISO/IEC 13818-1: Tables 2-3 and 2-6.
*/

    
/* first time around is always wrong, so don't count it */
    if (0xFF != last_cc[pid]) {

/* afc only: cc should be same as last cc for this pid */
        if (afc == 2) {
            if (cc != last_cc[pid]) {

/* cc error total: full cap counts all cc errors */
                if (cap_pn < 1) {
                    pkt.tsccet++;
                } else {

/* single vc cap increments cc errtot if pid is member of cap pids */
                    if (0 == find_cap_pid(pid))
                        pkt.tsccet++;
                }               
                cce_pids[ pid ]++;
            }
        } else {

/* afc+payload or payload only: cc should be 1 + last (modulo 16) */
            if ( cc != ( 0xF & (1 + last_cc[ pid ]) ) ) {

/* cc error total: full cap counts all cc errors */
                if (cap_pn < 1) {
                    pkt.tsccet++;
                } else {

/* single vc cap increments cc err tot if pid is member of cap pids */
                    if (0 == find_cap_pid(pid))
                        pkt.tsccet++;
                }               
                cce_pids[ pid ]++;
            }
        }
    }

/* for next time around */
    last_cc[pid] = cc;

    pids[pid]++;        /* tracking pids for dump cap stats */

/*
 cable uses PIDs like 0x0880 for MPEG2, so make MPEG2 range end at 0x1000
 finally found limit in mpeg spec: 12 [13?] bits, so 0xFFF is last mpeg2 PID
 some cable streams seem to have mpeg2 above 0x1000, hmm
*/
//#define MPEG2_TS_PID_LIMIT 0x1000

/* is MGX? ATSC System transport, always PID 1FFB and AFC = 01b & SCR = 00b */
    if ( (pid == 0x1FFB) && (afc == 1) ) {
        atsc_test_table( p );
        return;
    }

/* is MGX? see if PID is on MGT list and handle it if match found */
    if (0 == atsc_test_mg_ttpid( p, pid ))
        return;

/* FIXME: range too narrow for cable to work properly
    MPEG2 transport, PAT CAT PMT and PES only
 */


/* if it's full cap, test it always, otherwise program cap
    will test for matching pids in cap_pids, which will
    have been set by eventual PAT + PMT or VCT load.

    can't use cap_now because it will trigger while fifo has data
*/
#if REMOVEME_TEST_MPEG2
    if (cap_pn < 1) {
        atsc_test_mpeg2( p, pid );
    } else {
        if (0 == find_cap_pid( pid ))
            atsc_test_mpeg2( p, pid );
    }
#endif

    atsc_test_mpeg2( p, pid );

    return;
}

/* called in place of test packet to total stats immediately following */
/* static */
void
atsc_test_packet_stats ( unsigned char *p )
{
    atsc_test_packet( p ); /* set the flags, then total them */
    /* transport errors */
    pkt.tserrt = pkt.synert + pkt.teiert + pkt.tscert + pkt.tsccet;
    /* atsc errors */
    pkt.crcats = pkt.crcett + pkt.crceit + pkt.crcmgt
               + pkt.crctvct + pkt.crccvct + pkt.crcstt + pkt.crcrrt;
    /* mpeg2 errors */
    pkt.crcmp2 = pkt.crcpat + pkt.crccat + pkt.crcpmt;
    /* sum of all errors */
    pkt.errors = pkt.tserrt + pkt.crcats + pkt.crcmp2;

    /*
     have to call it to update log during user input,
     but don't call get time excessively (may be too high for SD VC)
    */
    if ( 0 == (pkt.count % 1120)) get_time(); /* cap log needs */
    /* utsel defaults to utsets, utsets always seconds since cap start */
    utsets = utsnow - utscap;

    /* only done if clock changes */
    if (utspte != utsets) {
        pkt.esec = pkt.errors - pkt.perr; /* errors in past second */
        pkt.perr = pkt.errors;  /* save current error count for next time */
        utspte = utsets;

        if (pkt.esec < 30) {
            sec_good++; /*  error count less than frame rate may be watchable */
        } else {
            sec_bad++; /* 30 or more errors per second is unwatchable */
        }
/* update cap stat array with per second error count */
/* cable should be around 26000 packets per second */
        if (pkt.esec > 65535) pkt.esec = 65535;

        if (utsets < CAP_STZ) cap_stats[ utsets ] = 0xFFFF & pkt.esec;

/* moved to fifo input loop? check and DELETEME
 *    if fifo was more full than last max, keep new max full
        if (fill_max2 < fill_max) fill_max2 = fill_max;
 */
    }

/* done elsewhere? check and DELETEME
 * if not raw cap, hold down until both PAT and PMT arrive
    if ( (-1 < cap_vc) && (0 == pkt.pat) && (0 == pkt.pmt) ) pkt.keep = 0;
 */
}


/* points to buf of TSBUFZ bytes in length
 test sync block might be more descriptive
*/
/* static */
void
atsc_test_sync_block ( unsigned char *p )
{
        int i, j;

        pkt.syncb = pkt.align = pkt.skips = pkt.synerr = 0;

        /* step thru to find SYNC bytes, inner loop checks last packet */
        for ( i = 0; i < (TSBUFZ - TSPZ); )
        {
            /* sync here and sync ahead? */
            if ( (TSYNC == p[i]) && (TSYNC == p[i+TSPZ]) )
            {
                /* two syncs were found, count them */
                pkt.syncb++;
                pkt.syncb++;

/*
 no test here, goal is find alignment of last packet in block
                test_packet( &p[i] );
 already know p[i] and p[i+188] are sync bytes
*/
                j = i+TSPZ;
            
                /* inner loop checks from outer loop offset to last packet */
                for ( ; j <= (TSBUFZ-TSPZ); )
                {
                    /* made it to last aligned packet? WOW. */
                    if ( j == (TSBUFZ-TSPZ) ) {
                        /* sync_count++; */
                        /* no. counted on next block */
                        break; /* get out so you dont exceed boundary */
                    }

                    /* sync ahead? should be somewhere if align not 0 */
                    if ( (TSYNC == p[j+TSPZ]) )
                    {
                        /* test_packet( &p[j] ); */
                        pkt.syncb++; /* sync was found, count it */
                        j += TSPZ; /* try for next packet */
                        continue;
                    } else {
                        pkt.synerr++;
                        /* back to outer loop to look for sync bytes */
                        break;
                    }
                }       

                /* stop outer loop if inner loop finished block */
                if (j >= (TSBUFZ-TSPZ) ) break;

                /* outer loop continues where sync was expected */
                i = j+TSPZ;
                /* falls through to continue with outer loop */

            } else {
                /* no sync here or no sync ahead, retrain bytewise */
                pkt.skips++; /* count the bytes skipped */
                i++; /* try next byte */
            }
        }

        /* align is how many bytes were skipped before sync found */
        pkt.align = i;
        pkt.align %= 188; /* only need 0-187 */
        
        
        /* it's possible to get here w/o error or sync, error is 21 if so */
        if (pkt.syncb == 0) pkt.synerr = TSPPB;

        /* only do sync totals during cap, not at end of cap during flush */
        if (cap_now > 0) {
            pkt.synert += pkt.synerr; /* total of sync errors found */
            pkt.synct  += pkt.syncb; /* total of sync bytes found in block */
            pkt.alignt += (pkt.align!=0)?1:0; /* bump align total if out */
        }
}
/************************************************************************ TS */



/* try to establish transport stream packet sync and stream alignment */
/* rewritten for 1.0-rc4. looks better. seems more robust, too.
    flow:
        read 21 packets
         find first sync byte and keep track of offset for alignment
            find next sync bytes til end of 21 packets
            if first sync byte was aligned to offset 0
              and found sync in right place on 21 packets
                consider sync good and stream aligned, so get out
            otherwise
                read non-zero offset number of bytes in to align stream
        loop back to read 21 packets until tries exceeds count
*/
/* static */
void
atsc_get_sync ( int count )
{
        int len, tries, errs, aligns, skips, syncs;
    
/* clear locals */
        len = tries = errs = aligns = skips = syncs = 0; 

#if 0
/* simulate tupari reported bug. turns out it needs time to fill the fifo */
        while(1) nanosleep( &console_read_sleep, NULL );
#endif

/* dummy mode doesn't need sync check */
        if (test_mode != 0) {
                pkt.syncb = 21;
                return;
        }

        while ( tries < count )
        {


                len = read( in_file, ts_buf, TSBUFZ );

/* NOTE: this should not show up unless read did not block properly */
                if (len != TSBUFZ) {
                        dvrlog( LOG_INFO, "get sync: read %d, not %d",
                                len, TSBUFZ);
                        return;
                }

                pkt.count = 0; /* use this for error checking below */
                atsc_test_sync_block( ts_buf ); /* 21 packet sync check */

/* demoth
                advrlog( LOG_INFO, "test sync: sc %d sa %d se %d sk %d",
                    sync_count, sync_align, sync_error, sync_skips);
*/
                if (pkt.align == 0) aligns++; /* count 0 alignments */
                tries++;
                errs  += pkt.synerr;
                skips += pkt.skips;
                syncs += pkt.syncb;
        
/* consider sync good at first 0 alignment that has 0 errors
 if ( (sync_align == 0) && (sync_error == 0) ) break;
  no, try for all 21 syncs
        
 now here's where it gets fun: try to fix the alignment.
 sync align is how much it was off last test sync
 align only if 21 syncs and no errors and 0 > align < 188

 if 21 sync bytes found in block, no errors and needs alignment
*/
                if ( (pkt.syncb == 21 ) && (pkt.synerr == 0)
                  && (pkt.align > 0) && (pkt.align < TSPZ) )
                {       
                    advrlog( LOG_INFO, "SYN%2d: block %d: align %d",
                             cap_chan, tries, pkt.align);
                    len = read( in_file, ts_buf, pkt.align );
                    if ( len != pkt.align ) {
                        dvrlog( LOG_INFO,
                                "SYN%2d: block %d: align read %d, not %d",
                                cap_chan, tries, len, pkt.align);
                    break;
                }
            }
        }

/* logging eats time, especially on bogged cpu, -l is option */
    
        advrlog( LOG_INFO, "SYN%2d: align %s: %d/%d sc %d se %d sk %d", cap_chan,
                (pkt.align == 0)?"OK":"FAIL", aligns, tries,
                syncs, errs, skips);

/* don't let get sync screw up total sync err count for rest of cap */
        pkt.synert = 0;

/* demoth
        advrlog( LOG_INFO, "SYN%2d: sc %d sa %d se %d sk %d",
                 cap_chan, sync_count, sync_align, sync_error, sync_skips);
        console_exit(0);
*/
}

#if 1
/* FIXME: doesn't flush last block, but bogs less than 188 byte writes */
/* It may be OK by now, but need to test to be sure.
 write a packet to out_buf until 21 packets, then write cut_buf
 NOTE: CUT_buf not OUT_buf. Bad choice of name and hard to read difference.
*/
/* static */
void
write_pkt_block ( unsigned char *p )
{
        int ok;
        char e[256];
/* buffer is either empty from above flush, or not full yet */
        pkt.kept++; /* and count the packet */
        memcpy( &cut_buf[block_widx], p, TSPZ);
        block_widx += TSPZ;
        block_widx %= TSBUFZ;
        outbc += TSPZ;

    /* is buffer full? if so, write it out */
        if (0 == block_widx ) {
        /* program guide info cap does not write */
            if (out_file > 2) {
                ok = write( out_file, cut_buf, TSBUFZ);
                if (ok != TSBUFZ) {
                        if (-1 == ok) {
                                strerror_r( errno, e, sizeof(e) );
                        } else {
                                snprintf( e, sizeof(e), "volume full" );
                        }
                        dvrlog( LOG_INFO, "%s stops capture '%s'", WHO, e );
                        pid_i = 0;
                        pid_o = 0;
                        cap_fail = FAIL_NOSPC;
                        cap_now = CAP_NONE;
                        return;
                }
            }
        }
}
#endif

/* static */
void
stream_on( void )
{
        int ir;
        ir = -1;

        /* DVB turn streaming on, mandatory for DVB */
        if ( (0 == test_mode) && (0 == arg_dummy) ) {
                ir = ioctl( dmx_file, DMX_START, NULL );
                if (0 == ir) {
                        advrlog( LOG_INFO, "DMX START\n" );
                } else {
                        if (0 == test_mode)
                                dvrlog( LOG_INFO, "DMX START fail %d\n", ir );
                }
        }

/* wait for fifo to get about 330k. tupari reported bug in usb nano driver */
    nanosleep( &signal_loop_sleep, NULL );
}

/* static */
void
stream_off( void )
{
        int ir;
        ir = -1;

        /* DVB stream off, mandatory for DVB */
        if ( (0 == test_mode) && (0 == arg_dummy) ) {
                ir = ioctl( dmx_file, DMX_STOP, NULL );
                if (0 == ir) {
                        advrlog( LOG_INFO, "DMX STOP");
                } else {
                        dvrlog( LOG_INFO, "DMX STOP fail %d", ir);
                }
        }
}

/* @begin fifo.c */
/********************************************************************** FIFO
* my code to flesh out ingos fifo, critical sections inside mutex locks
* these all give warning: cast discards qualifiers from pointer target type:
*       using fifo->mutex as pointer to fifo->mtx to address that
*/
/* static */
void
fifo_atomic_init ( struct fifo_s *fifo )
{
/* LinuxThreads default attribute is "fast" but is it fast enough? */
        pthread_mutex_init( &fifo->mutex, NULL );
        fifo->filled = 0;
}

/* read the current fifo byte count. mutex wait if it's being modified */
/* static */
size_t
fifo_atomic_read ( struct fifo_s *fifo )
{
#define USE_FIFO_MUTEX_READ
#ifdef USE_FIFO_MUTEX_READ
#warning using FIFO mutex reads
/* hmmm, maybe should have no lock. need read ASAP for FIFO drain? */
        size_t count;
        pthread_mutex_lock( &fifo->mutex );
        count = fifo->filled;
        pthread_mutex_unlock( &fifo->mutex );
        return count;
#else
        return fifo->filled;
#endif
}

/* lock fifo and decrement the fifo byte count */
/* static */
void
fifo_atomic_sub ( struct fifo_s *fifo, size_t count )
{
/* while trylock sleep method */
        while
            ( EBUSY == pthread_mutex_trylock( &fifo->mutex ) )
        {
/*          pthread_yield(); */
            nanosleep( &atomic_sleep, NULL );
        }

        fifo->filled -= count;
        pthread_mutex_unlock( &fifo->mutex );
}

/* lock fifo and increment the fifo byte count */
/* static */
void
fifo_atomic_add ( struct fifo_s *fifo, size_t count )
{
        /* while trylock sleep method */
        while
            ( EBUSY == pthread_mutex_trylock( &fifo->mutex ) )
        {
/*          pthread_yield(); */
            nanosleep( &atomic_sleep, NULL );
        }

        fifo->filled += count;
        pthread_mutex_unlock( &fifo->mutex );
}

/* This resets the actual FIFO pointers */
/* Atomic init above resets pthread mutex/lock and FIFO byte count */
/* static */
void
fifo_reset ( struct fifo_s *fifo )
{
        if (NULL == fifo) {
                dvrlog( LOG_INFO, "FIFO structure not allocated?");
                return;
        }

        if (NULL == fifo->buffer) {
                dvrlog( LOG_INFO, "FIFO init didn't allocate buffer?");
                return;
        }

/* Initialize FIFO mutex and structure with start/end pointers */
        fifo_atomic_init( fifo );
        fifo->max_bytes = fifoz;
        fifo->read_ptr = fifo->write_ptr = fifo->buffer;
        fifo->end_ptr  = fifo->max_bytes + fifo->buffer;

        advrlog( LOG_INFO, "FIFO reset, fifoz %d", fifoz);
}       

/* Allocate FIFO buffer size n bytes, store pointer in p->buffer */
/* USE_DYNAMIC not needed here because FIFO is large and of variable size n */
/* TESTME: It is possible that a need could arise for a large static FIFO. */
/* static */
void
init_fifo ( struct fifo_s *fifo, int n )
{
        if (NULL == fifo) return;
        if (NULL != fifo->buffer) return; /* already allocated? */

        advrlog( LOG_INFO, "FIFO init");

#ifdef USE_DYNAMIC              
/* malloc FIFO buffer allocation, fifo reset will init */
//      fifo->buffer = imalloc( n, "capture FIFO" );

/* calloc FIFO buffer allocation, fifo reset will init */
        fifo->buffer = icalloc( 1, n, "capture FIFO" );

/* This one really is fatal. Log it so the user can see. */
        if ( NULL == fifo->buffer ) {
                dvrlog( LOG_INFO,"FIFO buffer calloc failed" );
                fprintf( stderr, CLS "FIFO buffer calloc failed\n");
                console_exit(1);
        }
#else
        fifo->buffer = fifo_buffer; /* static fifo */
        memset( fifo_buffer, 0, fifoz );
#endif
/* clear the FIFO buffer */
        fifo_reset( fifo );
}

/* frees the FIFO buffer allocated above */
/* static */
void
free_fifo ( struct fifo_s *fifo )
{
#ifdef USE_DYNAMIC
/* sanity check */
        if (NULL == fifo) return;       /* NULL is something seriously wrong */
        if (NULL == fifo->buffer ) return; /* NULL is not allocated yet */

        ifree( fifo->buffer, "fifo buffer" );
        fifo->buffer = NULL;

/* fifo itself doesn't need freeing. It is a small pointer structure. */
        advrlog( LOG_INFO, "FIFO freed");
#endif
}

/* not quite the end of my code to flesh out ingos fifo */
/***************************************************************************/


/* WRITEME for UDP BROADCAST: If less than half full, keep filling. else
     wait a bit to get closer to half full, but not so long that any data
     is lost unless the cpu/io is porked. (ext2/3)

    It may not help if media player is always done too soon, either because
     it tossed frames rather than decode them late, or is a fast decoder.

    This is why UDP broadcast is listed as experimental, because it does not
    make the playback as smooth as it could be using file itself as buffer.
*/

/***************************************************************************/
/* start of ingos fifo, modified to try harder to empty if getting full */
/* write count bytes from buffer into fifo. */
/* static */
size_t
fifo_write ( struct fifo_s *fifo, unsigned char * buffer, size_t count )
{
    size_t avail = fifo->max_bytes - fifo_atomic_read( fifo );
    size_t todo = count;
    size_t part1, part2;
    int maxtries;

    maxtries = 0;

/* sanity checks */
    if (count < 1) return 0;
    if (NULL == fifo) {
        dvrlog( LOG_INFO, "%s fifo is NULL!", WHO);
        return -1;
    }
    if (NULL == fifo->buffer) {
        dvrlog( LOG_INFO, "%s fifo->buffer is NULL!", WHO);
        return -1;
    }

/* moved here to track highest fill before drain */
/* fixes slow show cap stats update */
    if ( fifo->filled > fill_max ) {
        fill_max = fifo->filled;
        if (fill_max2 < fill_max)
            fill_max2 = fill_max;
    }

/* this seems to help out when deleting large files on ext2/ext3 */
#if 0
/* if FIFO is half full or more, force yield to starving drain */
    if ( fifo->filled > (fifoz >> 1) ) {
        pthread_yield();
        nanosleep( &dummy_read_sleep, NULL);
    }

/* if FIFO is quarter full or more, force yield to starving drain */
    if ( fifo->filled > (fifoz >> 2) ) {
        pthread_yield();
        nanosleep( &dummy_read_sleep, NULL);
    }
#endif

#if 0
    if (0 != test_mode) {
        while (todo > avail) {
/*          pthread_yield(); */
            nanosleep( &atomic_sleep, NULL );
            avail = fifo->max_bytes - fifo_atomic_read( fifo );
        }
    }
#endif

/* try to wait a bit for the FIFO to drain */
    if (todo > avail) {
        /* force output thread to have a go when fifo is full */
        while (todo > avail)
        {

/* if capture stops, break out of drain wait loop */
            if ( CAP_NONE == cap_now ) return 0;
            maxtries++;

/* TWEAK THIS CONSTANT TO MATCH HARDWARE FIFO SIZE AS SET BY DEVICE DRIVER */
/* stock driver should use 21, but more tries should not break anything */
            if (maxtries++ > 154) return 0;

/* give back the timeslice so starving FIFO thread can drain */
            pthread_yield();

/* WARNING: sleep prevents deadlock */
            nanosleep( &atomic_sleep, NULL );
            avail = fifo->max_bytes - fifo_atomic_read( fifo );
        }

/* if still no room, not much can be done. logging may make it worse */
        if (todo > avail) {
            dvrlog( LOG_INFO, "fifo write: FULL!"
                    " start %p end %p read %p write %p\n",
                     fifo->buffer, fifo->end_ptr,
                     fifo->read_ptr, fifo->write_ptr );

/* data was bit-bucketed. caller will increase pkt.synerr */
            return -1;
        }
    }

/* this point is reached only if fifo has enough space for request */


    /* check for split write at end of fifo */
    if ( (fifo->write_ptr + todo) > fifo->end_ptr ) {
        /* write will not fit all before end_ptr */
        part1 = fifo->end_ptr - fifo->write_ptr;
        part2 = todo - part1;

        memcpy( fifo->write_ptr, buffer, part1 );

        /* part1 to end, part2 to beginning */
        buffer += part1;

        /* reset write ptr to start of fifo */
        fifo->write_ptr = fifo->buffer;

        memcpy( fifo->write_ptr, buffer, part2 );
        fifo->write_ptr += part2;
    } else {
        /* write will fit all before end_ptr */
        memcpy( fifo->write_ptr, buffer, todo );
        fifo->write_ptr += todo;
    }

    /* todo is todone by now, only need nukes plus */
    fifo_atomic_add( fifo, todo ); /* NOTE: do this last */

    return todo;
}

/* read count bytes from fifo into buffer */
/* static */
size_t
fifo_read ( struct fifo_s *fifo, unsigned char * buffer, size_t count )
{
    size_t avail = fifo_atomic_read( fifo );
    size_t todo = count;
    size_t part1, part2;

    if (NULL == fifo) {
        dvrlog( LOG_INFO, "%s fifo is NULL!", WHO);
        return -1;
    }

/* sanity check */
    if (NULL == fifo->buffer) {
        dvrlog( LOG_INFO, "%s fifo->buffer is NULL!", WHO);
        return -1;
    }

/* loop on sleep to block caller if can't satisfy request */
    while ( avail < todo ) {

/* escape from read wait loop if input thread ended */
            if (0 == pid_i) return 0;

/* not enough to do gives back to scheduler until there is */
            pthread_yield();
/* if using this, the sleep prevents deadlock */ 
            nanosleep( &atomic_sleep, NULL );
            avail = fifo_atomic_read( fifo );
    }


    /* check for split read at end of buffer */
    if ( (fifo->read_ptr + todo) > fifo->end_ptr )
    {
        /* it won't all read before end_ptr */
        part1 = fifo->end_ptr - fifo->read_ptr;
        part2 = todo - part1;

        memcpy( buffer, fifo->read_ptr, part1 );

        /* part1 done, move to part2 of buffer and copy */
        buffer += part1;

        /* reset write ptr to start of fifo */
        fifo->read_ptr = fifo->buffer;

        memcpy( buffer, fifo->read_ptr, part2 );
        fifo->read_ptr += part2;
    }
    else
        /* read will fit all before end_ptr */
    {
        memcpy( buffer, fifo->read_ptr, todo );
        fifo->read_ptr += todo;
    }

    if ( fifo->filled > fill_max )
        fill_max = fifo->filled;

    /* todo is todone by now, only need nukes minus */
    fifo_atomic_sub( fifo, todo ); /* NOTE: do this last */

    /* return what was actually done, not count */
    return todo;
}
/***************************************************************************/

/******************************************************** pthread root ctl */
/* pthread version of setting thread scheduler from within the thread */
/* NOTE: this requires root for it to work properly as user can't set */
/* FIXME: may not be fixable for 2.4.26 due to kernel limitations? */

/* TODO: kick out of this without error if not running as root
    at least one user reports:
        it can run as a user with some help from nice
*/
/* static */
void
set_pthread_sched ( struct sched_param *sp, int pol, int prio, char *name )
{
    int ok;
    char policy_text[4][8] = { "OTHER", "FIFO", "RR", "SNAFU" };

    uid = geteuid();
    if (0 != uid) {
            dvrlog( LOG_INFO, "root needed for changing thread scheduling");
            return; /* non-root, let superuser try using nice */
    }

/* get first to init some structures */
//    ok = pthread_getschedparam( pthread_self(), &pol, sp );

    ok = -1;
    pol &= 3;   /* limit for text */
    sp->sched_priority = 0;     /* causes error 22 EINVAL if not 1. odd. */

/* FIXME: prio 1 solid lock-up on 2.4.26 kernel, prio 0 errs */
    sp->sched_priority = prio; /* lower = higher priority */
#warning using POSIX SCHED_FIFO priority 1

    advrlog( LOG_INFO, "%s pthread sched(%d, %s, %d)",
            name,
            (int)pthread_self(),
            policy_text[pol],
            sp->sched_priority );       /* don't show if doesn't change */

    ok = pthread_setschedparam( pthread_self(), pol, sp );

    if (0 != ok) {      /* error check for scheduler prio not changed */
        dvrlog( LOG_INFO, "%s pthread err %d tid %d %s pri %d",
                name,
                ok,
                (int)pthread_self(),
                policy_text[pol],
                sp->sched_priority
            );
        return; /* not fatal but may cause problems with buffer overruns */
    }

    advrlog( LOG_INFO, "%s pthread pid %d tid %d %s pri %d",
                name,
                getpid(),
                (int)pthread_self(),
                policy_text[pol],
                sp->sched_priority ); /* get to here is ok */
}


/**************************************** Transport stream FIFO I/O pthreads */
/* both run detached so there should be no stdio called from within thread,
    or else the thread will generate SIGPIPE and either die, zombie
    or go to sleep depending on SIGPIPE handling in place.
*/


#if 0
/* this should be moved to fifo input loop? */

/* sync test only useful for v4l, and only works with TSBUFZ size above,
   because test sync needs 21 packets worth to find possible sync points.
   HD2000 v4l had the sync issues, but HD3000 v4l was ok. dvb is ok for both
 */
        test_sync_block( out_buf ); /* will set or reset pkt.align */
        /* align has number of bytes short that is corrected here */
        if (pkt.align != 0) {
            fifo_read( ts_fifo, out_buf + TSBUFZ, pkt.align );
            frdbc += pkt.align;
            advrlog( LOG_INFO, "fifo out: pkt align %d", pkt.align);
        }
#endif
/* read from the device and write to the fifo until cap_now resets */
void *
fifo_input_loop ( void * arg )
{
    int len, ok;

    ok = 0;
    pid_i = getpid();

    advrlog( LOG_INFO, "%s  pid_i %d detached", WHO, pid_i);

#ifdef USE_SIGNALS
/* disable control c */
    sigint_set( 0 );
#endif

//    memset( &fifo_input_param, 0, sizeof( fifo_input_param ) );
    set_pthread_sched( &fifo_input_param, SCHED_FIFO, 1, "in ");

    stream_on();
/* wait a bit for the driver to wake up */
    nanosleep( &guide_loop_sleep, 0);

/* flush  enough to purge the old data, at least 512k worth i think.
     512k / 188 / 21 ~= 132 blocks of 21 packets each, about 1/5 second */


    if (0 == arg_dummy) { /* -r assumes sync is good */
        if (0 != cap_now) atsc_get_sync(21);
    }

    if (0 != pkt.align) dvrlog( LOG_INFO, "%s SYNC IS BAD", WHO);

/* NOTE: log this to ram disk to prevent buffer overrun from log delay */
    advrlog( LOG_INFO, "%s sync %s OK", WHO, (arg_dummy) ?"maybe":"is");

/* save current cap start time in various formats */
    get_time();
    memcpy( &tloc3, &tloc, sizeof(tloc3) );
    utscap = utsnow;

/* getsync poisoned counts that are used by show cap stat, so reset them */
/* don't need to reset the per channel stats, because only set at end of cap */
    memset( &pkt, 0, sizeof( struct pkt_s ));

/* good sync is align 0 and no errors. log and fall through if not good */
    if ( (pkt.align != 0) || (pkt.synerr != 0) )
    {
    /* sync_align should be 0 if it did it correctly */
        if (pkt.align != 0) {
            dvrlog( LOG_ERR, "%s no syncs align [%d], giving up", WHO, 
                        pkt.align);
            stop_capture( "no syncs align", FAIL_TSYNC);
        }
        if (pkt.synerr != 0) {
            dvrlog( LOG_ERR, "%s sync error [%d], giving up", WHO,
                pkt.synerr);
            stop_capture( "sync error", FAIL_TSYNC);
        }
/* converse of above test is sync_align == 0 && sync_errors == 0 */
    } else {
        advrlog( LOG_INFO, "%s sync is good", WHO );


/* input loops until cap now resets or fifo full or end of file for -r */
        while (CAP_NONE != cap_now) {

#if USE_SELECT_FIFO
            int ok;
            fd_set fds;
            struct timeval fdtv;
            
            fdtv.tv_sec = 0;
            fdtv.tv_usec = 100; /* 1 ms, about 12.9 packets */
            FD_ZERO( &fds );
            FD_SET( in_file, &fds );
            ok = select( in_file+1, &fds, NULL, NULL, &fdtv );

            if (-1 == ok) {
                    stop_capture( "select error", FAIL_IFIFO);
                    break;
            }

/* timeout should yield to drain */
            if (0 == ok) {
                pthread_yield();
/* will be locking up without this sleep */
                nanosleep( &atomic_read_sleep, NULL );
            }
#endif
            len = read( in_file, ts_buf, TSBUFZ );

/* stop the capture if device gives an error */
            if (0 == arg_dummy)
            {
/* should never get end of file since it blocks */
                if (len == 0) {
                    cap_fail = FAIL_NONE;
                    dvrlog( LOG_INFO, "%s got EOF on blocked device?",
                            WHO);
                    stop_capture( "fifo in EOF", FAIL_IFIFO);
                    break;
                }


/* device error */
                if (len < 0) {

/* ext2/ext3 large file deletes can cause EOVERFLOW */
                    if ( EOVERFLOW == errno ) {
/* use SYNC error total counter for overflows */
                        pkt.synert++;

/* any error other than overflow will abort capture */
                    } else {
/* don't fill up the dvrlog, kill thread after log */
                        dvrlog( LOG_INFO, "%s device read error %d '%s'",
                                WHO, errno, strerror( errno) );
                        stop_capture( "fifo error", FAIL_IFIFO);
                        break;
                    }
                }
            } else {
                /* dummy mode will get end of file instead of blocking */
                /* any error will signal end of file. is ok for replay */
                if (len < 1) {
                    stop_capture( "fifo in: EOF", FAIL_NONE);
                    break;
                }
            }

/* -r replay dummy mode has to wait or it will fill fifo.
    normal mode can not tolerate very much waiting around */
            if (0 != arg_dummy) {
                while ( 1 ) {
                    if (( fifoz - ts_fifo.filled) > len)
                        break;
/*                  pthread_yield(); */
                    nanosleep( &dummy_read_sleep, NULL );
                }
            }

/* to handle signals, don't care about the len as long as more than 0 */
            if (len > 0) {
                ok = fifo_write( &ts_fifo, ts_buf, len );
                if (ok < 0) {
                    dvrlog( LOG_INFO, "%s fifo_write returns -1\n", WHO);
                    break;
                }

                if (ok > 0) fwrbc += ok;

/* fifo full? only reason why ok wouldn't be len
     this could pork the dvrlog, so don't log it.
     only indication it's occuring will be pkt.synert increasing
*/
                if ( len != ok )
                {
/* logging will make it worse if logging to same volume as capture */
                    advrlog( LOG_ERR,
                            "%s fifo full? write len %d != rc %d",
                            WHO, len, ok );

/* don't fail: count as sync error instead */
/*                  cap_fail = FAIL_IFIFO; */
                    pkt.synert++;  /* let it add up */
                }
            }
        }
        advrlog( LOG_INFO, "%s cap_now %d", WHO, cap_now);
    }

    stream_off();

/* thread is done, go back to normal scheduling */
    set_pthread_sched( &fifo_input_param, SCHED_OTHER, 0, "in ");

#ifdef USE_SIGNALS
/* control c was disabled during capture, re-enable it */
    sigint_set( 1 );
#endif

    advrlog( LOG_INFO, "%s pthread_exit, wrote %lld", WHO, fwrbc );

    pid_i = 0;
    pthread_exit( NULL );
}


/**************************************** Transport stream FIFO I/O pthreads */
/* read from the fifo and write to a file until cap_now resets */
/* the reader is the only one allowed to close the fifo [ingos notes] */
void *
fifo_output_loop ( void *arg )
{
    int ok;
    unsigned char *p;

    pid_o = getpid();

    ok = -1;

/* demoth, log causes buffer overruns on v4l input device so log to ram */
    advrlog( LOG_INFO, "%s pid_o %d detached", WHO, pid_o);

//    memset( &fifo_output_param, 0, sizeof( fifo_output_param ) );
    set_pthread_sched( &fifo_output_param, SCHED_FIFO, 1, "out");

    pkt.align = 0;

/* drain the fifo */
    while( 1 )
    {
/* will change to 0x47 if ok */
        *out_buf = 0;

/* all this buffer copying is eating a share of the cpu */
        ok = fifo_read( &ts_fifo, out_buf, TSPZ);
        if (ok > 0) frdbc += ok;
        if (ok < 0) {
            dvrlog( LOG_INFO, "%s fifo_read returns -1\n", WHO);
            break;
        }
/* fifo has nothing to read? */
        if (0 == ok) {
/* input thread done? */
            if (0 == pid_i) {
                advrlog( LOG_INFO, "%s cap_now %d ok %d", WHO, cap_now, ok);
                break;
            }
/* input thread not done, sleep a bit and try again for more data */
            nanosleep( &dummy_read_sleep, NULL );           
            continue;
        }

#if 1
/* TESTME: does this ever happen? */
        if (ok != TSPZ) {
            dvrlog( LOG_INFO, "fifo_read count %d is short", ok);
            break;
        }
#endif

/* Count bad sync and good sync.  Seems of little use these days, but
    users of bt878-based cards, like HD2000, might still find it useful.
*/
        if (0x47 != *out_buf) {
            pkt.synert++;
        } else {
            pkt.synct++;
        }

        pkt.align = 0;

        p = &out_buf[0];        /* assume p is len TSPZ, single packet now */
        atsc_test_packet_stats(p); /* statistical wrapper above ATSC layer */

/* -n option:
    Substitutes removed packet with NULL packet. This is for Roku1000 or other
    hardware players. Continuity Counter is don't care for NULL packets.
 */
        if (0 == pkt.keep) {
            if (0 != arg_nulls) {
                p = nul_buf;
                pkt.null++;
                pkt.keep = ~0;
            }
        }

/* pkt.keep is set by test packet stats */
        if (0 != pkt.keep) {

/* dummy can write */
            if (out_file > 2) write_pkt_block( p ); /* build/write cut_buf */

/* UDP live is only UDP that works because ATSC device determines packet rate.
   TCP lets the application request set the packet rate but doesn't work live.
   Can only do near-live playback of a current capture over TCP.
*/

#ifdef USE_MCAST
            if (0 != udp_mcast) {
                struct udp_s *u = &udp;
                /* write the packet to the socket */
                if ( (-1 != u->sock) && (-1 != u->bind))
                    udp_write_socket( u, p );
            }
#endif
        }
    } /* while 1 */

/* flush */
//    if (out_file > 2) fsync( out_file );

/* thread is done, go back to normal scheduling */
    set_pthread_sched( &fifo_output_param, SCHED_OTHER, 0, "out");

    advrlog( LOG_INFO, "%s pthread_exit, read %lld outbc %lld",
            WHO, frdbc, outbc);

/* clear output thread pid */
    pid_o = 0;
    pthread_exit( NULL );
}
/* @end fifo.c */

/********************************************************* DVB frontend init */
/* /sys/class/dvb/ has list of dvb devices registered. count them */
/* static */
void
get_dvr_count( void )
{
        struct stat s;
        char n[256];
        int i, j;

        j = 0;
        for (i = 0; i < 4; i++) {
                snprintf( n, sizeof n, "/sys/class/dvb/dvb%d.dvr0", i);
                if (0 == stat(n, &s)) j++;
        }
        advrlog( LOG_INFO, "detected %d dvb devices", j);
        www_dvrs = j;
        return;
}


/* static */
int
init_dvb_frontend ( int fe_fd, struct dvb_frontend_parameters *frontend)
{
    char d[256];
    char *m;
    
    m = "";
    
    if ( (0 != test_mode) || (0 != arg_dummy) ) return 0;
    
    if (ioctl(fe_fd, FE_GET_INFO, &fe_info) < 0) {
            dvrlog( LOG_INFO, "FE GET INFO fail\n");
            return -1;
    }
    
    if ( FE_ATSC != fe_info.type ) {
        dvrlog( LOG_INFO, "FE is not ATSC\n");
        return -1;
    }
    
    snprintf( fe_text1, sizeof(fe_text1), "FE is %s", fe_info.name);

/* driver should do this automatically? */
//    frontend->inversion = INVERSION_OFF;

    memset(d, 0, sizeof(d));

    m = "FUBAR";

    if (0 != (FE_CAN_QAM_256 & fe_info.caps)) {
        snprintf( &d[strlen(d)], 8, "QAM256 ");
        m = "QAM256";
    }

    if (0 != (FE_CAN_QAM_128 & fe_info.caps)) {
        snprintf( &d[strlen(d)], 8, "QAM128 ");
        m = "QAM128";
    }

    if (0 != (FE_CAN_QAM_64 & fe_info.caps)) {
        snprintf( &d[strlen(d)], 7, "QAM64 ");
        m = "QAM64";
    }

    if (0 != (FE_CAN_QAM_32 & fe_info.caps)) {
        snprintf( &d[strlen(d)], 7, "QAM32 ");
        m = "QAM32";
    }

    if (0 != (FE_CAN_QAM_16 & fe_info.caps)) {
        snprintf( &d[strlen(d)], 7, "QAM16 " );
        m = "QAM16";
    }

    if (0 != (FE_CAN_16VSB & fe_info.caps)) {
        snprintf( &d[strlen(d)], 7, "VSB16 " );
        m = "VSB16";
    }

    if (0 != (FE_CAN_8VSB & fe_info.caps)) {
        snprintf( &d[strlen(d)], 6, "VSB8 ");
        m = "VSB8";
    }

/* FIXME: cable needs to use some kind of option for this */
    if (0 != arg_cable) {
        if ( 0 != (FE_CAN_QAM_256 & fe_info.caps)) {
            frontend->u.vsb.modulation = QAM_256;
            m = "QAM256";
        }
    } else {
        if ( 0 != (FE_CAN_8VSB & fe_info.caps)) {
            frontend->u.vsb.modulation = VSB_8;
            m = "VSB8";
        }
    }

    snprintf( fe_text2, sizeof(fe_text2), "FE using %s; supports: %s", m, d);
    snprintf( fe_text3, sizeof(fe_text3), "%s", m);
    
    return 0;
}    

/* DVB filters packets, but do not need filtering, so turn it off. */
/* should not change for cable, because need PAT+PMT from cable. */
/* static */
int
init_dvb_filter ( void )
{
    
    if ( (0 != test_mode) || (0 != arg_dummy) ) return 0;

    dmx_filter.pid = 0x2000; /* pass-through mode? */
    dmx_filter.input = DMX_IN_FRONTEND;

/* DMX OUT TS TAP sets demux output to be as new transport stream */
    dmx_filter.output = DMX_OUT_TS_TAP;
    dmx_filter.pes_type = DMX_PES_OTHER;

/* DMX_IMMEDIATE START not used here but in fifo_input */
    dmx_filter.flags = 0;

/* set DVB to not filter any packets */
    if (ioctl( dmx_file, DMX_SET_PES_FILTER, &dmx_filter) < 0) {
        dvrlog( LOG_INFO, "DMX SET PES FILTER fail");
        return -1;
    }
    advrlog( LOG_INFO, "DMX SET PES FILTER 0x2000");
    return 0;
}

/* This might help with the DViCo nano driver issues reported by tupari:
    back-to-back captures corrupt the second capture. Tupari reports closing
    and opening the device helps, but that induces too many delays.  Instead,
    this will test to see if it's the demux device buffer causing the problem.
    atscap requires the full stream and sets the demux device accordingly.
*/

/* static */
void
dmx_reset( )
{
        int ok;

        advrlog( LOG_INFO, "%s %d", WHO, dmx_file);
        if (dmx_file < 3) return;
        ok = close( dmx_file );
        if (ok < 0) {
                dvrlog( LOG_INFO, "%s close %s %d failed", WHO, dmx_name, ok );
                return;
        }

        dmx_file = open( dmx_name, O_RDWR ); /* ioctl is write? */
        if ( dmx_file < 3) {
                dvrlog( LOG_INFO, "%s open %s failed", WHO, dmx_name );
                return;
        }

        advrlog( LOG_INFO, "%s open %s %d OK", WHO, dmx_name, dmx_file);
        if ( 0 != ioctl( dmx_file, DMX_SET_BUFFER_SIZE, TSBUFZ ) ) {
                dvrlog( LOG_INFO, "%s SET BUFFER SIZE failed", WHO);
        }
        if ( 0 != init_dvb_filter() ) {
                dvrlog( LOG_INFO, "%s init_dvb_filter failed", WHO);
        }
}


/* Open the ATSC device(s), put fd or error in:
   NOTE: in_file is input, error goes here. DVB extras are input control.
        V4L: in_file, 1 file one device.
        DVB: fe_file, dmx_file, dvr_file == in_file, 3 files one device.
*/
/* static */
void
open_device ( char *caller )
{

        if (in_file > 2) {
                dvrlog( LOG_INFO, "*** %s device fd %d %s already open",
                        caller, in_file, in_name);
                return; /* don't open twice */
        }

        advrlog( LOG_INFO, "*** %s open device %s",
                    caller, in_name);

/* if (test_mode == 0 ) return; */
/* that's enough for dummy mode? */
    
        aprintf( stderr, HOM BG "OPENED %-24s" BN, in_name);

/* error until opened */
        in_file  = -1;
        fe_file  = -1;
        dmx_file = -1;
        dvr_file = -1;

/* clear test mode, will set it if device can't be opened */
        test_mode = 0;

/* a fix for replay file name not resetting after cap */
        if (0 != arg_dummy) {
                snprintf( in_name, sizeof(arg_dummyn)-1, "%s", arg_dummyn);
                in_file = open( in_name, O_RDONLY );
                if (in_file < 3) {
                        dvrlog( LOG_INFO, "%s error %d reading %s",
                                WHO, in_file, in_name );
                }
                return; /* file read mode does need to init device? */
        }

        advrlog( LOG_INFO, "using DVB");
/* DVB API open method, uses new FE_TUNE_MODE_ONESHOT setting
        to stop the constant status reads that are killing driver */
        if ( (0 == test_mode) && (0 == arg_dummy) )
        {
          memset( &fe_param,   0, sizeof( fe_param ) );
          memset( &fe_info,    0, sizeof( fe_info )  );
          memset( &dmx_filter, 0, sizeof( dmx_filter ) );
          fe_file = open( fe_name, O_RDWR ); /* ioctl is write? */
        
/* all these have to pass */
          if ( fe_file > 2 )
          {

/* dvb_frontend.c defaults to zig-zag mode, we don't want this for ATSC/cable.

   All testing so far shows you do not want HD2000/3000 i2c chatter during
    capture because of a tendency to desync/fail or51132/or51211 i2c comm.
    The microcode is probably designed for only one task at a time. You can
    capture or you can signal scan, but both at same time cause problems.

   See developer mirror for my v4l-dvb hg cvs patch that has
    better i2c handling and automatic reset on i2c failure.

   Even with my patch, if you don't set tune mode to one-shot, you
    will see more resets than you will if you use the one-shot ioctl. You
    may also see increased capture errors without the one-shot ioctl.

   Turning off zig-zag mode and constant status check, no ret val:
    Reduces HD3000 i2c driver lock-outs; missing from 2.6.12-14.
    This ioctl is reported to be missing from 2.6.15.1 too?
*/

#if defined(FE_SET_FRONTEND_TUNE_MODE)
#warning using Linux DVB FE_TUNE_MODE_ONESHOT
            ioctl( fe_file, FE_SET_FRONTEND_TUNE_MODE, FE_TUNE_MODE_ONESHOT );
#endif
            advrlog( LOG_INFO, "FE OPEN OK %d", fe_file );
            if ( 0 == init_dvb_frontend( fe_file, &fe_param ) )
            {
                dmx_file = open( dmx_name, O_RDWR ); /* ioctl is write? */
                if ( dmx_file > 2)
                {
                    advrlog( LOG_INFO, "DMX OPEN OK %d", dmx_file);
                    if ( 0 == ioctl( dmx_file, DMX_SET_BUFFER_SIZE, TSBUFZ ) )
                    {
                        if ( 0 == init_dvb_filter() )
                        {
                            dvr_file = open( dvr_name, O_RDONLY );
                            if (dvr_file > 2)
                            {
                                dvrlog(LOG_INFO, "DVR OPEN OK %d", dvr_file);
                                in_file = dvr_file; /* capture will use */

                                /* DVB DONE */
                                /* return; */ /* fall through */

                            } else { /* dvr_file <= 2 */
                                dvrlog(LOG_INFO, "DVR OPEN %s FAIL", dvr_name);
                                test_mode = ~0;
                            }
                        } else { /* 0 != init_dvb_filter */
                            dvrlog( LOG_INFO, "DMX FILTER FAIL" );
                            test_mode = ~0;
                        }
                    } else { /* 0 != ioctl dmx file bufz */
                        dvrlog( LOG_INFO, "DMX BUFFER SIZE %d FAIL", TSBUFZ );
                        test_mode = ~0;
                    }               
                } else { /* dmx file not open */
                    dvrlog( LOG_INFO, "DMX OPEN %s FAIL", dmx_name);
                    test_mode = ~0;
                }
            } else { /* 0 != init_dvb_frontend */
                dvrlog( LOG_INFO, "FE INIT %s FAIL", fe_name);
                test_mode = ~0;
            }               
          } else { /* fe file <= 2 */
            dvrlog( LOG_INFO, "FE OPEN %s FAIL", fe_name);
            test_mode = ~0;
          }         
        }

/* make set_channel re-set the channel */
    scan_freq = 0;

/* deprecated: test mode. want it to exit rather than eat another screen */
    if (0 != test_mode) {
        fprintf( stderr, CLS "Open %s failed\n", fe_name);
        if (0 != arg_dummy) return;
        console_exit(1); /* open fail goes to exit */
    }
#ifdef USE_POWERDOWN
    utspdd = utsnow + USE_POWERDELAY;
#endif
    
}

/* build out_name based on capture mode

    -o option forces outname regardless of anything else (for scripts)
    -r option forces outname and in name to same file name

    User cap name is network id.ts, or network id.pn.ts
      ABC.ts or ABC.3.ts

    MPEG has no concept of minor channel number which is only found in VCT.
    If the station stops sending VCT for whatever reason, the fallback to
    MPEG-only should still work because the program # is in the timer. The
    program number is used to cross ref the correct proto-VC info in MPEG pa[].

    Info cap name is Program Guide + Callsign
        Program Guide KTRK

    Timer cap name is from timer name and flags in timer name.

    build outnames is one thing that uses @ (old #). rest are:
        get timer add event     (user enters from epg)
        add search event        (atscap enters from search list)
        strip timer flags
        load config and save config do not process these flags

TODO:
    build outnames could check for name existing, and
    if so, try name.n++[.pn].ts until it finds a non existing new name

    use @ instead of dot and obsolete current $ meaning to current @ meaning.
    no one has mentioned using $-weekday in a long time, and is unused here.
    The @ sign should make it more obvious the timer is the program @pgm,aud.
    . dot could be reused in place of , comma for audio, but starts to look
*/
/* static */
void
build_outnames ( void )
{
    struct sig_s *s;
    char *call, *net, n[64];
    struct qtimer_s *t;

    s = &ptc[cap_chan].sig;
    call = s->call;
    net = s->sid;
    
    memset( out_name, 0, sizeof(out_name));

/* FIXME: breaks [enter] to cap specific vc */

    if (CAP_NONE == cap_now) return;


    advrlog( LOG_INFO, "%s cap p %d v %d a %d",
            WHO, cap_pn, cap_vc, cap_va);

/* -r dummy mode sets out_name and in_name the same */
    if (0 != arg_dummy) {
        char nn[256];
        filebase( nn, arg_dummyn, F_TFILE );

/* input name mangled to name-1.ts or name.p.ts */
        snprintf( out_name, sizeof(out_name), "%s%s%d.ts",
                    out_path, nn, cap_pn);
        snprintf( in_name, sizeof(in_name), "%s", arg_dummyn);
        advrlog( LOG_INFO, "dummy outputs %s", out_name);
        return;
    }

/* -o outname override also will set output name for dummy mode, do nothing */
/* NOTE: user must supply extension */
    if ( 0 != *arg_ofile ) {
        /* -p outpath override will set output path */
        if (0 == *arg_opath) {
            snprintf( out_name, sizeof(out_name)-1, "%s", arg_ofile);
        } else {
            snprintf( out_name, sizeof(out_name)-1, "%s%s",
                arg_opath, arg_ofile);
        }
        return;
    }

/* want callsign not network for -s5 feedback, .ts extension */
/* user override above will prevent it getting here */
    if (0 != arg_capture) {
        snprintf( out_name, sizeof(out_name)-1, "%s%s.ts",
                    out_path, call);
        return;
    }

    if (0 != arg_dummy) return;

/* info cap name is Program Guide + Channel */
    if (CAP_INFO == cap_now) {
/*      cap_pn = cap_vc = cap_va = -1; */ /* set in ts_cap */

        snprintf( out_name, sizeof(out_name)-1, "EPG%02d", cap_chan);
        advrlog( LOG_INFO, "%s INFO %s", WHO, out_name);
        return;
    }

    if (cap_pn > 0) cap_va = s->va; /* default audio from config */
    if (cap_pn > 0) /* user/timer cap checks audio if program select */
        if (-1 == cap_va) /* audio select -1 default is same as audio 0 */
            cap_va = 0;

/* user cap sets name to net.ts or net.p.ts or net.p,a.ts if va > 0 */
    if (CAP_USER == cap_now) {
        *n = 0;
        cap_vc = find_vc_pgm( cap_pn, WHO );

/* no VCT yet? */
        if (-1 == cap_vc) {
            cap_vc = find_pa_pgm( cap_pn, WHO );
/* if cap_vc still -1, parse PAT will have to set it */
        }

/* full cap if cap_vc -1 */     
        dvrlog( LOG_INFO, "%s user cap p %d v %d a %d",
                    WHO, cap_pn, cap_vc, cap_va );

        if (cap_pn < 1) {
            snprintf( n, sizeof(n)-1, "%s.ts", net);
        } else {
            if (cap_va < 1) {
                snprintf( n, sizeof(n)-1, "%s.%d.ts",
                    net, cap_pn);
            } else {
                snprintf( n, sizeof(n)-1, "%s.%d,%d.ts",
                    net, cap_pn, cap_va);
            }
        }
        snprintf( out_name, sizeof(out_name)-1, "%s%s", out_path, n);
        advrlog( LOG_INFO, "%s USER %s p %d v %d a %d",
                 WHO, n, cap_pn, cap_vc, cap_va);
        return;
    }

/* timer cap parses the flags in timer name to determine how name is built
    flags supported are:
        $ for -wdy as three char weekday
        @ for -mmdd-hhmm as month day hour minute
            (changed to @, is URI friendly, # gets truncated by browsers)
        .p for specific program p
        ,a for specific audio a, needs to follow .p, if used
 */

    if (CAP_TIME == cap_now)
    {
        char tn[TIMER_NAME_MAX];
        char tpn[16], tva[16], twd[16], tmd[16];
        char *f1, *f2, *f3, *f4; /* @ $ . , */

        t = &timer[timer_rec];  

        cap_pn = -1; /* default is full cap unless flag given */

        memset( tn,  0, sizeof( tn  ) );
        memset( tpn, 0, sizeof( tpn ) );
        memset( tva, 0, sizeof( tva ) );
        memset( twd, 0, sizeof( twd ) );
        memset( tmd, 0, sizeof( tmd ) );

        /* alter the copy of time name */
        astrncpy( tn, timer[timer_rec].name, sizeof(tn) );
        f1 = strchr( tn, '@' );
        f2 = strchr( tn, '$' );
        f3 = strchr( tn, '.' );
        f4 = strchr( tn, ',' );

/* flags @ $ do not have following parameters, NULL check only */
/* flags . , do have following parameters, NULL check and point to */
        if (NULL != f3) *f3++ = 0;
        if (NULL != f4) *f4++ = 0;
        
        get_time();                                     /* time is current */


#if 0
/* these should have been parsed and stored when timer loaded from config?
   but vc could still be wrong because of missing nn.vc file.
*/
            cap_pn = t->pn;
            cap_vc = t->vc;
#endif

/* if . dot flag, set cap pn and cap vc from .program number */
        if (NULL != f3) {
            cap_pn = atoi( f3 );                        /* some cable > 7 */
            cap_vc = find_vc_pgm(cap_pn, WHO);          /* try to find vc */

/* no VC selected? */
            if (-1 == cap_vc) {
                if (cap_pn > 0) {
                    cap_vc = find_pa_pgm(cap_pn, WHO);

/* if no vc loaded yet, parse PAT will have to set cap_vc */
                    if (-1 == cap_vc) {
                        dvrlog( LOG_INFO, "%s parse PAT.%d will set cap_vc",
                                WHO, cap_pn);
                    }
                }
            }

#if 0
/* should be cap_pn = 0 to force getting first vc program
*/

/* log override and force single vc0 cap if pn set but vc isn't */
            if ((cap_pn > 0) && (-1 == cap_vc)) {
                cap_vc = find_vc_pgm( cap_pn, WHO);
                if (-1 == cap_vc) {
                    dvrlog( LOG_INFO, "%s overrides cap_vc0", WHO);
                    cap_vc = 0;
                }
            }
#endif

/* if can't find vc now, parse VCT or PAT will try to find from .program# */
            snprintf( tpn, sizeof(tpn), ".%d", cap_pn); /* asssume p# OK */

/* if , comma flag, set program audio from ,audio number */
            if (NULL != f4) {
                cap_va = atoi( f4 );
                if (cap_vc >= 0) {                      /* if vc found */
                    if (cap_va >= vc[cap_vc].acn)       /* and audio not OK */
                        cap_va = 0;                     /* use main audio */
                }
                /* if vc not found yet, have to assume ,audio# is correct */
                snprintf( tva, sizeof(tva), ",%d", cap_va); /* assume a# OK */
            }
        }

/* DEBUG: force main audio for all timers */
/*      cap_va = 0; *tva = 0; */

        if ( ',' != *tva ) {                    /* if no timer ,audio number */

            if (cap_va > 0)                     /* and user wants non-main */
                snprintf( tva, sizeof(tva), ",%d", cap_va); /* override it */
        }

/* if $ flag, generate -Day of week */
        if (NULL != f2) {
            *f2 = 0; /* truncate for name only */
            twd[0] = '-';
            memcpy( &twd[1], date_now, 3);
        }

/* if @ flag, generate -mmdd-hhmm */
        if (NULL != f1) {
            int ok;
            time_t es;
            struct tm et;
            char en[256];
            struct stat fs;

            *f1 = 0; /* truncate for name only */
            es = (time_t)timer[0].start;
            
            localtime_r( &es, &et);
/* Check to see if file already exists at scheduled event start time
   and if not, use that name, otherwise use curent time */
            snprintf( tmd, sizeof(tmd)-1, "-%02d%02d-%02d%02d",
                        et.tm_mon+1, et.tm_mday, et.tm_hour, et.tm_min );
            snprintf( en, sizeof(en)-1, "%s%s%s%s%s%s.ts",
                        out_path, tn, twd, tmd, tpn, tva );
            ok = stat( en, &fs);
            advrlog( LOG_INFO, "build outnames %s exists %d", en, ok);

/* if file exists, use current time instead; need to copy tloc current time,
   web users will have to go to cap dir to playback instead of guide href */
            if (0 == ok) {
                memcpy( &et, &tloc, sizeof( et ));
                snprintf( tmd, sizeof(tmd)-1, "-%02d%02d-%02d%02d",
                            et.tm_mon+1, et.tm_mday, et.tm_hour, et.tm_min );
            }
        }

/* order of flags is this: name-wdy-mmdd-hhmm.p,a.ts */
        snprintf( n, sizeof(n)-1, "%s%s%s%s%s.ts", tn, twd, tmd, tpn, tva);
        snprintf( out_name, sizeof(out_name)-1, "%s%s", out_path, n);
        advrlog( LOG_INFO, "%s TIMER %s p %d v %d a %d",
                 WHO, n, cap_pn, cap_vc, cap_va);
        return;
    }    

    dvrlog( LOG_INFO, "%s FAIL\n", WHO );
    snprintf( out_name, sizeof(out_name)-1, "%sFAIL", out_path);
    stop_capture( WHO, FAIL_NONE);
}


/* static */
int
chaos_loop ( struct sig_s *s )
{
        int i, k, c, e, aosb;
        char m[ 64 ];
        struct timespec ns;
        struct timespec aos_start;
        struct timespec aos_stop;
        struct timespec aos_diff;

        clock_gettime( clock_method, &aos_start );

        aosb = 0;
        ns.tv_sec = 0;
        ns.tv_nsec = aos_delay << 20;
        *m = 0;

        scan_freq = 0;
        get_signal_lock( s );

        c = 0;
        e = 0;
        for (i=1; i <= AOS_MIN_LOOPS; i++) {

                if (0 != arg_cable) {
                    if (i > 3) break;
                }

                get_time();

                get_signal_lock( s );
                k = console_getch();

                nanosleep( &ns, NULL );
/* show */

                asnprintf(m, sizeof(m), "%02d ", s->strength);
                aosb += s->strength;
                c++;
                aprintf( stderr, "\033[3;1H" BY "AOS%02d %s" BN CEL,
                        s->chan, m);

// no, want to collect all points for inner loop
                if (s->strength < AOS_MIN_STRENGTH) e++;
                if (0 != arg_cable) break;
        }

        if (0 == c) c = 1;
        aosb /= c;
        clock_gettime( clock_method, &aos_stop );
        time_diff( &aos_diff, &aos_start, &aos_stop );

        if (0 != e)
            advrlog( LOG_INFO, "AOS%02d ET: %d.%09d AvgA[%d]: %02d%% [%s]",
                s->chan, aos_diff.tv_sec, aos_diff.tv_nsec, c, aosb, m  );
        return aosb;
}

/* -a option: Acquisition Of Signal check.
    AOS will try to validate the signal strength before capturing.
    Will try MAX_AOS_LOOPS times MIN_AOS_LOOPS in total
        or stop looping early if signal strength is good.
*/
/* static */
int
chaos ( struct sig_s *s )
{
        int i, c, e, aos, aosa;
        char m[ 64 ];
        struct timespec aos_start;
        struct timespec aos_stop;
        struct timespec aos_diff;

        aprintf( stderr, "\033[3;1H" CEL);
        clock_gettime( clock_method, &aos_start );

/* AOS */    
        get_signal_lock( s ); 
        nanosleep( &msg_sleep, NULL ); /* 250ms for 5 scans */

/* -a not specified or -r tard mode specified which doesn't need AOS 
    or cable where AOS is always 99
*/
        if ( (0 == arg_aos)
          || (0 != arg_dummy)
          || (0 != arg_cable) ) {
                aosa = 99;
                s->strength = aosa;
                return aosa;
        }
        aprintf( stderr, "\033[3;1H" BY "AOS%02d" BN CEL, s->chan); /* show */
        aos = aosa = 0;
        c = 0;
        e = 0;
        *m = 0;
        for (i=1; i<= AOS_MAX_LOOPS; i++) {
                get_time();
                aos = chaos_loop( s );
                aosa += aos;
                c++;
                asnprintf(m, sizeof(m), "%02d ", aos);

/* 50% is lowest strength for lock indication, if the driver is working */
                if (aos < AOS_MIN_STRENGTH) e++;
                if (aos >= AOS_MIN_STRENGTH) break;
                if (0 != arg_cable) break;
        }
        if (0 == c) c = 1;
        aos = aosa / c;

/* hold down until start time to get file name closer to start time */
        if (CAP_TIME == cap_now) {
                while (utsnow < timer[0].start) {
                        get_time();
                        nanosleep( &console_read_sleep, NULL); /* 100ms */
                }
        }

        clock_gettime( clock_method, &aos_stop );
        time_diff( &aos_diff, &aos_start, &aos_stop);

/* for non-info cap, log if it fails */
        if (CAP_INFO != cap_now) {
            if (0 != e) {
                advrlog( LOG_INFO, "AOS%02d ET: %d.%09d AvgB[%d]: %02d%% [%s]",
                    s->chan, aos_diff.tv_sec, aos_diff.tv_nsec, c, aos, m );
            } else {
                advrlog( LOG_INFO, "AOS%02d ET: %d.%09d Avg %02d%%",
                    s->chan, aos_diff.tv_sec, aos_diff.tv_nsec, aos );
            }
        }
        return aos;
}


/* ts capture calls this */
/* static */
void
init_globals ( void )
{
        scan_one = ~0;  /* channel lock */
        scan_sig = 0;   /* turn off signal scan/display */

        sequence_idx = 0;
        last_sbo = 0;
        frame_idx = 0;
        last_vpn = 0;

/* keep track of last cap mode for dump cap stats */
        cap_prev = cap_now;
        cap_pchn = cap_chan;
        cap_prvc = cap_vc;

        cap_zap = 0;    /* no left over zaps */
        cap_zapped = 0;
        cap_done = 0;
        cap_fail = 0;   /* it will be set later, maybe */
        cap_errors = 0;
        cap_etime = 0;  /* default is by capture type */
        cap_tsid = 0;

        display_type = D_TIMERS; /* jump back to timer display */
        refresh.timers = 1;     /* trigger the timer list */
        block_widx = 0;  /* reset cut block index */

        pgm_done = 0;
        pgm.fail = 0;
        pgmto = 0;              /* reset timeout to fix 'l' twice problem */

        fill_max = fill_max2 = 0;       /* fifo stats */
        utscap = utsets = 0;    /* time stats */
        sec_good = sec_bad = 0; /* number of seconds good and bad */
        frdbc = 0LL;
        fwrbc = 0LL;
        outbc = 0LL;    /* output byte count */

        pat_built = 0;
        pmt_built = 0;

        chan_name[0] = 0;

        pkt.pmtrc = 0;

/* dump stat html, dump cap log, save epg */
        utsdsh = 0;
        utsdcl = 0;
        utsdpg = 0;

        mgt_vn = 0xFF;

/* -m: set cap_frames to arg_frames in case out-of-frames resets cap_frames */
        cap_frames = arg_frames;
        utspte = 0;

/* clear event name and description; TODO? use t->ename/edesc instead? */
        *epg_name = 0;
        *epg_desc = 0;

        otsidx = tsidx;
}

/* save tallies from psi_pids, cce_pids and pids by walking the vc list */
/* static */
void
save_pkt_stats( struct sig_s *s )
{
    if (NULL == s) return;
    if (0 == vc_ncs) return;

    memcpy( &s->pkt, &pkt, sizeof(struct pkt_s));
}

/* Create reader/writer threads then wait for cap_now reset.
    Sync check is at start of reader thread, will reset cap_now if no sync.
    Resetting cap_now will flush the output buffer and terminate r/w threads.
    Bottom of this waits for threads to end then delete any files if zap.

    2 pthread_joins does not work correctly. pthread spec indicates trying to
    start more than one thread and try to join them together causes all kinds
    of unspecified behaviour. Replaced join with wait for r/w thread terminate.
*/
/* static */
void
ts_capture ( void )
{
        int ok, i;
        char *tc = "";
        char f[256];
        struct sig_s *s;
        int ets = 0;
        char *ct;
        unsigned int aost;      /* strength average of 10 tries */
        struct stat64 fs;       /* checks for existing files */
        int tr;                 /* thread return */
        long long estb;
        char *ests;

#ifdef USE_MCAST
        struct udp_s *u = &udp;
#endif

        pid_c = getpid();
        i = 0;

        refresh.headers = 1;

/*      dump_epg_html( epg, &pgm, pg, WHO); // want html BEFORE it's wiped? */
/* moved epg wipe after dump epg */
        init_globals();

/* -s but not -S */
        if (0 != arg_chan) cap_chan = arg_chan;

        if (CAP_TIME == cap_now)
        {
                advrlog( LOG_INFO, "ts cap timer[%d].chan %d %s",
                        timer_rec,
                        timer[timer_rec].chan,
                        timer[timer_rec].name );

/* timer_rec should always be 0 because of sort */
                pgm.chan = cap_chan = timer[timer_rec].chan;
                *epg_name = 0;
                *epg_desc = 0;

/* if exists, copy event name and description for later */
                if (0 != *timer[0].ename)
                        astrncpy( epg_name, timer[0].ename, sizeof(epg_name) );
                if (0 != *timer[0].edesc)
                        astrncpy( epg_desc, timer[0].edesc, sizeof(epg_desc) );
        }

        s = &ptc[ cap_chan ].sig;
        s->cap_ets = 0;

/* manual cap default, possibly changed by build outnames */
        cap_pn = s->pn;
        cap_vc = s->vc;
        cap_va = s->va;

/* reset the packet counts */
        init_stats( s );

/* display the usual stats */
        display_type = D_TIMERS;
        set_refresh();

/* variable size FIFO when using dynamic allocation */
#ifdef USE_DYNAMIC
        fifoz = FIFOZ_EPG;
        if (CAP_INFO != cap_now) fifoz = FIFOZ_CAP;
#endif

/* if there is only 1GB (binary) free, the capture can't continue. */
        read_capvol_stats();
        if (CAP_NONE == cap_now) {
                dvrlog( LOG_INFO, "%s false alarm, volume full", WHO );
                if (CAP_TIME == cap_prev) reschedule_timer( 0, WHO );
                utswuv = -1;
                goto capture_exit;
        }

/* Moved post volume check. Saves memory grab until enough to do something. */
        init_fifo( &ts_fifo, fifoz );

        init_atsc();

#ifdef USE_MCAST
        if ( (CAP_USER == cap_now) && (-1 != u->sock) && (-1 != u->bind) ) {
                dvrlog( LOG_INFO, "UDP MCAST %s", WHO);
        }
#endif

/* show timer list so user knows a capture event is occurring */
        display_type = D_TIMERS;

/* want callsign to show up even if cap fails somehow */
        astrncpy( chan_name, s->call, sizeof(chan_name) );

/* WARNING: tupari reports having to close and re-open the device here or else
        DVB-API DViCo nano driver will trash the stream. Instead of closing
        all DVB devices try to reset demux device only, to see if it helps.
*/
        if (0 == arg_cable) dmx_reset();

/* tard mode resets file to start position every cap */
        if (0 != arg_dummy) lseek( in_file, 0, SEEK_SET );

        get_time();

/* set elsewhere? */
/*    memcpy( &tloc3, &tloc, sizeof(tloc3) ); */

/* tuning assists */

/* save cap chan, will stay on this after cap */
        scan_pos = get_scanlist_offset( cap_chan );
        scan_next = scan_pos;

        chid = ptc[ cap_chan ].sig.sid;

        scan_freq = 0; /* make sure channel set if slammed into active timer */
    
/* sets cap pn, cap vc cap va */

/* FIXME: should have VCT data but find_vc_pgm below returns -1, not found.
   is normal for cold start with timers but without guide data,
   but should always have VCT if guide already saved, as in EPG [enter]
 */

/* set_channel calls set_vc and changes cap_pn/vc/va */
        advrlog(LOG_INFO, "%s cap chan %s%d", WHO, s->sid, s->chan);
        set_channel( s, WHO );

/* info cap gets full capture but is only temporary, not stored in s-> */
        if (CAP_INFO == cap_now) {
                cap_pn = -1;
                cap_vc = -1;
                cap_va = -1;
        }

/* save current guide data. first new data in 7 seconds */
        pgm.chan = cap_chan;

/* build the capture filename. it may change farther down */
        build_outnames();

/* log start cap in case fails with AOS hang */
        advrlog( LOG_INFO, "CAP%02d %s start ", cap_chan, out_name );

        if (CAP_NONE == cap_now) goto capture_exit;

        *f = 0;
        if (out_file > 2)
/* truncate filename for status */
                filebase( f, out_name, F_FILE);

        pkt.errors = 0;

        utsdpg = utsnow + 5;    /* don't do it again for57 seconds */

/* clear signal samples and index */
        memset( s->smp, 0, sizeof(s->smp));
        memset( s->rmp, 0, sizeof(s->rmp));
        s->smx = 0;

/* -s is full cap only for now, will override config file pn/va */
/* will need to parse arg_chan to get program number or add option,
   to make this usable via cron. until then, cron script will have
   to extract the desired program and delete the fullcap file.
*/
        if ( (0 != arg_capture) && (0 != arg_chan)) {
                cap_pn = -1;
                cap_vc = -1;
                cap_va = -1;
                display_stat = ~0;
        }

/* update console in case startup jumps immediately to capture */
        show_headers(0);
        show_timers();

/* reset cap stats to known bogus value */
        memset( cap_stats, 0xFF, sizeof(cap_stats) );

/* current scan position, csp, gets moved around depending on mode */
//      snprintf( csp, 15, "\033[%d;1H", 3 + get_scanlist_offset( cap_chan ) );
        if (D_TIMERS == display_type) snprintf( csp, 15, "\033[3;1H");

/* show filename on 1st row 1st col, white is timer, green is manual */
        tc = BW;
        if (CAP_TIME == cap_now) tc = BR;

        s->sig_col = &bc[0][0];

/* estimated time in seconds for timer or cli -s cap, or zero for manual */
        get_time();
        ets = 0;
        if (0 != arg_capture) {
                ets = arg_capture;
        } else {
                if (CAP_TIME == cap_now) {
                        ets = (timer[timer_rec].start
                            + (timer[timer_rec].len
                            -  timer[timer_rec].secdt))
                            - utsnow;
                        if (ets < 0) ets = 0;
                }
        }
        ct = "CAP";
        if (test_mode != 0) ct = "TEST";

/***************************** Acquisition Of Signal *************************/

        filebase( f, out_name, F_TFILE );

        aost = chaos( s );

/******************************** signal is bad? ****************************/
        if (aost < AOS_MIN_STRENGTH) {
                dvrlog( LOG_INFO, "AOS%02d %2d%% FAIL %s",
                        cap_chan, aost, f );

/* should redraw timers but doesnt? */
                refresh.timers = 1;
                display_type = D_TIMERS;
                timer_sort = ~0;
/*              show_timers(); // let status update do this */

/* don't keep trying if AOS is bad, reschedule it or remove it */
/* cap_now gets changed */
                if (CAP_TIME == cap_prev) reschedule_timer( 0, WHO );
                stop_capture( WHO, FAIL_AOS );
                goto capture_exit;
        }

/**************************** signal is good ****************************/


/* if it's a timer, in case AOS ends early, wait until start of capture */
        if ( (CAP_TIME == cap_now) && (timer_idx > 1) ) {
                if (T_SEARCH != timer[0].qstat) {
                        while(utsnow < timer[0].start) {
                                get_time();
                                nanosleep( &console_read_sleep, NULL );
                        }
                }
        }

/* in case AOS runs over the end of the minute, do it again
   to get name closer to actual capture data flow start time
*/
        build_outnames();

/* log start cap in case fails with AOS hang */
        advrlog( LOG_INFO, "CAP%02d %s", cap_chan, out_name );
        filebase( f, out_name, F_TFILE);

        if (0 == *out_name) goto capture_exit;
        if (CAP_NONE == cap_now) goto capture_exit;

/* default is first audio if none specified */
        if (cap_pn > 0)
                if (cap_va < 0)
                        cap_va = 0;

        cap_prpn = cap_pn;

        advrlog( LOG_INFO, "%s p %d v %d a %d", WHO, cap_pn, cap_vc, cap_va);

/* do this after build outnames or you won't get pgm to vc translation */
        init_arrays(); /* reset stats, pgm guide, all that jazz */

/* FIXME: info cap and manual full cap do not need frame data */
        if (CAP_INFO != cap_now) {
/* single VC cap is only cap that needs frame data */
                if (cap_pn > 0) init_frames();
        }
/* stat check for file, gives error on large file if stat() used */
        if (CAP_INFO != cap_now) {
//              dvrlog( LOG_INFO, "AOS%02d %2d%% %d OK %s",
//                      cap_chan, aost, s->freq, f);
                dvrlog( LOG_INFO, "AOS%02d %2d%% OK %s",
                        cap_chan, aost, f);

/* 0 or -1 error (errno set) */
                ok = stat64( out_name, &fs );
/* truncate delete filename string */
                *del_name = 0;

/* statfs 0 ret means file exists and needs to be renamed */
                if (ok == 0) {
                        char *b;
            /* copy to delete filename and replace .ts with .$ */
                        astrncpy( del_name, out_name, sizeof(del_name) );

                        b = strrchr(del_name, '.');
                        if (NULL != b) {
                                b++;
                                *b++ = '$';
                                *b = 0;
                        }

/* device not open, dummy mode, dont actually rename anything
   also don't rename if arg ofile set, in case live via /tmp/fifo
 */
                        if (test_mode == 0)
                                if (*arg_ofile == 0)
                                        rename( out_name, del_name );
                }
        }

/* create at least a blank cap log */
        dump_cap_log( WHO );

/* OPEN OUTPUT */
        out_file = -1;

        if (CAP_INFO != cap_now) {

/* CREAT, TRUNC, and set to owner read/write, everyone else read */
                out_file = open( out_name, FILE_WMODE, FILE_PERMS );
                if (out_file < 3) {
                        dvrlog( LOG_ERR, "%s open write fail %s: %s", WHO,
                                out_name, strerror(errno) );

/* non-fatal error if write file can not be opened */
                        fprintf( stderr, CLS "%s open write fail %s: %s", WHO,
                                 out_name, strerror(errno) );
                        stop_capture( WHO, FAIL_OFIFO );
                        goto capture_exit;
                }
                advrlog( LOG_INFO, "out_file open %s %d", out_name, out_file );
        }


/****************************** THREAD_CREATE *****************************/

/************************ input thread detaches ****************************/
/* start device -> fifo input thread, as detached thread */
/* cap_now = 0 stops fifo input loop */

//      memset( &fifo_input_thread, 0, sizeof(fifo_input_thread) );
//      memset( &fifo_input_attr, 0, sizeof(fifo_input_attr) );
        tr = pthread_attr_init( &fifo_input_attr );
        tr |= pthread_attr_setdetachstate( &fifo_input_attr,
                        PTHREAD_CREATE_DETACHED);
/* set now because unknown time until is loaded with thread pid */
        pid_i = ~0;    
        tr |= pthread_create( &fifo_input_thread, &fifo_input_attr,
                        fifo_input_loop, NULL);
        if (0 != tr) {
                pid_i = 0;
                advrlog( LOG_INFO, "pthread create fifo input error %d", tr );
                goto capture_exit;
        }

/*  nanosleep( &console_read_sleep, NULL ); */

/************************** output thread detaches ***************************/
/* start fifo -> file output thread */
/* pid_i = 0 and fifo filled zero stops output thread, clears pid_o */

//      memset( &fifo_output_thread, 0, sizeof(fifo_output_thread) );
//      memset( &fifo_output_attr, 0, sizeof(fifo_output_attr) );
        tr = pthread_attr_init( &fifo_output_attr );
        tr |= pthread_attr_setdetachstate( &fifo_output_attr,
                        PTHREAD_CREATE_DETACHED);
/* set now because unknown thread time until loaded from thread pid */
        pid_o = ~0;
        tr |= pthread_create( &fifo_output_thread, &fifo_output_attr,
                            fifo_output_loop, NULL );
        if (0 != tr) {
                advrlog( LOG_INFO, "pthread create fifo output error %d", tr );
                pid_o = 0;
                goto capture_exit;
        }

/*    nanosleep( &console_read_sleep, NULL ); */



    clock_gettime( clock_method, &cap_start );

/* now that read and write have their own threads, this one
   does not block anymore and can be used for clock/status update
*/
        while ( 1 )
        {
                show_status( 1, WHO );

/* look for exit or control (sets state flags) */
                console_scan();

/* prevent cpu pig, but don't go much under 100ms to keep UI responsive */
                nanosleep( &signal_loop_sleep, NULL );

/* stop status loop update when both threads terminate and clear pid_flags */
                if ( (0 == pid_o) && (0 == pid_i) ) {
                        advrlog( LOG_INFO, "%s threads done", WHO);
                        break;
                }

/* NOTE: if you disable this, it doesn't stop info cap for current event */
/* if info cap adds event from search timer, stop the capture */
                if ( (CAP_INFO == cap_prev) && (CAP_INFO != cap_now) ) {
                        advrlog( LOG_INFO, "info cap stopped");
                        stop_capture( WHO, FAIL_NONE );
                        break;
                }

/* if cap limit given and if past it */
                if ( (arg_capture != 0 ) && (utsets >= arg_capture) ) {
                        advrlog( LOG_INFO, "-s time expired");
                        stop_capture( WHO, FAIL_NONE );
                        break;
                }
        }
/* until both threads are done */

/************************* end of capture *******************************/

        refresh.headers = 1;
        cap_done = ~0;

/* Moved capture stop time stamp from fifo input loop because it
    does it out of order due to thread latency, apparently.
*/
        clock_gettime( clock_method, &cap_stop );
        time_diff( &cap_diff, &cap_start, &cap_stop );
        advrlog( LOG_INFO, "start %d.%03d stop %d.%03d diff %d.%03d",
            cap_start.tv_sec, cap_start.tv_nsec / 1000000,
            cap_stop.tv_sec,  cap_stop.tv_nsec  / 1000000,
            cap_diff.tv_sec,  cap_diff.tv_nsec  / 1000000 );

        dump_cap_log( WHO );    /* write name.html capture error log file */
        dump_frame_sequence();  /* write name.tsx sequences + frames file */

        if (out_file > 2)
                advrlog( LOG_INFO, "out_name %s closed %lld bytes",
                         out_name, outbc);

/* log end of EPG cap too in case fails with AOS hang */
        advrlog( LOG_INFO, "CAP%02d %s %lldM errs %d",
                cap_chan, out_name + strlen(out_path),
                outbc >> 20, pkt.errors);

        if (out_file > 2) close( out_file );

        aprintf( stderr, BN "%s" CEL, csp);

/* round up the elapsed time seconds and count 0 as 1 */
        s->cap_ets = cap_diff.tv_sec;
        if (cap_diff.tv_nsec >= 500000000L ) s->cap_ets++;
        advrlog( LOG_INFO, "%s cap_diff %d", WHO, cap_diff.tv_sec);
        if (s->cap_ets < 1) s->cap_ets = 1;

        ests = "";
        estb = outbc;

/* base2-base10 (1023 != 999) rounding issue */
        if (estb > 1023) {
                estb >>= 10; /* might see K for quick start/stop */
                ests = "K";
                if (estb > 1023) {
                        estb >>= 10; /* 1M to 999M uses M */
                        ests = "M";
                        if (estb > 1023) { /* 1G and above uses G */
                                estb >>= 10; /* gigs */
                                ests = "G";
                        }
                }
        }

/* cap_now is already 0, test cap prev, guide cap has to chk too */
        if ( (CAP_USER == cap_prev) || (CAP_TIME == cap_prev) ) {
/* delete *.$ renamed file and optionally zap current cap file */
                remove_renamed();
/* small delay to see it */
                nanosleep( &msg_sleep, NULL );
        }

        scan_sig = 0;
        timer_sort = ~0;
        blinky = 0;

/* TESTME: needed? force reload of cap_pn,vc,va from s->pn,vc,va */
/*    scan_freq = 0; */
        cap_now = CAP_NONE;
        refresh.epg = 1; /* show event short uses */

#if 0
/* save any new TSIDs from this capture. NO: find stations saves at end */
        if (0 == arg_scan)
            if (otsidx != tsidx)
                save_tsids();
#endif

/* need to save config in case any new search timers added */
        save_config( WHO );

        if (0 != cap_zapped) ct = "ZAP";

        if (CAP_INFO != cap_prev) 
                dvrlog( LOG_INFO, "%s%02d %s %s(%d) errs %d QoS %lld%%",
                        ct, s->chan, f, (0 != cap_fail) ? "FAIL":"OK",
                        cap_fail, pkt.errors, qost);

/* save guide if QoSt good enough and cap > 15s */
        if ( ( (qost > QOS_INFO_SS_LIMIT) && (utsets > 15) )
            || (0 != epg_test)  /* or doing test epgs */
            || (0 != arg_cable) /* or cable user hit [l] key */
            )
            save_guide();

/* TODO: turns off the refresh if it was on [DONE?] */
        dump_cfg_html( WHO );

/* update packet stats for this channel */
        save_pkt_stats( s );

capture_exit:
        cap_now = CAP_NONE;
/* This caused no-end-to-cap problems the last time I tried to use it */
        while (0 != (pid_o | pid_i)) nanosleep(&atomic_sleep, NULL);

 /* do not free until capture threads end, bug found by Peter Knaggs */
        free_fifo( &ts_fifo );  // is dynamic even with USE_DYNAMIC ndef
        free_frames();          // is dynamic only when USE_DYNAMIC def
        free_atsc();            // is dynamic only when USE_DYNMAIC def

/* clear current capture epg name, description and flags */
        memset(epg_name, 0, sizeof(epg_name));
        memset(epg_desc, 0, sizeof(epg_desc));
        cap_done = ~0;
        out_file = -1;
        scan_sig = 0;

#ifdef USE_POWERDOWN
/* clear the wakeup one-shot to auto-find the next time to wake up */
        utswuv = 0;
#endif

/* redraw timers */
        last_pktc = pkt.count;
        get_time();
        display_type = D_TIMERS;
        set_refresh();
        show_headers(1);
        show_status( 0, WHO );

/* hold down test guides if expired in case another timer kicks in */
        if (utstpg < (utsnow + PROGRAM_GUIDE_TIMEOUT))
                utstpg = utsnow + PROGRAM_GUIDE_TIMEOUT;

        pid_c = 0;

#ifdef USE_POWERDOWN
        get_time();
        utspdd = utsnow + USE_POWERDELAY;
#endif
}

/* Check to see if any guide file expiration (modify) times have been crossed.
 If post modify time, initiate info cap to load a new guide from stream.
 If zero modify time, init modify time with stat time from guide.
 Otherwise if saved guide file exists for current channel, load it.

 The guide file expiration time will be set to the next 3 hour meridian.
 Optionally, the guide file will expire half-way to the end of the last event,
 or the next 3hr meridian, which ever is greater.
 
 The device number will add futher multiples of seconds to the timeout,
 so that the multiple instances will stagger the load instead of
 hitting it all at once, to not distract any current playback.

    NOTE: There are a lot of conditions that will hold down this function.
            It is meant to run when all else is idle.
*/

/* various hold downs prevent test epgs from running, order may be important */
/* static */
int
test_epgs_hold( char *caller )
{
        int i, j, k;
        struct sig_s *s;


//#define USE_SIGSCAN_IGNORES_INFOCAP
#ifdef USE_SIGSCAN_IGNORES_INFOCAP
/* prevents timely auto-epg updates. [not needed with 3hr meridian fixups?] */
        if ( 0 != scan_sig ) return -1;         /* is not signal scan? */
#endif
        if (CAP_NONE != cap_now) return -1;     /* is not capturing? */
        if ( utsnow < utstpg ) return -1;       /* is not expired? */
        if ( 0 != pid_c) return -1;             /* is not capturing? */

        if ( 0 != arg_scan ) return -1;         /* is not creating config */
        if ( 0 == cf_mt ) return -1;            /* is not configured */
        if ( D_CHANNELS == display_type)
            return -1;                          /* is not channel list? */

        if ( 0 != arg_dummy) return -1;         /* is not dummy? */
        if ( 0 != test_mode) return -1;         /* is not test? */

/* hold down test epgs if timer0 is within 3m of now */
        if (timer_idx > 0) {
            if (T_SEARCH != timer[0].qstat) {   /* not search? */
                if ( utsnow >= (timer[0].start - 180) ) {
                    dvrlog( LOG_INFO, "%s timer0 %s", WHO, timer[0].name );

/* push off next test guides check until well after timer is done */
                    utstpg = timer[0].start + timer[0].len
                             + ( (1+arg_devnum) * PROGRAM_GUIDE_TIMEOUT);
                    return -1;
                }
            }
        }

/* hold down test epgs if timer1 within 3m of now */
/* prevents late start: test epgs trying to run between consecutive timers */
        if (timer_idx > 1) {
            if (T_SEARCH != timer[1].qstat) {   /* not search? */
                if ( utsnow >= (timer[1].start - 180) ) { /* within 3m? */
                    dvrlog( LOG_INFO, "%s timer1 %s", WHO, timer[1].name );
                    return -1;
                }
            }
        }

/* nothing to do? */
        j = 0;
        for (i = 0; i < scan_idx; i++ ) {
            k = scan_list[i];
            s = &ptc[ k ].sig;

/* skip if no auto program guide time out flag */
            if (0 == s->pgto) continue;

/* TESTME: is it worth the trouble of consolidating pgto and pgrt? NO?
    needs adjustments to load/save config and would confuse user? */

/* has program guide refresh time occurred yet? */
            if (utsnow >= s->pgrt) j++;
        }

/* no epgs need refresh? */
        if (0 == j) return -1;

        advrlog( LOG_INFO, "%s %s is OK to run", WHO, caller);
        return 0;
}

/* the mutex is used to prevent multiple allocs but is it needed? */
/* static */
void
test_epgs ( char *caller )
{
        int spgch, spgmt, fpgmt;
        int i, ch, rc;
        struct sig_s *s;
        struct stat fs;
        char f[256];
        int ok;

/* FIXME: list of channels already done, but would break import of .epg?
   No, cable import is too limited only loads first program... for now.
   There would be multiple events listed for broadcast until I make
    show program guide be more selective about the events it displays.
    This mostly only applies to stations that share same PTC, but the
    user wants to have separate listing on channel list for it.
   ptcd tells to copy .vc file instead of cap. vc+pa doesn't refer PTC.
*/
        unsigned char vcd[ 128 ];
        char en[256];   // epg name
        char xn[256];   // xlate name
        char dn[256];   // dir name
        char sc[256];   // system cli

        if (0 != arg_scan) return;
        memset( vcd, 0xFF, sizeof(vcd) );

/* no guide on cable, but maybe can fetch from elsewhere? */
//      if (0 != arg_cable) return;

/* don't do rest if hold downs haven't expired */
        if (0 != test_epgs_hold( WHO )) return;

/* is it already running? */
        if (EBUSY == pthread_mutex_trylock( &epg_mutex )) return;

        advrlog( LOG_INFO, "%s(%s)", WHO, caller);

/* NOTE: don't return until these freed and mutex unlocked */
        epg2 = imalloc( sizeof( epg ), "test epg2");
        if (NULL == epg2) {
                dvrlog( LOG_INFO, "%s failled epg2 malloc", epg2);
                goto test_epgs_exit;
        }

        epg_test = ~0;  /* hold down before setting any local variables */

/* Z parameter wasn't numeric, use ntp_name for ntpdate fetch */
        if (0 != *ntp_name) {
                memset(sc, 0, sizeof(sc));
                snprintf(sc, sizeof(sc)-1, "ntpdate %s &>/dev/null", ntp_name);
                rc = 0;
#ifndef USER_TEST
                rc = system( sc );
#endif
                if (0 != rc)
                        dvrlog(LOG_INFO, "%s %d = system( %s )", WHO, rc, sc);
        }

/* hold down and mutex tests complete, see if any guides have changed,
    from first config channel to last config channel
*/
        snprintf( dn, sizeof(dn)-1, "%s%s/pg", out_path, ram_path);

        chdir( dn );

/* remove all the pnxf files, if any */
        for (i = 0; i < scan_idx; i++) {
/* point to sig struct for this channel */
                s = &ptc[ scan_list[i] ].sig;
                if (0 == s->pnx) continue;
                snprintf( en, sizeof(en), "%02d.epx", s->pnxf);
                remove( en );
        }

        for (i = 0; i < scan_idx; i++ )
        {
                nanosleep( &console_read_sleep, NULL);  /* reduce CPU usage */

                fpgmt = 0;
                ch = scan_list[i];
                s = &ptc[ ch ].sig; /* point to sig struct for this channel */

/* subset of scanlist: only channels with program guide time out non-zero */
                if (0 == arg_cable) /* want cable to fetch all the vc tsids */
                    if (0 == s->pgto)
                        continue;

/* this can still be used for touch but mostly as http blank helper now */
                snprintf( f, sizeof(f)-1, "%s%spg/%02d.html", out_path, ram_path, ch);
                ok = stat( f, &fs );
                if (0 == ok)
                {
                        fpgmt = (int)fs.st_mtime;

/* NOTE: Refresh can be done even if capturing something on another channel */

/* Refresh html guide is done whenever html file date is zero */
                        if (0 == fpgmt) {
                                advrlog( LOG_INFO, "touch dump guides %s %d", f, fpgmt );

/* init_epg that clears first byte of each .name entry would be faster */
                                memset( &pgm2, 0, sizeof( pgm )); /* tiny array */
                                memset( &pg2, 0xFF, sizeof( pg )); /* small array */

/* use current hide/aged/match settings for guide refresh */
                                pgm2.chan = ch;
                                pgm2.hide = pgm.hide;
                                pgm2.age = pgm.age;
                                pgm2.find = pgm.find;

                                load_epg( ch, epg2, &pgm2, pg2, WHO );
                                build_pg_epg( epg2, &pgm2, pg2, WHO );
                                dump_epg_html( epg2, &pgm2, pg2, WHO );
                        }
                } else {
                        memset( epg2, 0, sizeof( epg ));  /* large array */
                        memset( &pgm2, 0, sizeof( pgm )); /* tiny array */
                        memset( pg2, 0xFF, sizeof( pg )); /* small array */

/* file does not exist, can create a blank one now */
                        pgm2.chan = ch;
                        build_pg_epg( epg2, &pgm2, pg2, WHO );
                        dump_epg_html( epg2, &pgm2, pg2, WHO );
                }


/* now check binary version */
                fpgmt = 0;
                snprintf( f, sizeof(f)-1, "%s%spg/%02d.epg", out_path, ram_path, ch );
                ok = stat( f, &fs );
                if (0 == ok) fpgmt = (int)fs.st_mtime;

/* init by load config needs to reload all the timeouts from mtime */
                if (0 == s->pgmt) s->pgmt = fpgmt;

                if (0 == fpgmt) s->pgmt = 0; /* www reload */

                text_time(date_next, s->pgmt, 19);
                advrlog( LOG_INFO, "APG%02d %s %s",
                         ch, (utsnow < s->pgmt)?"expires":"EXPIRED", date_next);

                get_time();

/* break out if any timers and under 3 minutes to next timer */
                if (0 != timer_idx) {
                        if (T_SEARCH != timer[0].qstat) {

/* TESTME: never interrupted and rescheduled here? log it if so */
                                if ( utsnow >= timer[0].start - 180) {
                                        epg_test = 0;
                                        utstpg = timer[0].start + timer[0].len;
                                        utstpg += PROGRAM_GUIDE_TIMEOUT;
                                        dvrlog( LOG_INFO, "%s timer0 within 3m", WHO );
                                        break; /* free mallocs above */
                                }
                        }
                }

/* is guide expired? if so, trigger new guide load */
                if ( utsnow >= s->pgmt ) { /* will be = if arrives here on time */

/* trigger new guide load */
                        pgm.chan = ch;
                        cap_chan = ch;

/* move scan index to current capture channel so console interface follows */
                        scan_pos = get_scanlist_offset( ch );

                        rc = chdir( dn );
                        if (0 != rc) continue;

                        cap_fail = FAIL_NONE;

                        advrlog( LOG_INFO, "APG%02d expired ts cap", ch);

/* should update the PAT+PMT every 3 hours for cable too. cable may
    move some stations around but program number should be same. */
                        cap_now = CAP_INFO;
                        ts_capture();

/* check for aborts */
                        if (0 != cap_zapped) break;
                        if (0 != cap_zap ) break;
                        if (0 == epg_test) break;

                        advrlog( LOG_INFO, "APG%02d fail: cap %d pgm %d",
                                         ch, cap_fail,pgm2.fail);
                        vcd[ s->ptc ] = s->chan;

/* xn is external epg name, en is local epg name */
                        snprintf( xn, sizeof(en)-1, "%02d.epg", s->pnxf );
                        snprintf( en, sizeof(xn)-1, "%02d.epg", ch );

/* cable fetches the .epg from remote server */
                        if ((0 != arg_cable) && (0 != s->pnx)) {
                            aprintf( stderr, DCA_HEAD3
                                    "wget remote %02d.epg" CEL, s->pnxf);
                            remove( en );

/* FIXME: should set timeout and retries to 30s/0, or write http_fetch */
                            snprintf( sc, sizeof(sc)-1,
                                        "wget -q -O %s http://%s/pg/%s",
                                        en, epg_srv, xn);
                            rc = system( sc );
                            if (0 != rc)
                                dvrlog( LOG_INFO, "APG%02d %d = %s",
                                        ch, rc, sc );

/* try to load the remote epg (will translate channel and program number) */
                            load_epg( ch, epg, &pgm, pg, WHO );
                            aprintf( stderr, DCA_HEAD3 CEL);

                        }
/* redraw timer headers after EPG capture */
                        show_headers(0);

/* If no epg, or blank, set it to retry at the next EPG meridian
   when the EPG may again be available. 2 cases handled here:
    1) user may have set C line GTO field for stations w/o EPG
    2) station that has guide stops sending it, or has really bad reception
*/
                        if (0 == pgm.idt)
                        {
                            struct utimbuf u;
                            FILE *fh;
                            int t;
                            t = get_next_meridian();

                            if (0 != s->pgto)
                                dvrlog( LOG_INFO, 
                                        "APG%02d failed: retry in %dm",
                                         ch, (t - utsnow) / 60 );

/* don't trigger until next 3 hour meridian */
                            s->pgmt = t;
                            s->pgrt = t;

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

/* touch, in case file does not exist, want epg status to be blank */
                            fh = fopen( f, "a");
                            if (NULL != fh) {
                                fclose( fh );
                                u.modtime = (time_t) s->pgmt;
                                utime( f, &u );
                            }
                        }

                }
        }

        spgch = 0;
        spgmt = 0x7FFFFFFE;

/* count backwards to find lowest channel with earliest pgmt first */
        for (i = (scan_idx - 1); i >= 0; i--) {
                ch = scan_list[i];
                s = &ptc[ ch ].sig;     
                if (0 == s->pgto) continue; /* only the active ones */
                if ( (s->pgmt > utsnow) && (s->pgmt <= spgmt) ) {
                        spgmt = s->pgmt;
                        spgch = ch;
                }
        }

        if ((0 == spgch) || (0x7FFFFFFE == spgmt) || (0 == spgmt)) {

/* push off next test until next 3hr meridian */
                advrlog( LOG_INFO, "APGxx %s found nothing", WHO );
                utstpg = get_next_meridian();
        } else {
                utstpg = spgmt;
                text_time( date_next, utstpg, 19 );
                dvrlog( LOG_INFO, "APG%02d next autoguide %s", spgch, date_next);

                epg_to = spgmt;
                epg_ch = spgch;
        }

// TESTME is this needed here too? ts capture already set it...
#ifdef USE_POWERDOWN
        utspdd = utsnow + USE_POWERDELAY;
#endif

/* Track the date of the last matching spam event seen, */
        save_spamlist( WHO );

test_epgs_exit:
        if (NULL != epg2) ifree( epg2, "test epg2" );
        epg2 = NULL;
        epg_test = 0; /* status */
        pthread_mutex_unlock( &epg_mutex );
}

/* show channels in scan_list, and signal strengths (if scan_sig != 0)
*/
/* FIXME: last unscrollable list: this does not support cable, so more than
    user_lines channels will make the redraw very ugly. I do not anticipate
    that people will have more than 20 channels for local broadcast physical
    transmission channels but with packet stats enable, it's only 16 lines.

    This also affects web-scan, so be careful about what is changed to make
    it do console, i.e. don't skip channels because they don't display.
 */
/* static */
void
show_channels ( void )
{
    int i, j, m, n;
    int ch;
    int siglocks = 0;
    struct sig_s *s;

    channel_idx = scan_idx;
    show_chanlist();

    for (j = 0; j < scan_idx; j++) {

        show_status( 1, WHO );

/* scan next moves to next entry in scan list */
        if (scan_next > 0) {
                j = scan_next % scan_idx; /* sanity limit/wrap */
                scan_next = 0;
        }           

/* If [TAB] mode, skip channels that don't start and end in display area.
   This will make the web interface act strange while viewing what console
    is doing. Scan button 2x should kick it out of limited channel mode.
*/
        if (D_CHANNELS == display_type) {
            if ( (j < channel_offset)
              || (j >= (channel_offset + user_lines) ) ) {
                console_scan();
                continue;
            }
        }

        i = channel_offset + j;
        if (i >= scan_idx) continue;

        scan_pos = i;
        ch = scan_list[scan_pos];

/* NOTE: everything uses cap_chan for current channel */
        cap_chan = ch;
        s = &ptc[ch].sig;
        s->lock = 0;

        if (ch != pgm.chan) load_guide( ch, WHO );
        
/* cursor scan position string */
        snprintf( csp, 15, "\033[%d;1H", 3 + (j % user_lines));
        if (D_TIMERS == display_type)
            snprintf( csp, 15, "\033[%d;1H", 3);

/* goal is one channel per second, scan or no scan, use scan_rate to help */
        if (scan_sig == 0) n = 1;
        n = scan_rate;
        if (0 != arg_cable) n = 1;

        siglocks = 0;
        s->str_avg = 0;

/* this is how many signal scans to show on each channel */
        for (m = n; m > -1; m--)
        {
            if (fe_file > 2) set_channel( s, WHO );

/* keep signal scans over 100ms cycle time but makes read sig slower */
/* but it does allow control-L for refresh */
            console_scan();
            nanosleep( &console_read_sleep, NULL);

            /* bust out if cap enabled (already below) */
            if (CAP_NONE != cap_now) break;
            
/* only show status on first loop if signal scan disabled */
            if (0 == scan_sig) {
                show_status( 1, WHO );
//              aprintf( stderr, SCI "%s", csp );
                aprintf( stderr, "%s", csp );

/* should only kick in the first time through */
//              if (0 == m)
                    show_signal( s, j );

//              aprintf( stderr, SCV );
                
                for (i=0; i<16; i++) {
                    if (CAP_NONE != cap_now) break;
                    console_scan();
                    if (scan_next > 0) break;
                    nanosleep( &guide_loop_sleep, NULL);
                }
                if (scan_next == 0) continue;
            }


            if (scan_next > 0) {

#if 0
/* obsolete [ and ] keys, but used for 1-9 keys */
/* scan_next: -2 back1, -1 next1, or 1-9 to jump to */
// obsolete [ last ] next channel keys
//              refresh.vstats = 1;
                if (scan_next < 0 ) {
                    if (scan_next == -2) {
                        j--;
                        if (scan_one == 0) j--;
                        if ( j < 0 ) j += scan_idx;
                        scan_next = 0;
                        break;
                    }
                    /*  break advances to next channel */
                    if (scan_next == -1) {
                        if (scan_one) j++;      
                        scan_next = 0;
                        break;
                    }
                }
#endif

/* channel jump, from hotkey [or signal?] */
                if (scan_next > 0) {
                    if (scan_next <= scan_idx) {
                        j = scan_next - 1;
                        scan_next = 0;
                        break;
                    }
                }
                /* it wasn't valid so ignore it */
                scan_next = 0;
            } /* if scan_next != 0 */

/* get new signal readings if doing signal scan */
//          show_status( 1, WHO );
            if (0 != scan_sig) get_signal_lock( s );    /* read strength */

/* last loop on this channel when scanning all 
    gets str_avg substituted for strength
*/
            if (0 == scan_one) {
                if (0 == m) {
                    calc_sig_avg(s);
                    s->strength = s->str_avg;

/* console needs because arg extras sets different display ranges */
                    if (0 != arg_extras) {
                            calc_snr_rms(s);
                            s->snr = s->snr_rms;
                    }
                }
            }

/* move the cursor and show the signal reading */
            aprintf( stderr, SCI "%s", csp );
            if (0 != scan_sig) {
                 show_signal( s, j );
            }

/* capture start breaks out of channel scan */
            if (CAP_NONE != cap_now) break;

// blinks too fast
//          if (0 != scan_one) m = m + 1;
            if (CAP_NONE != cap_now) break;
        } /* for m */

/* FIXME: move this up to use m instead so scan_one doesn't display avg
   and make the graph less than real-time looking. also, looping on j
   regenerates values that already have been computed for m loop
*/
/* keep on this channel if scan one is mode */
        if (0 != scan_one) j = j - 1;

/* capture start breaks out of channel scan */
        if (CAP_NONE != cap_now) break;
    } /* for j */
}


/* loop wrapper for show channels so it can return whenever */
/* static */
void
channel_scan ( void )
{
        cap_chan = scan_list[ scan_pos ];       /* restore channel */
        load_guide(cap_chan, WHO);              /* restore guide */
        show_headers(0);                        /* redraw headers */
        if (test_mode != 0) scan_sig = 0;       /* dummy mode has no sig */

        while (CAP_NONE == cap_now) {
                show_channels();
                nanosleep( &console_read_sleep, NULL);
                if (0 == scan_sig) nanosleep( &signal_sleep, NULL);
        }
        refresh.timers = 1; /* needed? */
}

#define USE_SAMPLE_SH
#ifdef USE_SAMPLE_SH
/* build a script file to run atscap in sample collection mode */
/* find stations calls this if user tells it to call this */
/* static */
void
build_sample_script ( char *location, int s )
{
        FILE *sample_fd = NULL;/* output file descriptor */
        char chs[512];  /* 3 digits plus space for 124 channels */
        char *n = "/usr/local/bin/get-samples.sh";
        int i;
        
/* sanity limit */
        if (s < 1) {
                fprintf( stderr, "\nnothing to write?\n");
                return;
        }
        get_time();             /* sets date_now, minus year and NL */

        sample_fd = fopen( n, "w");
        if (NULL == sample_fd) {
/* TODO: print error for reason why write failed */
                return;
        }

        *chs = 0;       /* asnprintf uses start of channels[] */

        for (i=0; i < scan_idx; i++)
                asnprintf( chs, sizeof(chs), "%3d ", scan_list[i]);

        fprintf( sample_fd,
"#!/bin/sh\n"
"# Generated by atscap -S, %s. You may need to edit this.\n"
"# This script collects ATSC samples from all of your stations.\n"
"# You may edit LOCATION to reflect the nearest big city.\n"
"# You may edit CHANNELS if you adjust for better reception.\n"
"LOCATION=%s\n"
"CHANNELS=\042%s\042\n"
"cd /dtv\n"
"echo atscap >atscap.txt\n"
"tar cf samples-$LOCATION.tar atscap.txt\n"
"for i in $CHANNELS; do\n"
"    echo Collecting samples from channel $i\n"
"    atscap -q -i%d -s%d -o$i.ts $i\n"
"    if [[ -f $i.ts ]]; then\n"
"       atscut -q -m3 -a15 $i.ts >$i-mgt.txt\n"
"       atscut -kmgt $i.ts >/dev/null\n"
"       tar rf samples-$LOCATION.tar $i-mgt.txt $i-mgt.ts\n"
"       rm -f $i-mgt.txt $i-mgt.ts $i.ts\n"
"    fi\n"
"done\n"
"rm -f samples-$LOCATION.tar.bz2\n"
"bzip2 samples-$LOCATION.tar\n"
"echo Email samples-$LOCATION.tar.bz2 to inkling@users.sourceforge.net\n"
"echo The curious may inspect the -mgt.ts files with atscut -a15 -m3.\n"
                , date_now, location, chs, arg_devnum, s );

        fclose( sample_fd );
        chmod( n, 0755 );
}
#endif

/* static */
int
noyes( void )
{
        char key;
        while (1) {
                key = console_getch();
                nanosleep( &console_read_sleep, NULL );
                if (key == 0) continue;
                if (('Y' == key) || ('y' == key)) {
                        fprintf( stderr, "yes\n" );
                        return 1;
                }
                fprintf( stderr, "no\n");
                break;
        }
        return 0;
}

/* station found list, one for each VC not scrambled w/ SD/HD video + audio */
struct sf_s {
    char call[8];
    char sid[4];
    short tsix;
    unsigned int tsid;
    unsigned int pn;
    unsigned int ptc;
    unsigned int hd;
};


/* -S option to scan all frequencies for available digital channels */
/* static */
void
find_stations ( void )
{
        FILE *o;
        int f, i,j, k, m, n;
//      char *ok;
        int sigavg, signum, sigmax;
        struct sig_s *s;
        unsigned char key;
        int ui_save = 0;
        int ui_epg = 0;
        int ui_run = 0;
        int ui_sd = 0;
        int epc; /* error percent */
        struct timespec find_start = {0,0};
        struct timespec find_stop = {0,0};
        struct timespec find_diff = {0,0};

        struct timespec scan_start = {0,0};
        struct timespec scan_stop = {0,0};
        struct timespec scan_diff = {0,0};

        unsigned int atimes[ 128 ];
        unsigned long long atime_avg;
        unsigned int atime_hr;
        time_t atime_av;
        time_t atime_at;
        time_t scan_tnow;

//      char location[16];
//      int seconds = 60;

        int tf;
        struct tsid_s *t;
        int ot;

        memset(atimes, 0, sizeof(atimes));

        ot = tsidx;

/* FIXME: limited by size of ptc[],
        but only seeing 38 unscrambled cable PMTs here with comcast
*/

#define SF_MAX 128
        struct sf_s sf[ SF_MAX ]; /* 128 * 20 */

/* FIXME: have to set different save file name here */
/* because something else calls save config, but shouldn't */
        snprintf( cfg_name, sizeof(cfg_name), "atscap%d.newconf", arg_devnum);

/* want to keep track of how long find stations takes */
        clock_gettime( clock_method, &find_start );

        i = mkdir( cfg_path, 0777 );/* tupari reported this one */

        if ((0 != i) && (EEXIST != errno)) {
            fprintf( stderr, CLS "\n %s Error mkdir %s: %s\n\n",
                 WHO, cfg_path, strerror(errno) );
            console_reset();
            exit(1);
        }

        test_termsize();

        if (in_file < 3) {
            fprintf(stderr, "\n DVB Device not open\n");
            exit(1);
        }


        scan_idx = 0;

        refresh.timers = 0;

#ifndef SHORT_TEST
#define LOC 2
#define HIC ptc_max
#endif

#ifdef SHORT_TEST
#ifdef USE_CABLE
/* ccast uhf hou range */
#define LOC 70
#define HIC 118
#else
/* bcast uhf hou range */
#define LOC 19
#define HIC 39
#endif
#endif

#ifdef USER_TEST
        i = 0;

        scan_list[i++] = 5;
        scan_list[i++] = 9;
        scan_list[i++] = 19;
        scan_list[i++] = 27;
        scan_list[i++] = 31;
        scan_list[i++] = 32;
        scan_list[i++] = 35;
        scan_list[i++] = 36;
        scan_list[i++] = 38;
        scan_list[i++] = 42;
        scan_list[i++] = 44;
        scan_list[i++] = 46;
        scan_list[i++] = 48;
        scan_list[i++] = 52;
        scan_idx = i;
#endif

        dvrlog(LOG_INFO, "%s %s lo-chan %d hi-chan %d \n",
                WHO, (0 == arg_cable) ? "vsb":"qam", LOC, HIC );
        nanosleep(&guide_sleep, NULL);

    if (scan_idx < 1)
    {
        display_stat = 0;
        show_headers(0);
        fprintf( stderr, "\033[1;1H"
                 BW "Looking for intelligent life on %s ... "BN, in_name );

        for (i = LOC; i < HIC; i++)
        {
/* control c check, tupari says it's unstoppable! */
            key = console_getch();
            s = &ptc[i].sig;

/* skip blank frequency list items */
            if (s->freq < 1) continue;

/* preload some values in case nothing found for lookup */
            snprintf( s->sid, sizeof(s->sid)-1, "%03d", i);
            snprintf( s->call, sizeof(s->call)-1, "C%03d", i);
            scan_pos = i;

            fprintf( stderr, SCP );
            show_clock();
            fprintf( stderr, "\033[3;1H");

/* force frequency change */
            scan_freq = 0;

            sigavg = signum = 0;
            sigmax = 9;

/* i2c hardware fix for dvb hd3000 driver means no more CPU pig signal scan */

            for ( j = 0; j < sigmax; j++ ) {

/* control c check, user complained it's unstoppable! */
                key = console_getch();

                scan_sig = ~0;
                get_signal_lock( s );

                show_signal( s, i );
                fprintf( stderr, "\n" );

/* 33% or greater */
                if ((0 != s->lock) && (s->strength > 33)) {
                    sigavg += s->strength;
                    signum++;


                    fprintf( stderr,
                            "\033[1;42H" BW
                            " but only saw TV!" BN );
                    fprintf( stderr, "\033[%d;1H", 3+j );
                }

                if ( (signum > 2) && (0 != s->lock) && (s->strength > 70)) {
                    fprintf( stderr, CCE );
                    break;
                }       
            }

            fprintf( stderr, RCP) ;

/* avoid divide by zero */
            if (signum < 1) signum = 1;
            sigavg /= signum;

/* 33% or greater */
            if (sigavg > 33) {
                scan_list[scan_idx++] = i;
                fprintf(stderr, "\033[16;1HFOUND:");

                for (k = 0; k < scan_idx; k++)
                    fprintf(stderr, " %3d", scan_list[k] );
            } /* else fprintf( stderr, " "); */
        }

/* no reason to keep running, no stations were found */ 
        if (scan_idx < 1) {
            fprintf( stderr, BR "\033[24;1H ... no sign of life.\n" BN );
            close_device( WHO );
            console_reset();
            exit(1);
        }

        fprintf( stderr, "\033[1;42H" BW " but only saw TV!" BN );
        fprintf( stderr, "\033[2;1H\033[J" );

    }
        fprintf( stderr,
                    "\nLCN PTC Status Time TSID Callsign "
                    "Signal%% Error%% Errors Packets NULLs\n");

        f = 0;
        m = 0;

        get_time();
        scan_tnow = tnow;

        clock_gettime( clock_method, &scan_start );

        for (i=0; i < scan_idx; i++) {
            if (f >= SF_MAX) {
                console_reset();
                fprintf( stderr, BW "\n\n\n recompile with larger SF_MAX\n");
                exit(1);
                break;
            }

            key = console_getch();      /* control c check, user complaint */
            s = &ptc[scan_list[i]].sig;
            get_time();
            fprintf( stderr, "%3d %3d",
                        i, scan_list[i] );

            memset( chan_name, 0, sizeof(chan_name) );
            scan_pos = i;
            cap_chan = scan_list[i];
            pgm.chan = cap_chan;

            arg_capture = 3;

            fprintf( stderr, " stream");

            /* silence */
            arg_quiet = ~0;

            display_stat = 0;
            atsc_stt = 0;

/* make sure channel gets set */
/* scan_freq = 0; */

            cap_now = CAP_INFO;
            ts_capture();

/* TESTME: needed? */
            while (0 != (pid_o | pid_i)) {
//              char b;
                nanosleep(&console_read_sleep, NULL);
//              b = console_getch();
            }

            utsets &= 7;

/* Thanks to Peter Knaggs for finding this divide by zero crash. */
            if (0 == utsets) utsets = 1;

            /* ok to yammer now */
            arg_quiet = 0;
            aprintf( stderr, " %3ds", utsets);

            epc = pkt.errors * 100;

            if (0 == pkt.count) pkt.count = 1; /* avoid /0 */
            epc /= pkt.count;

            if (epc > 99) epc = 100;

/* name is blank? */
            if (0 == arg_cable) {
                if (0 == *chan_name ) {
                    fprintf( stderr, "NO CALLSIGN FOUND\n");
                } else {
                    /* name isn't blank */
                    snprintf( s->call, 8, "%s", chan_name);
                    snprintf( s->sid, 4, "D%02d", s->major);
                    fprintf( stderr, " %04X %-8s    %3d%%   %3d%% %6d %7d %7d",
                        vc[0].tsid, s->call, s->strength, epc, pkt.errors,
                        pkt.count, pkt.null );
                }
            }
            fprintf( stderr, "\n");

/***************************************************** ATSC Terrestrial */
            if (0 == arg_cable) {
                n = 0;
                for (j = 0; j < vc_ncs; j++) {

                    if (0 == vc[j].pn) continue;
                    if (0xFFFF == vc[j].pn) continue;

//                  fprintf( stderr, "%s %02d.%d %s %s\n", WHO, s->ptc, vc[j].pn, vc[j].name, vc[j].cname);
//                  continue;

                    sf[f].ptc = s->chan;
                    sf[f].pn = vc[j].pn;
                    sf[f].hd = 0;
                    sf[f].tsid = vc[j].tsid;
                    tf = find_tsidx( sf[f].tsid, sf[f].pn, WHO );

/* add to tsid list if not already there.
  callsign is TS-TSID if no vc name found. sid is pgm # */
                    if (tf < 0) {
                        t = &tsids[tsidx];
                        t->tsid = sf[f].tsid;
                        t->ptc = s->chan;    
                        t->pn = sf[f].pn;

                        *t->call = 0;

/* user may still have to edit callsign & sid in the config file */
                        if (0 == *t->call)
                            snprintf(t->call, 8, "%s", vc[j].name);

                        if (0 == *t->call)
                            snprintf(t->call, 8, "%s", vc[j].cname);

/* fall back to tsid for callsign if no VCT or Component Name */
                        if (0 == *t->call)
                            snprintf(t->call, 8, "TS-%04X", t->tsid);

                        tsidx++;
                        if (tsidx >= TSID_MAX) break;
                    }
                    sf[f].tsix = find_tsidx( sf[f].tsid, sf[f].pn, WHO );
                
                    fprintf( stderr, "%7s Pgm # %5d %04X ",
                            "", vc[j].pn, vc[j].tsid );

                    if (sf[f].tsix >= 0) {
                            t = &tsids[ sf[f].tsix ];
                            fprintf( stderr, "%-7s %-3s", t->call, t->sid);
                    } else {
                            fprintf( stderr, "%-7s %-3s", s->call, s->sid );
                    }
                    fprintf( stderr, " ES# %d:", vc[j].vctes);

/* only check first two ES in each program map entry */
//                  for (k = 0; k < vc[j].vctes; k++)
                    for (k = 0; k < 2; k++)
                    {
                        char dr[16];

                        if (2 == vc[j].estype[k]) {

                            if (vc[j].hres > 1000) sf[f].hd = 1;
                            
                            snprintf(dr, sizeof(dr), " %cD @ %dx%d",
                                        (1==sf[f].hd)?'H':'S',
                                        vc[j].hres, vc[j].vres);

                            fprintf(stderr, "%-15s", dr);

                        }
#ifdef USE_NUMERIC_ES
                        fprintf( stderr, " %02X #%5d",
                                vc[j].estype[k], pids[ vc[j].espid[k] ] );
#else
                        if (0x81 == vc[j].estype[k]) {
                            fprintf( stderr, " AC3");

/* langcode moved inside audio. video has langcode too but not used much */
                            if (0 != *vc[j].eslang[k])
                                if (' ' != *vc[j].eslang[k])
                                    fprintf( stderr, "-%s", vc[j].eslang[k]);
                        }

                        if (0 == pids[vc[j].espid[k]]) {
                                fprintf( stderr, " NONE");
                        } else {
                                fprintf( stderr, " %02d%%",
                                    (100 * pids[ vc[j].espid[k] ])/pkt.count);
                        }
#endif
                    }

                    n++;
                    f++;
                    fprintf(stderr, "\n");
                }
            } else {
                n = 0;

/********************************* Cable, only PAT + PMT to work with */

                for (j = 0; j < pat_ncs; j++) {

/* bogus or missing program # */
                    if (0 == pa[j].pn) continue;
                    if (0xFFFF == pa[j].pn) continue;
/* scrambled */
                    if (0 != pa[j].ca) continue;
/* no video ES */
                    if (2 != pa[j].estype[0]) continue;
/* fewer than 2 ES */
                    if (pa[j].pmtes < 2) continue;

/* video ES has bandwidth too small to be SD */
                    if (2 == pa[j].estype[0])
                        if (pids[ pa[j].espid[0] ] < 500) continue;

                    sf[f].ptc = s->chan;
                    sf[f].pn = pa[j].pn;
                    sf[f].hd = 0;
                    sf[f].tsid = pa[j].tsid;
                    tf = find_tsidx( sf[f].tsid, sf[f].pn, WHO );

/* add to tsid list if not already there, 
    callsign is TSID if no vc name found. sid is ptc # */
                    if (tf < 0) {
                        t = &tsids[tsidx];
                        t->tsid = sf[f].tsid;
                        t->ptc = s->chan;    
                        snprintf( t->sid, 4, "%03d", t->ptc);
                        t->pn = sf[f].pn;

                        *t->call = 0;
/* user may still have to edit callsign & sid in the config file */
                        if (0 == *t->call)
                            snprintf(t->call, 8, "%s", vc[j].name);

                        if (0 == *t->call)
                            snprintf(t->call, 8, "%s", vc[j].cname);

/* fall back to tsid for callsign if no VCT or Component Name */
                        if (0 == *t->call)
                            snprintf(t->call, 8, "TS-%04X", t->tsid);

                        tsidx++;
                        if (tsidx >= TSID_MAX) {
                                fprintf(stderr, "\nTSID_MAX exceeded\n");
                                break;
                        }
                    }

                    tf  = find_tsidx( sf[f].tsid, sf[f].pn, WHO );
                    if (tf < 0) break;

                    sf[f].tsix = tf;
                    
                    fprintf( stderr, "%7s Pgm # %5d %04X ",
                             "", pa[j].pn, pa[j].tsid );

                    t = &tsids[ tf ];
                    fprintf( stderr, "%-7s %-3s", t->call, t->sid);

/* don't need to see this on the listing */
                    fprintf( stderr, " ES# %d:", pa[j].pmtes);

/* one video, one audio */
                    for (k = 0; k < 2; k++)
                    {
                        if (2 == pa[j].estype[k]) {
                            char dr[16];
                            if (pa[j].hres > 1000)  sf[f].hd = 1;
                            snprintf( dr, sizeof(dr), " %cD @ %dx%d",
                                        (0==sf[f].hd)?'S':'H',
                                        pa[j].hres, pa[j].vres);
                            fprintf( stderr, "%-15s", dr);
                        }

#ifdef USE_NUMERIC_ES
                        fprintf( stderr, " %02X #%5d",
                                pa[j].estype[k], pids[ pa[j].espid[k] ] );
#else
                        if (0x81 == pa[j].estype[k]) {
                            fprintf( stderr, " AC3");

/* langcode moved inside audio. video has langcode too but not used much */
                            if (0 != *pa[j].eslang[k])
                                if (' ' != *pa[j].eslang[k])
                                    fprintf( stderr, "-%s", pa[j].eslang[k]);

                        }
                        if ( 0 == pids[pa[j].espid[k]] ) {
                            fprintf( stderr, " NONE");
                        } else {
                            fprintf( stderr, " %02d%%",
                                (100 * pids[ pa[j].espid[k] ])/pkt.count);
                        }
#endif
                    }

                    n++;
                    f++;
                    fprintf( stderr, "\n");
                }
            }

            fprintf( stderr, "\n");
            m += n;

            if (0 != atsc_stt)
                    aprintf( stderr, "ATSC time for LCN %d PTC %d is %ld %s\n",
                            i, scan_list[i], atsc_stt, ctime( &atsc_stt ) );

/* store the time if it is non-zero, adjusted for 3s capture time per loop */
            if (0 != atsc_stt) atimes[i] = atsc_stt - (i * 3);

/* end of scan_idx */
        }       

        clock_gettime( clock_method, &scan_stop );
        time_diff( &scan_diff, &scan_start, &scan_stop );

        clock_gettime( clock_method, &find_stop );
        time_diff( &find_diff, &find_start, &find_stop );

        if (NULL == getenv("TZ"))
                fprintf(stderr, "No TZ environment variable set.  "
                                "See man page tzselect(8).\n");
        j = 0;
        atime_avg = 0LL;
        for (i = 0; i < 128; i++) {
                if (atimes[i] < 1) continue;
                j++;
                atime_avg += atimes[i];
        }

        if (0 == j) j = 1;
        atime_avg /= j;

/*  At the end of the station cap loop, even with good local ATSC STT averages
    computed from good data samples adjusted to the start of cap loop, it will
    now be at least scan_diff behind the current time. The point will be moot
    if the stations are very far out of time sync they will ruin the averaging.
    More processing will be needed to throw out the obvious bogus values.
*/
        atime_avg &= 0xFFFFFFFF;
        atime_av = atime_at = atime_hr = atime_avg;

/* force to nearest hour */
        if (atime_hr > 0) {
                atime_hr /= SECHR;
                atime_hr *= SECHR;
        }

        fprintf( stderr, "Scan loop started  %ld %s",
                    scan_tnow, ctime(&scan_tnow) );

        fprintf( stderr, "ATSC Average time  %ld %s",
                    atime_av, ctime(&atime_av) );

        atime_at += scan_diff.tv_sec;
        fprintf( stderr, "ATSC Average +%3lds %ld %s",
                    scan_diff.tv_sec, atime_at, ctime(&atime_at) );

        get_time();
        fprintf( stderr, "Local Current time %ld %s\n",
                    tnow, ctime(&tnow) );
        
/* maybe rename this to USE_LIVE_CD_ATSC_STT_PLUS_NTP */
#ifdef USE_ATSC_NTP
        if (0 != euid) {
            fprintf(stderr, "Only root can set system time.\n");
        } else {
            char *nt;
            struct timeval atime_tv;

/* compute average of reported ATSC STTs and truncate to nearest hour */

/* get ntp time for seconds.
    if supervisor, correct hours with ATSC average then add NTP seconds
    if user, tell user to set the TZ variable!
*/
//          nt = "ntpdate pool.ntp.org &>/dev/null";
            nt = "ntpdate pool.ntp.org";
            k = system( nt );
            if (0 == k) {
                get_time();
            } else {
                fprintf(stderr, "Can't set NTP time via \042%s\042\n", nt);
                fprintf(stderr, "Falling back to ATSC average time\n");
                atime_hr = atime_av;
            }
            memset(&atime_tv, 0, sizeof(atime_tv));

            atime_tv.tv_sec = atime_hr;

            if (0 == k) {
                atime_tv.tv_sec += (tnow % 3600);
                fprintf( stderr, "ATSC Hour + NTP seconds is %ld %s",
                    atime_tv.tv_sec, ctime(&atime_tv.tv_sec) );
            }
            settimeofday( &atime_tv, NULL );
        }
#endif
        fprintf( stdout, "\nFound %d VCs in %d PTCs in %ld.%09ld seconds.\n\n", 
                m, scan_idx, find_diff.tv_sec, find_diff.tv_nsec);

        *out_name = 0;

#ifdef USER_TEST
        show_mem_use();
        console_reset();
        exit(0);
#endif
/* ask user to save config */
        fprintf( stderr, "\nSave configuration" BW " (y/n)? " BN );
        ui_save = noyes();
        if (0 == ui_save) {
                console_reset();
                exit(0);
        }

/* ask user to save config */
        fprintf( stderr,"\nEnable auto EPG for all stations" BW " (y/n)? " BN);
        ui_epg = noyes();

/* most users will want the HD stations only */
        fprintf( stderr, "\nKeep non-HDTV stations" BW " (y/n)? " BN );
        ui_sd = noyes();

        chdir(cfg_path);
        snprintf(cfg_name, sizeof(cfg_name), "atscap%d.conf", arg_devnum);
        o = fopen(cfg_name, "w");
        if (NULL == o) {
            fprintf(stderr, CLS "Can not open %s for write.\n", cfg_name);
            console_exit(1);
        }

        fprintf( o, "# This file will be over-written after startup\n" );
        fprintf( o, "F%d\n", arg_frtable);

/* populate HD detected stations first with TSID list info */
        j = 0;
        for (i = 0; i < m; i++) {
                if (0 == sf[i].hd) continue;

                tf = find_tsidx( sf[i].tsid, sf[i].pn, WHO );
                if (tf < 0) break;

                t = &tsids[ tf ];
                fprintf( o, "C%03d", t->ptc );

                if (0 == *t->call)
                        snprintf( t->call, 8, "TS-%04X", 0xFFFF & t->tsid);
                fprintf( o, ":%s", t->call );

                if (0 == *t->sid) {
                        snprintf( t->sid, 4, "%03d", t->ptc);
                        t->sid[3] = 0;
                }
                fprintf( o, ":%s", t->sid );
                fprintf( o, ":%d:%u:0", ui_epg, t->pn );
                fprintf( o, " # HD\n" );
                j++;
        }


/* populate SD if user wants to keep them */
        if (0 != ui_sd) {
            for (i = 0; i < m; i++) {
                if (0 != sf[i].hd) continue;

                tf = find_tsidx( sf[i].tsid, sf[i].pn, WHO );
                if (tf < 0) break;

                t = &tsids[ tf ];
                fprintf( o, "C%03d", t->ptc );

                if (0 == *t->call)
                        snprintf( t->call, 8, "TS-%04X", 0xFFFF & t->tsid);
                fprintf( o, ":%s", t->call );

                if (0 == *t->sid) {
                        snprintf( t->sid, 4, "%03d", t->ptc);
                        t->sid[3] = 0;
                }
                fprintf( o, ":%s", t->sid );
                fprintf( o, ":%d:%u:0",  ui_epg, t->pn );
                fprintf( o, " # SD\n" );
                j++;

            }
        }
        fprintf( o, "\n" );

        fflush(o);
        fclose(o);

        save_tsids();

/* user can stop it after save config to inspect the result */
        fprintf( stderr, "\nRun %s now " BW "(y/n)? " BN, NAME );
        ui_run = noyes();
        if (0 == ui_run) {
                close_device( WHO );
                console_reset();
                exit(0);
        }

/* console exit is not needed anymore? */
        arg_scan = 0;
        arg_capture = 0;
        *out_name = 0;
        return;
}



/* static */
void
usage ( void )
{
        fprintf( stdout, "%s-%s %s %s\n", NAME, VERSION, COPYRIGHT, EMAIL);
        fprintf( stdout, "This code is released under the %s Version 2\n", LICENSE);
        fprintf( stdout, "New versions may be found here:  %s\n\n", WEBPAGE);
        fprintf( stdout, "%s", usehelp);
        fprintf( stdout, "%s", usehelpx);
        fprintf( stdout, "\nThe following keys are defined for console mode:\n\n");
        fprintf( stdout, "%s\n", keyhelp);
        fprintf( stdout, "%s", usehelpshort);
        exit(0);
}

#ifdef USE_MCAST
/* -u 224-239.x.x.x:1-65535
 bogus ip or port 0 disables multicast */
/* static */
int
parse_arg_mcast ( char *a )
{
    int ok;
    char m[32];
    char *t;
    unsigned int s, p;
    struct in_addr mc_addr;

    memset( arg_mcaddr, 0, sizeof(arg_mcaddr) );
    arg_mcport = 0;

    astrncpy( m, a, sizeof(m) );
    t = strrchr( m, ':');
    if (NULL == t) {
        dvrlog( LOG_INFO, "MCAST UDP port missing" );
        return -1;
    }
    *t = 0;
    t++;
    p = atoi( t );
    if ( (p < 1) || (p > 65535) ) {
        dvrlog( LOG_INFO, "MCAST UDP port invalid");    
        return -1;
    }
    if (strlen(m) > 15) {
        dvrlog( LOG_INFO, "MCAST IP address too long");
        return -1;
    }
    t = strchr( m, '.' );
    if (NULL == t) {
        dvrlog( LOG_INFO, "MCAST IP address bad format");
        return -1;
    }
    *t = 0;
    s = atoi( m );
    if ( (s < 224) || (s>239) ) {
        dvrlog( LOG_INFO, "MCAST IP adddress error");
        return -1;
    }
    *t = '.';

    /* overkill? */
    ok = inet_aton( m, (struct in_addr *)&mc_addr );
    if (0 == ok) {
        dvrlog( LOG_INFO, "MCAST IP address bad");
        return -1;
    }

    /* considered ok if gets to here */
    astrncpy( arg_mcaddr, m, sizeof(arg_mcaddr) );
    arg_mcport = p;
    return 0;
}

#endif


#if USE_DST_CHECK
/* This is a quick check of the new DST rules */
void
tz_check( void )
{
        int i,j;
        get_time();
        j = utsnow;
        j /= 3600;
        j *= 3600;

        for (i = j; i < j + (35 * 86400); i += 3600 ) {
                memcpy( &tloc1, localtime( (time_t *)&i ), sizeof( tloc1 ) );
                fprintf( stdout, "localtime isdst %d %s",
                        tloc1.tm_isdst, ctime( (time_t *)&i ) );
        }
        exit(0);
}
#endif


#ifdef USE_PARSE_ENV
/* These are parsed before parse args to set defaults. CLI will override */
/* DTV_ prefix:
        PATH out_path
        HOST arg_whost
        MASK arg_wmask
        PORT arg_wport
        SORT idx_sort
 */
/* static */
void
parse_envars ( void )
{
        char *p;
        p = getenv("DVR_PATH");
        if (NULL != p) {
                strncpy( out_path, p, sizeof(out_path));
        }
        p = getenv("DVR_HOST");
        if (NULL != p) {
                strncpy( arg_whost, p, sizeof(arg_whost));
        }

        p = getenv("DVR_PORT");
        if (NULL != p) {
                arg_wport = 0xFFFF & atoi(p);
        }

        p = getenv("DVR_SORT");
        if (NULL != p) {
                idx_sort = 0xF & atoi(p);
        }

/* TODO: unicast UDP */
        p = getenv("DVR_UUDP");
        if (NULL != p) {
        }

/* TODO: multicast UDP */
        p = getenv("DVR_MUDP");
        if (NULL != p) {
        }

/* TODO: FIFO size, faster machines can reduce alloc? */
        p = getenv("DVR_FIFO");
        if (NULL != p) {
        }
}
#endif


/* verify luser has access to things it will use. called by end of parse args
*/
/* static */
void
test_luser ( void )
{
        struct statfs ds;
        struct stat fs;
        FILE *f;

        char *d;
        char *e = "";
        char r[256];            /* name of resource that failed */
        char *n = r;
        int ok, z;

/* -R re-attach doesn't need any checks done except screen access */
        if ( (0 != arg_screen) && (0 != arg_sattach) ) return;


        aprintf(stderr, CLS BN "Checking access rights...\n");

        ok = 0;
        z = sizeof(r) - 1;

        memset(r, 0, z);

        while(1) {
        

/* if not dummy or test, do device check to see if it exists */
                if ((0 == arg_dummy) && (0 == test_mode)) {

/* DVB device names */
/* new udev format is dvb0.dvr0 */

                        ok = test_var_procpid(arg_devnum, 1);
                        if (0 != ok) {
                                snprintf(r, z, "%s%d", NAME, arg_devnum);
                                e = "instance already running";
                                break;
                        }

                        d = "/dev/dvb%d.%s";
                        n = fe_name;

                        snprintf(fe_name, sizeof(fe_name)-1,
                                    d, arg_devnum, "frontend0" );
                        ok = stat(fe_name, &fs);

/* try old udev format /dev/dvb/adapter0/frontend0 if new format failed */
                        if (0 != ok) {
                                d = "/dev/dvb/adapter%d/%s";
                                aprintf( stderr, "failed %s\n", n);
                                snprintf(fe_name, sizeof(fe_name)-1,
                                                d, arg_devnum, "frontend0" );

                                ok = stat( fe_name, &fs );
                                if (ok < 0) {
                                    e = "device doesn't exist";
                                    break;
                                }
                        }

                        aprintf( stderr, "found %s\n", fe_name);


                        snprintf( dmx_name, sizeof(dmx_name),
                                    d, arg_devnum, "demux0" );
                        snprintf( dvr_name, sizeof(dvr_name),
                                    d, arg_devnum, "dvr0" );
                        snprintf( in_name,  sizeof(in_name),
                                    d, arg_devnum, "dvr0" );

                        ok = open(fe_name, O_RDWR);
                        aprintf( stderr, "open %d %s\n", ok, fe_name);
                        if (ok < 3) {
                                n = fe_name;
                                e = "device in use";
                                break;
                        }
                        close(ok);

                        ok = open(dmx_name, O_RDWR);
                        aprintf( stderr, "open %d %s\n", ok, dmx_name);
                        if (ok < 3) {
                                n = dmx_name;
                                e = "device in use";
                                break;
                        }
                        close(ok);

                        ok = open(dvr_name, O_RDONLY);
                        aprintf( stderr, "open %d %s\n", ok, dvr_name);
                        if (ok < 3) {
                                n = dvr_name;
                                e = "device in use";
                                break;
                        }
                        close(ok);
                        aprintf( stderr, "using dvb%d\n", arg_devnum);

                        /* TODO: add file permission check here for -r mode:
                                in_name O_RDONLY
                        */

#ifdef USE_DEVOCHK
// abbreviated check, device name setup only
                        ok = 0;
                        e = "";
                        break;
#endif
                }

                n = r;

/* check for /etc/atscap/ directory writable */
                snprintf( r, z, "/etc/%s/%s%d.chk", NAME, NAME, arg_devnum);
                f = fopen(r, "w");
                if (NULL == f) { ok = -1; e = "can't write"; break; }
                fclose(f);
                ok = remove( r );
                if (ok < 0) { e = "can't delete"; break; }

/* create /var/run/atscap if needed
   TESTME: does it ever get to here?
*/
                snprintf( r, z, "/var/run/%s", NAME);
                ok = statfs( r, &ds );
                if (ok < 0) {
                        ok = mkdir( r, 0777 );
                        if (ok < 0) { e = "mkdir"; break; }
                }
                aprintf( stderr, "vardir exists %s\n", r);

/* check for /var/run/atscap/ directory writable */
                snprintf( r, z, "/var/run/%s/%s%d.chk", NAME, NAME, arg_devnum);
                f = fopen(r, "w");
                if (NULL == f) { ok = -1; e = "can't write"; break; }
                fclose(f);
                ok = remove( r );
                if (ok < 0) { e = "can't delete"; break; }

/* check for out path and out path + cut */
                snprintf( r, z, "%s", out_path);
                ok = statfs( r, &ds );
                if (ok < 0) {
                        ok = mkdir( r, 0777 );
                        if (ok < 0) { e = "mkdir"; break; }
                }
                aprintf( stderr, "capdir exists %s\n", r);

/* capture and cut directory check */
                snprintf( r, z, "%s%s%d.chk", out_path, NAME, arg_devnum);
                f = fopen( r, "w");
                if (NULL == f) { ok = -1; e = "write"; break; }
                fclose(f);
                ok = remove( r );
                if (ok < 0) { e = "delete"; break; }
                aprintf( stderr, "capdir rwd %s\n", r);

#ifdef USE_WWW
/* cap index won't generate unless cap index.html exists */
                snprintf( r, z, "%sindex.html", out_path);
                f = fopen( r, "w");
                if (NULL == f) { ok = -1; e = "write"; break; }
                fclose(f);
#endif

/* XFS_SUPER_MAGIC       0x58465342 */
//              if (ds.f_type != XFS_SUPER_MAGIC) {
                if (ds.f_type != 0x58465342) {
                        aprintf( stderr, "XFS handles capturing files better.\n" );
                }

                snprintf( r, z, "%spg", out_path);
                ok = statfs( r, &ds );
                if (ok < 0) {
                        ok = mkdir( r, 0777 );
                        if (ok < 0) { e = "root needs to: mkdir"; break; }
                }
                aprintf( stderr, "epgdir exists %s\n", r);

                snprintf( r, z, "%spg/img", out_path);
                ok = statfs( r, &ds );
                if (ok < 0) {
                        ok = mkdir( r, 0777 );
                        if (ok < 0) { e = "root needs to: mkdir"; break; }
                }
                aprintf( stderr, "imgdir exists %s\n", r);


                snprintf( r, z, "%scut", out_path);
                ok = statfs( r, &ds );
                if (ok < 0) {
                        ok = mkdir( r, 0777 );
                        if (ok < 0) { e = "root needs to: mkdir"; break; }
                }
                aprintf( stderr, "cutdir exists %s\n", r);

#ifdef USE_WWW
/* cut index won't generate unless cut index.html exists */
                snprintf( r, z, "%scut/index.html", out_path);
                f = fopen( r, "w");
                if (NULL == f) { ok = -1; e = "write"; break; }
                fclose(f);
#endif

/* XFS_SUPER_MAGIC       0x58465342 */
//              if (ds.f_type != XFS_SUPER_MAGIC) {
                if (ds.f_type != 0x58465342) {
                        aprintf( stderr, "XFS handles cutting files better.\n" );
                }

                snprintf( r, z, "%scut/%s%d.chk", out_path, NAME, arg_devnum);
                f = fopen( n, "w");
                if (NULL == f) { ok = -1; e = "write"; break; }
                fclose(f);

                ok = remove( r );
                if (ok < 0) { e = "delete"; break; }
                aprintf( stderr, "cutdir rwd %s\n", r);

                snprintf( r, z, "%s%s%d.chk", cfg_path, NAME, arg_devnum);
                f = fopen( n, "w");
                if (NULL == f) { ok = -1; e = "write"; break; }
                fclose(f);

                ok = remove( r );
                if (ok < 0) { e = "delete"; break; }
                aprintf( stderr, "cfgdir rwd %s\n", r);

/* if -E option check for existence of ram directory and try writing to it */
                if (0 != arg_tmpfs) {
                        snprintf( r, z, "%s%s", out_path, ram_path);
                        ok = statfs( n, &ds );
                        if (ok < 0)
                            { e = "tmpfs has no mount point at"; break; }
                        aprintf( stderr, "ramdir exists %s\n", r);

/* TMPFS_MAGIC           0x01021994 */
//                      if (ds.f_type != TMPFS_MAGIC)
                        if (ds.f_type != 0x01021994)
                            { ok = -1; e = "tmpfs not mounted at"; break;}

/* is it usable? */
                        snprintf( r, z, "%s%s%s%d.chk",
                                 out_path, ram_path, NAME, arg_devnum);

                        f = fopen( r, "w");
                        if (NULL == f)
                            { ok = -1; e = "can't write"; break; }

                        fclose(f);

                        ok = remove( r );
                        if (ok < 0)
                            { e = "can't delete"; break; }

                        aprintf( stderr, "tmpdir rwd %s\n", r);
                }

/* www port check */
                if (0 != arg_www) {
                        if ((0 != euid) && (arg_wport < 1024)) {
                                ok = -1;
                                e = "TCP port must be > 1023 for luser";
                                n = "";
                                aprintf( stderr, "TCP port BAD %d\n", arg_wport);
                                break;
                        }
                        aprintf( stderr, "TCP port %d OK\n", arg_wport);
                }

                ok = 0;

                break; /* one time through */
        }

        if (0 != uid) {
                aprintf( stderr, "User mode may require renicing!\n");
                nanosleep( &msg_long_sleep, NULL );
        }
        if (0 != ok) {
                aprintf( stderr, "Please correct this error:\n");
                aprintf( stderr, "%s %s", e, n );

/* keep onscreen for a while in case -W screen mode */
                nanosleep( &msg_longer_sleep, NULL);
                aprintf( stderr, "exiting %s\n\n", NAME);
                exit(1);
        }

        aprintf( stderr, "Everything seems OK\n");

#ifndef USER_TEST
        if (0 != euid)
            nanosleep( &msg_longer_sleep, NULL );
#endif

        aprintf( stderr, CLS );
}


/* getopt blech */
/* static */
void
parse_args ( int argc, char ** argv)
{
        int c;
        int chan;
        char *t;

        c = 0;
        astrncpy( arg_name, argv[0], sizeof(arg_name) );

#ifdef USE_PARSE_ENV
        parse_envars();
#endif


        while ( (c = getopt( argc, argv,
                    "ADENRSWadehklmnqtvxc:i:o:p:r:s:u:z:w:F:U:") )
             != EOF )

        switch(c) {

/* ATSC strict mode */
        case 'A':
                arg_strict = ~0;
                break;

/* start session detached with screen */
        case 'D':
                arg_sdetach = ~0;
                arg_screen = ~0; /* -D implies -W */
                break;

/* Energy Saver mode uses RAM for EPG/config/log so HDD can auto-spindown.
   Compile with USE_POWERDOWN defined and it will also close the device.
   You'll need something like hdparm -S5 to tell the drive to auto-spindown,
    see man hdparm for other -S settings.
*/
        case 'E':
                snprintf( ram_path, sizeof(ram_path), "%s", "ram/");
                arg_tmpfs = ~0;

/* FIXME: test arg tmpfs after option loop so outpath/rampath can be logged */
#ifdef USE_POWERDOWN
                dvrlog( LOG_INFO, "energy saver closes dvb at %ds idle",
                        USE_POWERDELAY );
#else
                dvrlog( LOG_INFO, "tmpfs only. Recompile with USE_POWERDOWN");
#endif
                break;


/* toggle boiler-plate default. defaut is on to pause 3s */
/* NOTE: it needs at least 3 seconds to load microccode */
        case 'N':
                arg_nosplash = ~arg_nosplash;
                break;

/* attach a previously running screen session */
        case 'R':
                arg_sattach = ~0;
                arg_screen = ~0; /* -R implies -W */
                break;

/* Station scan and config file build */
/* TODO? could use this to set how long to scan each channel */
        case 'S':
                arg_scan = ~0;
                break;

/* frequency table select */
        case 'F':
                if (NULL != optarg) {
                    arg_frtable = atoi( optarg );
                    if (arg_frtable > 0) arg_cable = ~0;
                }
                break;

/* user:group */
        case 'U':
                if (NULL != optarg) {
                    arg_setuid = atoi(optarg);
                    t = strchr(optarg, ':');
                    if (NULL != t) {
                        t++;
                        arg_setgid = atoi(t);
                    }
                }
                break;

/*  use screen */
        case 'W':
                arg_screen = ~0;
                break;

/* keep nulls for hardware players */
        case 'n':
                arg_nulls = ~0;
                break;

        case 'u':

#ifdef USE_MCAST
/* FIXME: needs device from parse arg mcast */
                if (NULL != optarg) {
                    if (0 == parse_arg_mcast( optarg ) ) {
                        udp_mcast = ~0;
                        system( "route add -net 224.0.0.0 "
                                "netmask 240.0.0.0 dev eth0");
                    }
                }
#else
                fprintf( stderr, CLS "Recompile with USE_MCAST\n");
                exit(1);
#endif
                break;

/* count packets for each frame type and keep track of sequence
       start offsets [renumber GOP too?] then:
            write frame data to to .tsf file
            write sequence offsets to .tss file
*/
        case 'm':
                arg_frames = ~0;
                break;          

/* errors enumerated, increases size of atscap[0-3].log files */
                case 'e':
                arg_edetail = ~arg_edetail;
                break;

/* version only */
        case 'v':
                fprintf( stdout, "%s%s", HOM, CCE );
                fprintf( stdout, "%s%s", welcome, BN );
                fprintf( stdout, "%s%s", boilerplate, BN );
                show_mem_use();
                exit(0); /* version boiler-plate etc and stop */
                break;

/* built-in help */
        case 'h':
                usage();
                break;

/* TARD mode (Test And Replay Demo) */
        case 'r':
                test_mode = ~0;
                arg_dummy = ~0;
                if (NULL != optarg) {
                /*
                 getopt was broken last time tried r:: for optional
                 if you don't supply this parameter, in_name doesn't change.
                 dummy mode comes up reading /dev/dtv0 but no output
                */
                    snprintf( in_name, sizeof(in_name)-1, "%s", optarg);
                    snprintf( out_name, sizeof(out_name)-1, "%s", optarg);
                    snprintf( arg_dummyn, sizeof(arg_dummyn)-1, "%s", optarg);
                }
                break;

/* -a uses AOS check before capture, otherwise pretends AOS always passes */
        case 'a':
                arg_aos = ~0;
                break;

/* FIXME: use QoS overall percentage
    zap file if this percentage of error seconds crossed */
        case 'z':
                arg_zapper = 0;
                if (NULL != optarg) {
                    arg_zapper = atoi( optarg );
                    if ( (arg_zapper < 0) || (arg_zapper > 100) )
                        arg_zapper = 99; /* sanity limit */
                }
                break;

/* capture for n seconds */
        case 's':
                fprintf(stdout,
                        "-s is deprecated and no longer supported.\n");
                exit(1);
#if 0
                arg_capture = 0;
                sscanf( optarg, "%d", &arg_capture);
                /* arbitrary 4 hour limit on capture */
                if ( (arg_capture < 0) || (arg_capture > 14400) )
                        arg_capture = 0;
#endif
                break;

/* input device -i0...3 or /dev/dtv0...3 */
        case 'i':
                arg_device = optarg;
                arg_devnum = 0;

                if ( arg_device != NULL ) arg_devnum = atoi( arg_device );
                break;

/* output file */
        case 'o':
                arg_ofile = optarg;
                if (NULL != arg_ofile)
                    astrncpy( out_name, optarg, sizeof(out_name) );
                break;

/* output path */
        case 'p':
                arg_opath = optarg;

                if (NULL == arg_opath) break;
                if (strlen(arg_opath) > 1) {
                        char *p;
/* copy dir */
                        strncpy( out_path, arg_opath, sizeof(out_path));
                        p = out_path + (strlen(out_path)-1);

/* add / to end if missing */
                        if ('/' != *p++) {
                                *p++ = '/';
                                *p = 0;
                        }

/* www and log needs copy too */
                        strncpy( log_path,  out_path, sizeof(log_path));
                        strncpy( arg_wroot, out_path, sizeof(arg_wroot));
                }
                break;

/* config file path */
        case 'c':
                arg_cpath = optarg;
                if (NULL != arg_cpath)
                    snprintf( cfg_path, sizeof(cfg_path)-1, "%s%s", arg_cpath,
                            ( strrchr(arg_cpath, '/') == NULL) ? "/":"" );
                break;

/* toggles for compiled defaults */

/* filesystem ext2 delete time computation toggle */
        case 'f':
                arg_fastfs = ~arg_fastfs;
                break;

/* DEBUG parse weekday timers:
        no timers loaded from cfg at startup
        IT WILL ERASE EXISTING TIMERS SO BEEWARY
*/
        case 't':
                arg_notimers = ~arg_notimers;
                break;

/* klutz mode, stop fingers from stopping program */
        case 'k':
                arg_nokb = ~arg_nokb;
                break;

/* HD2000 LED sense for V4L ATSC using my customized pcHDTV driver 1.07 */
/* also, read signal strength value during capture */
        case 'x':
                arg_extras = ~arg_extras;
                break;

/* verbose logging */
        case 'l':
                arg_log = ~arg_log;
                break;

/* no stdio */
        case 'd':
                arg_detach = ~arg_detach;
                scan_sig = 0; /* user request: -d does not scan */
                break;

/* quiet mode, no output, but input is allowed, for [q]uit key */
        case 'q':
                arg_quiet = ~arg_quiet;
                break;

        case 'w':
#ifdef USE_WWW
                if (NULL != optarg) {
                    parse_www_bind( optarg );
                    arg_www = ~0;
                }
#else
                fprintf( stderr, CLS "Recompile with USE_WWW.\n\n");
                exit(1);
#endif

                break;



/* end of toggles for compiled defaults */

                default:
                break;
        }           

/* now that all the args are loaded, it's time to check a few things */

        snprintf( cfg_name, sizeof(cfg_name)-1, "%s%d.conf", NAME, arg_devnum );

/* override arg_vapi based on available types
 2.6.12 has DVB and ATSC support, but
 prior to that is ATSC via V4Lx only
*/
    
/* last arg(s) used to be channel numbers to put in scan_list,
        but now last arg is channel to use for:
            -s scriptable single channel capture (cron users)
*/
        if (0 != arg_capture) {
                chan = 0;
                if (optind < argc) {
                        chan = atoi( argv[ optind ] );

/* if it's valid, add it to the scan list */
                        if ( (chan >= 0) || (chan < ptc_max) ) {
                                arg_chan = chan;
                                dvrlog( LOG_INFO,
                                        "-s caps channel %d for %d seconds",
                                        chan, arg_capture );
                        } else {
                                dvrlog( LOG_INFO, "-s invalid channel %d", chan);
                                console_exit(1);
                        }
                }
        }

        test_luser();
/* end of parse args */
}


#ifdef USE_WWW
/* This is the tiny threaded http server code based on my tinyhttp.c 0.5 */

/* TODO
    Fix pipelining:
        Most browsers seem to have this defaulted to off. It non-issue for now
        since the keep-alive appears to be working better and faster. There is
        still an issue with returning a blank page but this is known to be
        from running out of threads. Click slower and all is good. :>
        
        Will look into using dynamic thread model instead of static model.
        The dynamic threads should allow pipelining to work, too.
 */

/* CHANGELOG:

        1.1     2007-Dec-29 fixed If-Modified-Since handling
        1.0     2006-Dec-20 keep-alive is working better now; added sig cgi
        0.9     2006-Sep-22 uintodot snprintf shorted; tts_s names; more media
        0.8     2006-Jul-29 layout done; dynamic href; toggle search; index zap
        0.7     2006-Jul-14 zap cap; w3c validator flags id=, mozilla is ok
        0.6     2006-Jul-12 toggle cgi spam/aged; multiple server hrefs; kasb?
        0.5     2006-Jul-02 add/remove timer cgi; keep alive still broken?
        0.4     2006-Jun-20 added keep alive but it seems broken?
        0.3     2006-Jun-11 fixed connect return check crash on rapid attempts
        0.2     2006-Jun-10 added structures to organize things better
        0.1     2006-Jun-08 add multi-thread support via pthreads, index.html
*/

/* *************************** http structures *************************** */

struct tts_s {                          /* thread task state */
        pthread_t thttp;                /* http thread pthread state */
        pthread_attr_t tattr;           /* http thread attributes */

        pid_t tid;                      /* process id of thread */

        struct sockaddr_in remote_addr; /* remote socket IP address */
        struct sockaddr_in local_addr;  /* local socket IP address */
        unsigned short local_port;      /* local inbound port */
        int ka;                         /* requested keep alive seconds */    
        unsigned int utska;             /* keep alive expiration */

        long long rseek,                /* file byte offset */
                obytes;                 /* TODO: current byte count */

        time_t imstime;                 /* if modified since time */

        int accepted,                   /* fd sock accepted */
                infile,                 /* fd file sendfile */
                rtype,                  /* request: HEAD 0, GET 1 */
                rnum,                   /* response numeric code */
                num,                    /* thread num 0 to ptmax - 1 */
                ramz,                   /* size of data if ram non-null */
                htver,                  /* http version 0=1.0, 1=1.1 */
                orate;                  /* TODO: bytes until osleep */

/* FIXME: change back to 16 char allocation after removing port# */
        char remote_name[128],                  /* remote socket IP name */
                remote_number[32],              /* remote IP num as text */
                local_name[128],                /* local socket IP name */
                local_number[32],               /* local IP num as text */
                tsbuf[WWW_TCP_MAX],             /* file io buffer */
                request[WWW_TCP_MAX],           /* http request */
                rfile[WWW_TCP_MAX - WWW_ROOT_MAX], /* requested file */
                reply[WWW_TCP_MAX],             /* http reply */
                cgi[WWW_ROOT_MAX],              /* data after ? in uri */
                cwd[WWW_ROOT_MAX],              /* current working dir */
                file[WWW_TCP_MAX],              /* full path name */
                date[32],                       /* file date */
                ctext[32],                      /* content-type text */
                ctype;                          /* cache type. 0 yes, nz no */

/* not implemented yet */
        char *ram;                      /* non NULL replaces file data */
        struct timespec osleep;         /* TODO: throughput throttle */

};

struct wss_s {                                  /* web server state */
        pthread_t tws;                          /* http_start pthread state */
        pthread_attr_t twsattr;                 /* http_start pthread attrs */

        struct tts_s *tss;                      /* http init callocs this */
        struct sockaddr_in bind_addr;           /* bound address/INADDR_ANY */

        unsigned int addr,                      /* ipv4 address in 32 bits */
                mask;                           /* ipv4 mask in 32 bits */

        unsigned short port;                    /* www port address */
        short mtu;                              /* maximum tx block MTU - 36 */

        int ptuse,                              /* threads in use */
                ptmax,                          /* threads to spawn */
                ptz,                            /* size of one tts_s */
                sock,                           /* www main socket fd */
                bound,                          /* is port bound to socket? */
                bind_try,                       /* how many tries to bind? */
                sig;                            /* interrupt signal condition */

        char host[WWW_HOST_MAX],                /* very long internet name */
                root[WWW_ROOT_MAX];             /* root from out_path or -p */
};

/* content type:
     .extension, type name, val is category where 0 is cacheable reply */
struct ct_s {
        char *ext;
        char *name;
        char val;
};

#define ALLOW_MAX 8
#define ALLOW_NAME_MAX 128
struct allow_s {
        char name[ ALLOW_NAME_MAX ];    /* very long host name, or IP num */
};


/************************ http globals begin ********************************/

struct wss_s wss;               /* web server status */
/* type 0 is images and are browser cacheable, rest are no-cache */

/* even after 10 years, all browsers only support JPEG, PNG and GIF images */
struct ct_s content_type[] = {
        { ".png",       "image/png",            0 },    /* 0 is image */
        { ".jpg",       "image/jpg",            0 },
        { ".jpeg",      "image/jpeg",           0 },
        { ".gif",       "image/gif",            0 },

        { ".txt",       "text/plain",           1 },    /* 1 is text */
        { ".log",       "text/plain",           1 },
        { ".html",      "text/html",            1 },
        { ".css",       "text/css",             1 },

/* default capture name is .ts, this will be the usual media name */
        { ".ts",        "video/mpeg",           2 },    /* 2 is media */
};

#if USE_WWW_SIGNALS
/* signals */
struct sigaction www_act2[32]; /* only the first 32 signals */
#endif

/* nanosleeps */
struct timespec www_bind_sleep = {1, 0};
struct timespec www_long_sleep = {10, 0};
struct timespec www_tcreate_sleep = {0, 10000000};
/* struct timespec www_write_sleep = {0, 1}; */

int allow_max = 0;
int ha_mt = 0;          /* hosts.allow modtime */
struct allow_s allow[ ALLOW_MAX ];

/*************************** httpd globals end ******************************/

/************************* httpd functions begin ****************************/
/* static */
void
http_log ( int tnum, char *fmt, ... )
{
        struct wss_s *w;
        struct tts_s *t;
        char s[ LOG_CHARS ]; /*  , *n; */
        va_list ap;

        w = &wss;
        if (NULL == w) return;

        if ((tnum < 0) || (tnum > w->ptmax)) {
            dvrlog( LOG_INFO, "%s thread number %d out of bounds");
            return;
        }

        t = &w->tss[tnum];
        memset( s, 0, sizeof(s));

/* Variable arg macro start, pass fmt and ap, variable arg macro end */
        va_start(ap, fmt);
        vsnprintf( s, sizeof(s)-1, fmt, ap );
        va_end(ap);

/* Term at first NL */
        
/*      if (NULL != (n = strchr( s,'\n'))) *n = 0; */

/* Don't log blank lines */
        if (0 != strlen(s))
            dvrlog( LOG_INFO, "t%02ds%02d %s", t->num, t->accepted, s);
}

/* Reload the hosts allow list if the modtime of /etc/hosts.allow changes. */
/* The format for hosts.allow, with text after "atscap:" stored:
    atscap: 1.2.3.
    atscap: .nop.org
*/

/* static */
void
http_load_allows ( void )
{
        FILE *f;
        struct allow_s *a;
        char fn[256], line[256], service[32], ip[128], *n, *ok;
        int i, z;
        struct stat fs;

/* RAM tries to keep frequently checked items */
        if (0 != arg_tmpfs) {
            snprintf( fn, sizeof(fn), "%s%shosts.allow", out_path, ram_path);
        } else {
            strcpy( fn, "/etc/hosts.allow" );
        }

        i = stat( fn, &fs);
        if (0 != i) {
/* Peter Knaggs reported this error if no hosts allow exists at all */
                advrlog( LOG_INFO, "can't stat %s", fn);
                return;
        }

/* modify date unchanged, do nothing */
        if (fs.st_mtime == ha_mt) return;
        ha_mt = fs.st_mtime;

/* modify date changed, open the changed file */
        f = fopen( fn, "r");
        if (NULL == f) {
                dvrlog( LOG_INFO, "can't open %s", fn);
                return;
        }

        z = strlen( NAME );
        allow_max = 0;
        while (1) {
                ok = fgets( line, sizeof(line), f );
                if (NULL == ok) break;
                n = line;

/* strip comment */
                if (NULL != (n = strchr(line, '#'))) *n = 0;
/* strip NL */
                if (NULL != (n = strchr(line, '\n'))) *n = 0;

/* nothing left keeps looping til eof */
                if (0 == n) continue;

/*              dvrlog( LOG_INFO, "allow line %s", line ); */
                sscanf( line, "%s %s", service, ip);

/* only looking for "atscap:" entries, skip the rest */
                if (0 != strncmp(service, NAME, z))
                    continue;

                advrlog( LOG_INFO, "allowing access to %s", ip );
                a = &allow[i];
                astrncpy( a->name, ip, ALLOW_NAME_MAX );
                i++;

/* warn user and stop looping if limit is reached */
                if (i >= ALLOW_MAX) {
                    dvrlog( LOG_INFO, "ALLOW_MAX limit is %d", ALLOW_MAX);
                    break;
                }
        }

        fclose(f);
        allow_max = i;

        advrlog( LOG_INFO, "allow list has %d item%s",
                allow_max, (1 == allow_max)?"":"s");
}

/* Compare the IP address against entries in /etc/hosts.allow to determine
    if the client broswer should be allowed to connect to the web server:

    Parameters:
        t               current web server thread
        addr            remote IP address to use for reverse DNS/hosts lookup
    
    Returns:
        0 if the remote is allowed to access this machine
        -1 if no access is allowed

    NOTE:
        This code does not use the functions listed in "man 3 hosts_access",
        but instead implements a subset of what is in "man 5 hosts_access".
        There is no keyword support for things like "ALL" or "LOCAL".
        "LOCAL" is implied, and "ALL" is a bad idea, band leeches, etc.
*/
/* static */
int
http_test_allows ( struct tts_s *t, struct sockaddr_in *addr )
{
        int i, ok, z, tnum;
        char *name, *test, *dot;
        struct hostent *remote;

        tnum = t->num;
/* LOCAL is implied */
        if (t->local_addr.sin_addr.s_addr == addr->sin_addr.s_addr)
            return 0;

/* Track the modtime of /etc/hosts.allow, loads new if changed. */
        http_load_allows();

/* AF_INET is the only supported type for gethostbyaddr */
        remote = gethostbyaddr( (char *)&addr->sin_addr.s_addr,
                                sizeof( addr->sin_addr.s_addr),
                                AF_INET );

/* If the name didn't resolve, will have to compare against IP address. */
        if (NULL != remote)
          if (' ' != *remote->h_name)
            astrncpy( t->remote_name, remote->h_name, sizeof(t->remote_name));

        ahttp_log( tnum, "%s resolves to %s", t->remote_number, t->remote_name);

        z = 0;
/* Compare partial names in /etc/hosts.allow to full name or IP address. */
        for (i = 0; i < allow_max; i++) {
            name = t->remote_name;              /* set name pointer */
            test = allow[i].name;               /* set test pointer */
            if (NULL == test) break;            /* end of list? */

/* If test starts with a dot, check last letters of name, not first. */
            dot = strchr( test, '.');
            if (dot == test) {

/* Name should always be equal to or longer than test. If not, skip it. */
                z = strlen(name) - strlen(test);
                if (z < 0) continue;

/* Adjust name pointer to test the last bytes instead of first bytes. */
                name += z;
            }

/* Test length is usually equal to length of test string, unless no dot. */
            z = strlen(test);

/* If there is no dot in test string, it will compare for exact match. */
            if (NULL == dot) z = ALLOW_NAME_MAX;

/* Exact match will allow access. */
            ok = strncasecmp( t->remote_number, test, z);
            if (0 == ok) {
                ahttp_log( tnum, "access allowed to addr %s", t->remote_number);
                return 0;
            }

/* Exact match will allow access. */
            ok = strncasecmp( name, test, z);
            if (0 == ok) {
                ahttp_log( tnum, "access allowed to name %s", t->remote_name);
                return 0;
            }
        }

        return -1;
}

/* source, destination, mask, 0 is test passed, -1 is not passed */
/* static */
int
http_test_netmask ( unsigned int d, unsigned int s, unsigned int m )
{
        if (0 == m) return 0;

/* TESTME: */
        if ( s == d ) return 0;

        advrlog( LOG_INFO, "%s", WHO );
        if ( (s & m) != (d & m) ) {

/* Log the Wile E. Haxor bandwidth bums. */
                advrlog( LOG_INFO, "%08X %08X %08X DENY", d, s, m);
                return -1;
        }
        advrlog( LOG_INFO, "%08X %08X %08X ALLOW", d, s, m);
        return 0;
}

/* close accepted socket and log the close */
/* static */
void
http_close ( struct tts_s *t, int *s, char *which )
{
/* indicates logic error, want this logged */
        if (-1 == *s) {
                http_log( t->num, "already closed %s", which);
                return;
        }

        ahttp_log( t->num, "close %s socket %d", which, *s);
        close( *s );
        *s = -1;
}

/* static */
void
http_close_sockets( void )
{
        struct wss_s *w;
        struct tts_s *t;
        int i;
        
        dvrlog( LOG_INFO, "%s", WHO);
        w = &wss;

/* shutdown thread sockets */
        for (i=0; i < w->ptmax; i++) {
                t = &w->tss[ i ];

                if (t->accepted > 2) {
                        http_log( t->num, "closing thread socket %d",
                                    t->accepted);
                        http_close( t, &t->accepted, "abort");
                }
                t->accepted = -1;
                nanosleep(&console_read_sleep, NULL);
        }

/* shutdown main socket */
        if (w->sock > 2) {
                http_log( 0, "closing main socket %d", w->sock);
                close( w->sock );
                w->sock = -1;
        }
}

/* bind socket to port, 80 usually */
/* static */
int
http_bind_socket( struct wss_s *w )
{

/* nothing above 224, everything else is fair game */
        if (223 <  (w->addr>>24)) {
                dvrlog( LOG_INFO, "invalid IP address for http %s", w->host );
                return -1;
        }

/* try to make a streaming socket */
        w->sock = socket(AF_INET, SOCK_STREAM, 0);
        if (w->sock == -1) {
                dvrlog( LOG_INFO, "www socket() failed\n");
                return -1;
/*              http_c_exit(2); / * bind error returns 2 */
        }

/* bind to local port */
        w->bind_addr.sin_family = AF_INET;
        w->bind_addr.sin_port = htons(w->port);

/* try any open interface */
        if (0 == w->addr) {
                w->bind_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        } else {
                w->bind_addr.sin_addr.s_addr = htonl(w->addr);
        }
        memset(&w->bind_addr.sin_zero, 0, 8);

        w->bound = -1;
        w->bind_try = 0;
        while (w->bound == -1) {
                w->bound = bind( w->sock,
                     (struct sockaddr*) &w->bind_addr,
                      sizeof(struct sockaddr));

                if (0 == w->bound) break;
                dvrlog( LOG_INFO, "bind try %d %08X:%08X:%u fail, sleep 10s",
                        w->bind_try, w->addr, w->mask, w->port);
                fflush(stdin);
                nanosleep( &www_long_sleep, NULL);
                w->bind_try++;
                if (w->bind_try > 30) {
                        break;
/*                      http_c_exit(2); */
            }
        }

        if (-1 == w->bound) {
                dvrlog( LOG_INFO, "bind failed");
                close( w->sock );
                return -1;
        }

        w->addr = ntohl( w->bind_addr.sin_addr.s_addr );

/* will be either 0.0.0.0 (INADDR_ANY) to bind to all interfaces,
    or user supplied IP address/netmask to bind to a specific interface
    and/or limit connections to be only from a specific subnet.
    224 and above are reserved for UDP multicast, hey IPTV!

    A glipse of what IPTV could be can be found with the -u option, however
    there is no current way to enable UDP multicast from the EPG.
*/
        memset( w->host, 0, WWW_HOST_MAX );
/* default host name if nothing found */
        uintodot( w->host, w->addr );

        dvrlog( LOG_INFO,"TCP httpd %08X:%08X:%u root %s t%d",
                w->addr, w->mask, w->port, w->root, w->ptmax );

/* let user know http is bound by setting [w] flag in EPG mask */
        refresh.estats = 1;
        return 0;
}

/* static */
int
http_socket_listen( struct wss_s *w, int backlog )
{
        time_t now;

        if ( -1 == ( listen( w->sock, backlog )) ) {
                http_log( 0,  "listen() failed");
                return -1;
/*              http_c_exit(3); / * listen error returns 3 */
        }
        now = time(NULL);
        return 0;
}

/* Peter Knaggs requested sort by file date */
/* if legend visible. uses headers above filenames to set sort order */
/* static */
void
http_sort_index ( struct globsort_s *g, int count )
{
        int i,j, t;
        time_t t1;
        time_t t2;
        char *n1, *n2;
        struct globsort_s s;

        if (count < 2) return;  /* if nothing to do */

        for (i=0; i < (count-1); i++) {
                for (j=i+1; j < count; j++) {
                        t = 0;
                        t1 = g[i].mt;
                        n1 = g[i].name;

                        t2 = g[j].mt;
                        n2 = g[j].name;

/* flag bit 0: 1 swap to mod time descending order */
                        if (0 != (1 & idx_sort))
                                if (t1 > t2) t = ~0;
/* flag bit 1: 1 swap to mod time ascending order */
                        if (0 != (2 & idx_sort))
                                if (t1 < t2) t = ~0;
/* flag bit 2: 1 swap to name ascending order */
                        if (0 != (4 & idx_sort))
                                if (0 < strncasecmp(n1, n2, 32)) t = ~0;
/* flag bit 3: 1 swap to name descending order */
                        if (0 != (8 & idx_sort))
                                if (0 > strncasecmp(n1, n2, 32)) t = ~0;
/* any swap to do? */
                        if (0 != t) {
                                memcpy( &s, &g[i], sizeof(s));
                                memcpy( &g[i], &g[j], sizeof(s));
                                memcpy( &g[j], &s, sizeof(s));
                        }
                }
        }
}


/* builds index.html in current working directory of thread

     atscap0 atscap1 atscap2 atscap3 [cap] free% [cut] free%
    ---------------------------------------------------------
      PBS UPN FOX CBS ABC NBC WB ETH FUT AZH TUB ZJL UNI TEL
    ---------------------------------------------------------
      Size  Date                 [+/zap] [log] [edit] Name

     4,634M 2007-Jan-06 22:06:44 [+/zap] [log] [edit] Farscape-0106-1200.00.ts

    '+' is record indicator red circle or zap if not a new file.
    log image or LOG indicates there is a capture log for it.
    edit image or EDIT will run xtscut on the file.
    name.ts is clickable as mpeg:// href.
    zap image or ZAP will delete the file.
*/

/* static */
int
http_index_html3 ( struct wss_s *w, int tnum, char *caller )
{
        FILE *f;                /* index.html file descriptor */
        glob_t globt;           /* globt glob pointer */
        time_t now;             /* current time */

        long long fz;

        char *globa,            /* glob wildcard match in ascii */
            *p,
            *n,
            *ur,                /* uri:// filler as mpeg:// */
            *l,
            *st,                /* sort type bitmask */
            *ei;
            
        char
            s[8192],            /* html source text string */
            ti[256],            /* html title text "index of /[cut/]" */
            zt[32],             /* reusable file size text */
            ft[32],             /* reusable file time text */
                                /* reusable file names: */
            ln[WWW_ROOT_MAX],   /* reusable capture log name */
            lu[WWW_TCP_MAX],    /* reusable capture log url */
            xn[WWW_ROOT_MAX],   /* reusable tsx name */
            cn[WWW_ROOT_MAX],   /* reusable tsc name */
            d[WWW_TCP_MAX],
            o[WWW_TCP_MAX],
            x[WWW_TCP_MAX];


        int i, ok,              /* counter and reusable return code */
            globnum,
            gc,                 /* total globs returned */
            fg,                 /* files globbed for sorting */
            chg,
                                /* reusable file stat return codes: */
            tsx,                /*  0 is tsx file exists */
            tsc,                /*  0 is tsc file exists */ 
            clf;                /*  0 is cap logfile exists */


        struct tm mt;           /* reusable file mod time */
        struct tts_s *t;        /* thread task status */
        struct globsort_s *globsort;    /* reusable by each thread */

        struct stat64 fs,       /* reusable file stats data: */
            ls,                 /*  capture logfile stat */
            xs,                 /*  tsx index file stat */
            cs;                 /*  tsc cut file stat */


        while (EBUSY == pthread_mutex_trylock( &index_mutex )) return -1;
        globsort = NULL;
        fg = 0;

        t = &w->tss[ tnum ];
        i = 0;
        ok = -1;

        globa = "*.ts";          /* glob all .ts files */
        globnum = 0;

/* media type include list by .ts extension */
        astrncpy( o, t->cwd, sizeof(o) );
    
/* get path */
        p = NULL;
        if (strlen(o) > 1)
                p = strrchr( o, '/' );
        if (NULL != p) {
                *p='?';
                p = strrchr(o, '/');
                if (NULL != p) {
                        p++;
                        *p = 0;
                }
        }

        if (strlen(o) < 1)
                astrncpy( o, t->cwd, sizeof(o) );

        snprintf( d, sizeof(d), "%s%s", w->root, t->cwd );

        ok = chdir( d );
        if (ok != 0)
        {
                dvrlog( LOG_INFO,  "%s %s t%d chdir %d %s %s %s",
                        WHO, caller, tnum, ok, d, w->root, t->cwd );
                ok = -1;
                goto http_index_exit;
        }
        snprintf( x, sizeof(x)-1, "%sindex.html", d );
        advrlog( LOG_INFO, "x1 %s", x);

        ok = stat64(x, &fs);

/* if file exists, don't overwrite if user write not set */
        if (0 == ok) {
                if (0 == (S_IWUSR & fs.st_mode)) {
/* serve current file */
                        dvrlog( LOG_INFO, "user can't update %s", x);
                        ok = -1;
                        goto http_index_exit;
                }
        }

/* NOTE:
        glob on smbfs does not differentiate file vs dir.
        Also some odd issues with symlink display because not handled.
        Each glob item has to be checked for being a regular file.
*/

/* glob all .ts and get glob count */
        glob( globa, 0, NULL, &globt);
        gc = globt.gl_pathc;

/* allocate glob sort */
        globsort = icalloc( gc, sizeof( struct globsort_s ), "globsort" );

        fg = 0;
/* skip missing or non-regular files, else copy out size, date and name */
        for (i = 0; i < gc; i++) {
                memset( &fs, 0, sizeof(fs));
                ok = stat64( globt.gl_pathv[i], &fs);
                if (0 != ok) continue;
                if (0 == (S_IFREG & fs.st_mode)) continue;

                globsort[fg].fz = (long long) fs.st_size;
                globsort[fg].mt = fs.st_mtime;
                globsort[fg].name = globt.gl_pathv[i];
                fg++;
        }

#define USE_GLOB_SORT_MT
#ifdef USE_GLOB_SORT_MT
/* TODO: do the sort, but could make it a toggle */

/* reverse sort by date */
        http_sort_index( globsort, fg );
#endif
        chdir( w->root );

        f = fopen( x, "w");
    
/* if can't create the index file for some reason, get out */
        if (NULL == f) {
                dvrlog( LOG_INFO,
                        "www t%d didn't create %s%sindex.html",
                        tnum, w->root, t->cwd);
                ok = -1;
                goto http_index_exit;
        }

        now = time(NULL);
        advrlog( LOG_INFO, "open w %s %s files %d", d, x, fg);
        snprintf( ti, sizeof(ti)-1, "%s index %s", syslog_name, t->cwd);

/* Write out the HTML header and body headers and optional legend
        The index pages do not have auto-refresh. This is intentional
        so it will only use CPU when user requests it to refresh.
*/
        *s = 0;
        build_head_html( s, sizeof(s), 1, ti, 0, WHO); /* non-rel epg href */
        fprintf( f, "%s", s);

        fprintf( f, "<center>\n");
        fprintf( f, "<b>Index of [%s] " NBSP "</b>\n",
                (0 == t->cwd[1]) ? "cap":"cut" );

/* get vol free/size and cut free/size */
        read_capvol_stats();
        read_cutvol_stats();
        if ( 0 == t->cwd[1] ) {
            if (0 == vol_size) vol_size = 1;
            fprintf( f, "Free %lldG (%lld%%) ",
                     vol_free, (100 * vol_free) / vol_size );
        } else {
            if (0 == cut_size) cut_size = 1;
            fprintf( f, "Free %lldG (%lld%%) ",
                     cut_free, (100 * cut_free) / cut_size );
        }

        fprintf( f, "<a href=\042%s%s?l=1\042>", t->cwd, t->file);
        fprintf( f, "%s", (0 == web_legend) ?"Help":"HELP");
        fprintf( f, "</a> " NBSP "\n");

        fprintf( f, "<a href=\042%s%s?f=1\042>", t->cwd, t->file);
        fprintf( f, "%s", "CSS");
        fprintf( f, "</a> \n");
        fprintf( f, "<br>\n");

        if (0 != web_legend) {
            fprintf( f, IMG_FMT "%s\n", "NEW", "/pg/img/rec16.png",
                     16, 16, 4, 4, 0, "New " );
            fprintf( f, IMG_FMT "%s\n", "LOG", "/pg/img/log16.png",
                     16, 16, 4, 4, 0, "Log " );
            fprintf( f, IMG_FMT "%s\n", "SEQ", "/pg/img/seq16.png",
                     16, 16, 4, 4, 0, "Seq+Edit " );
            fprintf( f, IMG_FMT "%s\n", "EDIT", "/pg/img/edit16.png",
                     16, 16, 4, 4, 0, "Edit " );
            fprintf( f, IMG_FMT "%s\n", "CUT", "/pg/img/cut16.png",
                     16, 16, 4, 4, 0, "Cut " );
            fprintf( f, IMG_FMT "%s\n", "ZAP", "/pg/img/zap16.png",
                     16, 16, 4, 4, 0, "Delete " );
        }
        fprintf( f, "</center>\n");
        fprintf( f, "<hr>\n");

// validator does like this, but screws up the file size text alignment
//      fprintf( f, "<code>\n");
// validator doesn't like this
        fprintf( f, "<pre>"); 
        if (0 != web_legend) {
                fprintf( f, "  Size      ");

                st = "b=1";
                if (1 & idx_sort) st = "b=2";

                fprintf( f, "%s<a href=\042index.html?%s\042>%s</a>%s",
                        "   ", st, "Date", "        ");

                st = "b=4";
                if (4 & idx_sort) st = "b=8";

                fprintf( f, "%s<a class=\042%s\042 "
                            "href=\042index.html?%s\042>%s</a>\n",
                        "                ", "f3 green", st, "Name");
        }
/* walk globsort index of files */
        for ( i = 0; i < fg; i++ ) {
                ln[0] = lu[0] = 0;
                n = globsort[i].name;
                l = "";

/* should not happen, abort loop if any name pointer got zapped */
                if (NULL == n) break;
                if (0 == *n) break;

/* use mpeg:// type URL */
                ur = "mpeg";

/* build the .html capture log name from .ts file name */
                snprintf( ln, sizeof(ln)-1, "%s", n );
                ln[strlen(ln)-3] = 0; /* strip .ts */
                asnprintf( ln, sizeof(ln)-1, ".html");
                    
/* build the .tsx index file name */
                snprintf( xn, sizeof(xn)-1, "%s%s%sx", w->root, t->cwd, n );
                tsx = stat64( xn, &xs );
                advrlog( LOG_INFO, "%s %s %d", WHO, xn, tsx);

/* build the .tsc cut file name */
                snprintf( cn, sizeof(xn)-1, "%s%s%sc", w->root, t->cwd, n );
                tsc = stat64( cn, &cs );
                advrlog( LOG_INFO, "%s %s %d", WHO, cn, tsc);
                if (0 == tsc)
                    if (0 == cs.st_size)
                        tsc = -1;

/* capture log exists? */
                clf = stat64(ln, &ls);
                if (0 == clf) {
/* LOG is img alt text */
                        l = "LOG ";
                        snprintf( lu, sizeof(lu)-1, "%s", ln);
                }

/* build the time string from file mod time */
                localtime_r( &globsort[i].mt, &mt );

/* ft is file time text: YYYY-MMM-DD hh:mm :ss always 55 except manual cap */
                snprintf( ft, sizeof(ft), "%04d-%3s-%02d %02d:%02d",
                            mt.tm_year+1900, mons[mt.tm_mon], mt.tm_mday,
                            mt.tm_hour, mt.tm_min );

                chg = 0;

/* red dot indicates capture is in progress */
                if ( (globsort[i].mt + 5) > now) chg = ~0;

/* fz is file size text: xx,xxx max, in binary style megabytes */
                fz = (long long) globsort[i].fz;
                fz >>= 20LL;

                lltoasc( zt, fz );
                fprintf( f, "%6sM  ", zt );

/* ft is file time text: yyyy-mm-dd hh:mm:ss */
                fprintf( f, "%-17s ", ft );

                if (0 == chg) {
/* unlink/zap href img */
                        fprintf( f,
                            "<a href=\042index.html?u=%s\042>" IMG_FMT "</a>",
                            n, "DEL ", "/pg/img/zap16.png", 16, 16, 4, 0, 0 );
                } else {
/* recording indicator is red button, can only zap from EPG */
                        fprintf( f, IMG_FMT, "CAP ", "/pg/img/rec16.png",
                                 16, 16, 4, 0, 0 );
                }

                if (0 == clf) {
/* log href img */
                        fprintf( f,
                                "<a href=\042%s\042>" IMG_FMT "</a>",
                                lu, "LOG ", "/pg/img/log16.png",
                                16, 16, 4, 0, 0 );
                } else {

/* spacer if no log file */
                        fprintf( f, IMG_FMT, 
                                "    ", "/pg/img/blank16.png",
                                16, 16, 4, 0, 0 );
                }

/* edit image, four possible images to pick, blank, seq, edit or cut */
                ei = "/pg/img/blank16.png";     /* new files get blank */
                
/* only show these if no change in .ts file in last 5s, and also */
/* only if cwd is cap directory, no editing in other directories */
                if ( (0 == chg) && (0 == t->cwd[1]) ) {
                        l = "SEQ ";
                        ei = "/pg/img/seq16.png";
                        if (0 == tsx) {
                                if (0 == tsc) {
                                        ei = "/pg/img/cut16.png";
                                        l = "CUT ";
                                } else {
                                        ei = "/pg/img/edit16.png";
                                        l = "XTC ";
                                }
                        }
                        fprintf( f,
                                 "<a href=\042xtc://%s%s\042>" IMG_FMT "</a>", 
                                 t->cwd, n, l, ei, 16, 16, 4, 0, 0);
                } else {

/* cut dir files only get delete img+alt tag */
                        fprintf( f, IMG_FMT, "    ", ei, 16, 16, 4, 0, 0);
                }

/* can't use relative href because using mpeg:// instead of http:// */
/* t->local_name could be from any interface, w->host may be INADDR_ANY */
/* added port so it will work properly with http playback from any port */
                fprintf( f, " <a href=\042%s://", ur);
                fprintf( f, "%s:%d", t->local_name, arg_wport );

                fprintf( f, "%s%s\042>", t->cwd, n );
                fprintf( f, "%s</a>", n );

// validator test: doesn't look right without <br> if using <code></code>
//              fprintf( f, "<br />" );
                fprintf( f, "\n" );

        }

// validator does like this, but screws up the file size text alignment
//      fprintf( f, "</code>\n");
// validator doesn't like this
        fprintf( f, "</pre>\n"); 


/* .ts files list was 0, indicate no captures */
        if (0 == fg)  fprintf( f, "<center><b>No Captures</b></center>\n");

        fprintf( f, "<hr>\n");

/* NOTE: This one will pass the validator with <code></code>, but looks wrong
    unless using invalid <pre></pre> for file size when it's over 9999M.
    Take comfort in fact that apache file list won't pass validator, either.
*/
        *s = 0;
        build_foot_html(s, sizeof(s), 0); /* no validator png. needs <pre> */
        fprintf( f, "%s", s);
        fclose( f );
        ok = 0;

/* don't forget: free glob memory and unlock mutex */
http_index_exit:
        ifree( globsort, "globsort" );
        globfree( &globt );
        advrlog( LOG_INFO,  "www t%d glob: %s found %d files for index.html",
            tnum, d, fg);
        pthread_mutex_unlock( &index_mutex );
        return ok;
}

/* static */
int
http_index_html4( struct wss_s *w, int tnum, char *caller )
{
        FILE *f;                /* index.html file descriptor */
        glob_t globt;           /* globt glob pointer */
        time_t now;             /* current time */

        long long fz;

        char *globa,            /* glob wildcard match in ascii */
            *p,
            *n,
            *ur,                /* uri:// filler as mpeg:// */
            *l,
            *st,                /* sort type bitmask */
            *ei;
            
        char
            s[8192],            /* html source text string */
            ti[256],            /* html title text "index of /[cut/]" */
            zt[32],             /* reusable file size text */
            ft[32],             /* reusable file time text */
                                /* reusable file names: */
            ln[WWW_ROOT_MAX],   /* reusable capture log name */
            lu[WWW_TCP_MAX],    /* reusable capture log url */
            xn[WWW_ROOT_MAX],   /* reusable tsx name */
            cn[WWW_ROOT_MAX],   /* reusable tsc name */
            d[WWW_TCP_MAX],
            o[WWW_TCP_MAX],
            x[WWW_TCP_MAX];


        int i, ok,              /* counter and reusable return code */
            globnum,
            gc,                 /* total globs returned */
            fg,                 /* files globbed for sorting */
            chg,
                                /* reusable file stat return codes: */
            tsx,                /*  0 is tsx file exists and not blank */
            tsc,                /*  0 is tsc file exists */ 
            clf;                /*  0 is cap logfile exists */


        struct tm mt;           /* reusable file mod time */
        struct tts_s *t;        /* thread task status */
        struct globsort_s *globsort;    /* reusable by each thread */

        struct stat64 fs,       /* reusable file stats data: */
            ls,                 /*  capture logfile stat */
            xs,                 /*  tsx index file stat */
            cs;                 /*  tsc cut file stat */


        while (EBUSY == pthread_mutex_trylock( &index_mutex )) return -1;
        globsort = NULL;
        fg = 0;

        t = &w->tss[ tnum ];
        i = 0;
        ok = -1;

        globa = "*.ts";          /* glob all .ts files */
        globnum = 0;

/* media type include list by .ts extension */
        astrncpy( o, t->cwd, sizeof(o) );
    
/* get path */
        p = NULL;
        if (strlen(o) > 1)
                p = strrchr( o, '/' );
        if (NULL != p) {
                *p='?';
                p = strrchr(o, '/');
                if (NULL != p) {
                        p++;
                        *p = 0;
                }
        }

        if (strlen(o) < 1)
                astrncpy( o, t->cwd, sizeof(o) );

        snprintf( d, sizeof(d), "%s%s", w->root, t->cwd );

        ok = chdir( d );
        if (ok != 0)
        {
                dvrlog( LOG_INFO,  "%s %s t%d chdir %d %s %s %s",
                        WHO, caller, tnum, ok, d, w->root, t->cwd );
                ok = -1;
                goto http_index_exit;
        }
        snprintf( x, sizeof(x)-1, "%sindex.html", d );
        advrlog( LOG_INFO, "x1 %s", x);

        ok = stat64(x, &fs);

/* if file exists, don't overwrite if user write not set */
        if (0 == ok) {
                if (0 == (S_IWUSR & fs.st_mode)) {
/* serve current file */
                        dvrlog( LOG_INFO, "user can't update %s", x);
                        ok = -1;
                        goto http_index_exit;
                }
        }

/* NOTE:
        glob on smbfs does not differentiate file vs dir.
        Also some odd issues with symlink display because not handled.
        Each glob item has to be checked for being a regular file.
*/

/* glob all .ts and get glob count */
        glob( globa, 0, NULL, &globt);
        gc = globt.gl_pathc;

/* allocate glob sort */
        globsort = icalloc( gc, sizeof( struct globsort_s ), "globsort" );

        fg = 0;
/* skip missing or non-regular files, else copy out size, date and name */
        for (i = 0; i < gc; i++) {
                memset( &fs, 0, sizeof(fs));
                ok = stat64( globt.gl_pathv[i], &fs);
                if (0 != ok) continue;
                if (0 == (S_IFREG & fs.st_mode)) continue;

                globsort[fg].fz = (long long) fs.st_size;
                globsort[fg].mt = fs.st_mtime;
                globsort[fg].name = globt.gl_pathv[i];
                fg++;
        }

#define USE_GLOB_SORT_MT
#ifdef USE_GLOB_SORT_MT
/* TODO: do the sort, but could make it a toggle */

/* reverse sort by date */
        http_sort_index( globsort, fg );
#endif
        chdir( w->root );

        f = fopen( x, "w");
    
/* if can't create the index file for some reason, get out */
        if (NULL == f) {
                dvrlog( LOG_INFO,
                        "www t%d didn't create %s%sindex.html",
                        tnum, w->root, t->cwd);
                ok = -1;
                goto http_index_exit;
        }

        now = time(NULL);
        advrlog( LOG_INFO, "open w %s %s files %d", d, x, fg);
        snprintf( ti, sizeof(ti)-1, "%s index %s", syslog_name, t->cwd);

/* Write out the HTML header and body headers and optional legend
        The index pages do not have auto-refresh. This is intentional
        so it will only use CPU when user requests it to refresh.
*/
        *s = 0;

/* non-rel servers, rel epg hrefs */
        build_head_html( s, sizeof(s), 1, ti, 0, WHO);
        fprintf( f, "%s", s);

        fprintf( f, "<center>\n");
        fprintf( f, "<b>Index of [%s] " NBSP "\n",
                (0 == t->cwd[1]) ? "cap":"cut" );

/* get vol free/size and cut free/size */
        read_capvol_stats();
        read_cutvol_stats();
        if ( 0 == t->cwd[1] ) {
            if (0 == vol_size) vol_size = 1;
            fprintf( f, "Free %lldG (%lld%%) ",
                     vol_free, (100 * vol_free) / vol_size );
        } else {
            if (0 == cut_size) cut_size = 1;
            fprintf( f, "Free %lldG (%lld%%) ",
                     cut_free, (100 * cut_free) / cut_size );
        }
        fprintf( f, "</b>\n");

        fprintf( f, "<a class=\042%s\042 href=\042%s%s?l=1\042>",
                    "green", t->cwd, t->file);
        fprintf( f, "%s", (0 == web_legend) ? "Help":"HELP");
        fprintf( f, "</a> \n");

        fprintf( f, "<a class=\042%s\042 href=\042%s%s?f=0\042>",
                    "green", t->cwd, t->file);
        fprintf( f, "%s", "HTML");
        fprintf( f, "</a> \n");

        fprintf( f, "<br />\n");

        if (0 != web_legend) {
            fprintf( f, IMG_FMT "%s\n", "NEW", "/pg/img/rec16.png",
                     16, 16, 4, 4, 0, "New " );
            fprintf( f, IMG_FMT "%s\n", "LOG", "/pg/img/log16.png",
                     16, 16, 4, 4, 0, "Log " );
            fprintf( f, IMG_FMT "%s\n", "SEQ", "/pg/img/seq16.png",
                     16, 16, 4, 4, 0, "Seq+Edit " );
            fprintf( f, IMG_FMT "%s\n", "EDIT", "/pg/img/edit16.png",
                     16, 16, 4, 4, 0, "Edit " );
            fprintf( f, IMG_FMT "%s\n", "CUT", "/pg/img/cut16.png",
                     16, 16, 4, 4, 0, "Cut " );
            fprintf( f, IMG_FMT "%s\n", "ZAP", "/pg/img/zap16.png",
                     16, 16, 4, 4, 0, "Delete " );
        }
        fprintf( f, "</center>\n");
        fprintf( f, "<hr />\n");

// validator does like this, but screws up the file size text alignment
//      fprintf( f, "<code>\n");
// validator doesn't like <pre> here?
        fprintf( f, "<div class=\042%s\042>\n", "f5");
        fprintf( f, "<pre>");
        if (0 != web_legend) {
                fprintf( f, "  Size      ");

                st = "b=1";
                if (1 & idx_sort) st = "b=2";

                fprintf( f, "%s<a class=\042%s\042 "
                            "href=\042index.html?%s\042>%s</a>%s",
                        "   ", "f5 green", st, "Date", "        ");

                st = "b=4";
                if (4 & idx_sort) st = "b=8";

                fprintf( f, "%s<a class=\042%s\042 "
                            "href=\042index.html?%s\042>%s</a>\n",
                        "         ", "f5 green", st, "       Name");
        }
/* walk globsort index of files */
        for ( i = 0; i < fg; i++ ) {
                ln[0] = lu[0] = 0;
                n = globsort[i].name;
                l = "";

/* should not happen, abort loop if any name pointer got zapped */
                if (NULL == n) break;
                if (0 == *n) break;

/* use mpeg:// type URL */
                ur = "mpeg";

/* build the .html capture log name from .ts file name */
                snprintf( ln, sizeof(ln)-1, "%s", n );
                ln[strlen(ln)-3] = 0; /* strip .ts */
                asnprintf( ln, sizeof(ln)-1, ".html");
                    
/* build the .tsx index file name */
                snprintf( xn, sizeof(xn)-1, "%s%s%sx", w->root, t->cwd, n );
                tsx = stat64( xn, &xs );
                advrlog( LOG_INFO, "%s %s %d", WHO, xn, tsx);

/* build the .tsc cut file name */
                snprintf( cn, sizeof(xn)-1, "%s%s%sc", w->root, t->cwd, n );
                tsc = stat64( cn, &cs );
                advrlog( LOG_INFO, "%s %s %d", WHO, cn, tsc);
                if (0 == tsc)
                    if (0 == cs.st_size) tsc = -1;

/* has capture log file? */
                clf = stat64(ln, &ls);
                if (0 == clf) {
/* log is img alt text */
                        l = "LOG ";
                        snprintf( lu, sizeof(lu)-1, "%s", ln);
                }

/* build the time string from file mod time */
                localtime_r( &globsort[i].mt, &mt );

/* ft is file time text: YYYY-MMM-DD hh:mm :ss always 55 except manual cap */
                snprintf( ft, sizeof(ft), "%04d-%3s-%02d %02d:%02d",
                            mt.tm_year+1900, mons[mt.tm_mon], mt.tm_mday,
                            mt.tm_hour, mt.tm_min );
                chg = 0;

/* red dot indicates capture is in progress */
                if ( (globsort[i].mt + 5) > now) chg = ~0;

/* fz is file size text: xx,xxx max, in binary style megabytes */
                fz = (long long) globsort[i].fz;
                fz >>= 20LL;

                lltoasc( zt, fz );
                fprintf( f, "%6sM  ", zt );

/* ft is file time text: yyyy-mm-dd hh:mm:ss */
                fprintf( f, "%-17s ", ft );

                if (0 == chg) {
/* unlink/zap href img */
                        fprintf( f, "<a class=\042%s\042"
                                    "href=\042index.html?u=%s\042>" IMG_FMT "</a>",
                            "green", n, "DEL ", "/pg/img/zap16.png",
                            16, 16, 4, 0, 0 );
                } else {
/* recording indicator is red button, can only zap from EPG */
                        fprintf( f, IMG_FMT, "CAP ",
                                "/pg/img/rec16.png", 16, 16, 4, 0, 0 );
                }

                if (0 == clf) {
/* log href img */
                        fprintf( f, "<a class=\042%s\042 "
                                    "href=\042%s\042>" IMG_FMT "</a>",
                                "green", lu, "LOG ",
                                "/pg/img/log16.png", 16, 16, 4, 0, 0 );
                } else {

/* spacer if no log file */
                        fprintf( f, IMG_FMT, 
                                "    ", "/pg/img/blank16.png", 16, 16, 4, 0, 0 );
                }

/* edit image, four possible images to pick, blank, seq, edit or cut */
                ei = "/pg/img/blank16.png";     /* new files get blank */
                
/* only show these if no change in .ts file in last 5s, and also */
/* only if cwd is cap directory, no editing in other directories */
                if ( (0 == chg) && (0 == t->cwd[1]) ){
                        l = "SEQ ";
                        ei = "/pg/img/seq16.png";
                        if (0 == tsx) {
                                if (0 == tsc) {
                                        ei = "/pg/img/cut16.png";
                                        l = "CUT ";
                                } else {
                                        ei = "/pg/img/edit16.png";
                                        l = "XTC ";
                                }
                        }
                        fprintf( f, "<a class=\042%s\042 "
                                    "href=\042xtc://%s%s\042>" IMG_FMT "</a>", 
                            "green",  t->cwd, n, l, ei, 16, 16, 4, 0, 0);
                } else {
/* cut dir files only get delete img+alt tag */
                        fprintf( f, IMG_FMT, "    ", ei, 16, 16, 4, 0, 0);
                }

/* can't use relative href because using mpeg:// instead of http:// */
/* t->local_name could be from any interface, w->host may be INADDR_ANY */
/* added port so it will work properly with http playback from any port */
                fprintf( f, "<a class=\042%s\042 href=\042%s://",
                        "f5 green", ur);
                fprintf( f, "%s:%d", t->local_name, arg_wport );

                fprintf( f, "%s%s\042>", t->cwd, n );
                fprintf( f, " %s</a>", n );

// validator test: doesn't look right without <br /> if using <code></code>
//              fprintf( f, "<br />" );
                fprintf( f, "\n" );

        }

// validator does like this, but screws up the file size text alignment
//      fprintf( f, "</code>\n");
// validator doesn't like this
        fprintf( f, "</pre>\n"); 
        fprintf( f, "</div>\n");

/* .ts files list was 0, indicate no captures */
        if (0 == fg)  fprintf( f, "<b>No Captures</b>\n");

        fprintf( f, "<hr />\n");

/* NOTE: This one will pass the validator with <code></code>, but looks wrong
    unless using invalid <pre></pre> for file size when it's over 9999M.
    Take comfort in fact that apache file list won't pass validator, either.
*/
        *s = 0;
        build_foot_html(s, sizeof(s), 0); /* no validator png. needs <pre> */
        fprintf( f, "%s", s);
        fclose( f );
        ok = 0;

/* don't forget: free glob memory and unlock mutex */
http_index_exit:
        ifree( globsort, "globsort" );
        globfree( &globt );
        advrlog( LOG_INFO,  "www t%d glob: %s found %d files for index.html",
            tnum, d, fg);
        pthread_mutex_unlock( &index_mutex );
        return ok;
}


/* builds index.html in current working directory of thread

     atscap0 atscap1 atscap2 atscap3 [cap] free% [cut] free%
    ---------------------------------------------------------
      PBS UPN FOX CBS ABC NBC WB ETH FUT AZH TUB ZJL UNI TEL
    ---------------------------------------------------------
      Size  Date                 [+/zap] [log] [edit] Name

     4,634M 2007-Jan-06 22:06:44 [+/zap] [log] [edit] Farscape-0106-1200.00.ts

    '+' is record indicator red circle or zap if not a new file.
    log image or LOG indicates there is a capture log for it.
    edit image or EDIT will run xtscut on the file.
    name.ts is clickable as mpeg:// href.
    zap image or ZAP will delete the file.
*/

/* static */
void
http_index_html ( struct wss_s *w, int tnum, char *caller )
{
        if (0 == use_css) {
            http_index_html3( w, tnum, caller );
        } else {
            http_index_html4( w, tnum, caller );
        }
}


/* look at t->file extension and set t->ctext and t->ctype */
/* static */
void
http_get_content( struct tts_s *t )
{
        int i, j, x, y, z;
        char *e, *c, cc;
        struct ct_s *ct = &content_type[0];

        c = "text/plain";               /* default if no match */
        cc = 1;                         /* default is no cache */
        
        j = sizeof( content_type ) / sizeof (struct ct_s);
        x = strlen( t->file );          /* filename length */
        for (i = 0; i < j; i++) {
            e = ct[ i ].ext;            /* ext text */
            y = strlen(e);              /* ext len */
            z = x - y;

            if (z > 0) {
                if (0 == strncasecmp( &t->file[ z ], e, y)) {
                    c    = ct[ i ].name;
                    cc   = ct[ i ].val;
                    break;
                }
            }
        }

        astrncpy( t->ctext, c, sizeof(t->ctext) ); /* content type text */
        t->ctext[31] = 0;               /* nul term */
        t->ctype = cc;                  /* 0 is cache, nz is no cache */
}

/* Reload will eventually dump latest epg if the signal is good.
    After a few seconds, there will be an EPG but if the station sends
    a few days worth it may take >45s before it is complete.
    12 days worth takes about 90s for one station here that sends that much.
    ts cap loop saves the current epg (presumably with timers indicated),
    so the first update can occur immediately. show cap stats dumps epg.
*/
/* static */
void
http_reload_epg ( int tnum, int ch )
{
        struct sig_s *s;

        if (ch < 0) return;
        if (ch > ptc_max) return;
        if (CAP_NONE != cap_now) return;

        s = &ptc[ ch ].sig;

/* fetch one guide from this device if no timers within 180s */
        if ( ch == s->chan) {
            if (timer_idx > 0) {
/* only search timers left on timer list is ok to cap info */
                if (T_SEARCH == timer[0].qstat) {
/* scan_pos for console gets set by ts cap loop */
                        cap_chan = ch;
                        cap_now = CAP_INFO;
                } else {
/* timer0 more than 3 minutes away is ok to cap info */
                    if (utsnow < (timer[0].start - 180)) {
                        cap_chan = ch;
                        cap_now = CAP_INFO;
                    }
                }
/* no timers is ok to cap info */
            } else {
                        cap_chan = ch;
                        cap_now = CAP_INFO;
            }
        }
/* wait for AOS at least */
        nanosleep( &signal_long_sleep, NULL );
}

/* This is faster than waiting for test guides to get around to it. */

/* NOTE: big epg is malloc'd but rest are static. The only one that needs
         to be static is pgm3 to hold the http user filter settings, which
         allows it to be different from the console settings.
*/
/* static */
void
http_refresh_epg ( int tnum, int ch )
{

/* don't forget to free epg3 */
        epg3 = imalloc( sizeof( epg ), "http epg3");
        if (NULL == epg3) {
                http_log( tnum, "%s epg3 malloc failed", WHO);
                return;
        }

/* Temporarily re-enabled 20071227 to test for crashes:

    It may be better to only allow this after about 15 to 30s
    of capture since most stations that are working correctly
    will have their baseline 12 hour EPG data (4 EITs) loaded by then.

    The 4 baseline EITs will usually repeat more often than the rest, if the
    station is sending more than the minimum 4 EITs for ATSC compliance.

    If there is a crash here, it could be caused by partial data fill.
*/

#define USE_HTTP_LIVE_EPG
#ifdef USE_HTTP_LIVE_EPG
/* if live, epg is copied in case it's requested for current channel */

/* Peter Knaggs reported a crash that seems to be related to this.
   The live EPG can be saved by show_cap_status after 3m instead,
    so the user can get a guide update within 5m of start of capture.
    If the EPGs are already up-to-date, disabling this should be OK.
*/
        if ((CAP_NONE != cap_now) && (ch == cap_chan) && (utsets > 5)) {
            memcpy( epg3, epg, sizeof(epg));
            memcpy( &pg3, &pg, sizeof(pg));
/*          memcpy( &pgm3, &pgm, sizeof(pgm)); */ /* NO: keep web UI settings */
        } else
#endif

        {
/* otherwise, load last saved EPG */
            memset( epg3, 0, sizeof(epg));   /* EPG data: .5, 3 or 8M sizes */
            memset( pg3, 0xFF, sizeof(pg)); /* small: indices 16k */
            load_epg( ch, epg3, &pgm3, pg3, WHO );
        }

/* set the channel to requested */
        pgm3.chan = ch; /* what is value during cap? */

/* dump epg should be abstracted enough by now to write any epg */
        dump_epg_html( epg3, &pgm3, pg3, WHO );
        if (NULL != epg3)
            ifree( epg3, "http epg3" );
        epg3 = NULL;
}

#if 0
/* when user hits cap log href and href refers to current file, refresh log */
/* no: this one needs more thought. */
/* static */
void
http_refresh_caplog( void )
{
        if (CAP_NONE != cap_now) dump_cap_log();
}
#endif

/* convert %XX chars to ascii, and + to space */
/* static */
void
http_url_ascii( char *d, char *s )
{
    unsigned char c;
    char *e;

    e = d;

    while (0 != *s) {
        *d = *s;
        if ('+' == *d) {
            *d = ' ';
            s++;
            d++;
            continue;
        }

        if ('%' == *d) {
            s++;
            c = ahex2u( s );
            if (0 == c) break;
            *d = c;
            s += 2;
            d++;
            continue;
        }
        *d = *s;
        s++;
        d++;
    }
}


/* convert FORM GET into something parse weekday or volatile timer can do */
/* static */
void
http_form_timer( int tnum, char *t )
{
        int ch, st, hh, mm, lh, lm, ls, wd, dd, z;
        char *a, a1, *p[6], *r, *v;
        char tn[32],    /* timer name */
             pn[8],     /* program number as text */
             c[128],    /* url-encoded conversion */
             e[64];     /* string for parsers */
        struct sig_s *s;

        memset( c, 0, sizeof(c) );
        http_url_ascii( c, t );

        r = c;
        z = sizeof(tn);

        memset( tn, 0, sizeof(tn) );

        build_form_args( p, 6, c );

        advrlog( LOG_INFO, "%s %s", t);

        advrlog( LOG_INFO, "%s '%s' '%s' '%s' '%s' '%s' '%s'",
                WHO, p[0], p[1], p[2], p[3], p[4], p[5] );

        ch = st = lm = wd = dd = 0;
/*
    The following can't be blank: ch, name, start time, len.
    If weekday or date are blank, it's a volatile for today,
     or for tomorrow if the start time is past the current time.
*/
        if (NULL == p[0]) return;
        if (strlen(p[0]) < 1) return;

        ch = atoi( p[0] );
        if ( (ch < 0) || (ch > scan_idx) ) return;
        advrlog( LOG_INFO, "ch %d", ch );

        s = &ptc[ ch ].sig;
        *pn = 0;
        if (s->pn > 0)
            snprintf(pn, sizeof(pn), ".%d", s->pn);

        advrlog( LOG_INFO, "pn %d", s->pn );

        if (NULL == p[1]) return;
        if (strlen( p[1]) < 1) return;

/* preserve the append flag */
        a1 = 0;
        a = strchr(p[1], '@');
        if (NULL == a) a = strchr(p[1], '#');
        if (NULL != a) a1 = *a;
    
        event_truncate( tn, p[1], 2, sizeof( tn ));

        if (a1 > 0) asnprintf( tn, sizeof(tn), "%c", a1);

        if (0 == *tn) return;
        advrlog( LOG_INFO, "tn %s", tn );

        if (NULL == p[2]) return;

//      if (strlen(p[2]) < 5) return;

/* start time */

/* no colon assumes 0000-2359, could get fancy & add a/p check too */
        v = strchr( p[2], ':' );
        if (NULL != v) {
            *v = 0;
            v++;
            hh = atoi( p[2] );
            mm = atoi( v );
        } else {
            hh = atoi( p[2] ) / 100;
            mm = atoi( p[2] ) % 100;
        }

        if ((hh < 0) || (hh > 23)) return;
        if ((mm < 0) || (mm > 59)) return;


        st = utsmid + (SECHR * hh) + (SECMIN * mm);
        advrlog( LOG_INFO, "hh:mm %02d:%02d st %d", hh, mm, st );

        if (NULL == p[3]) return;
        if (strlen(p[3]) < 1) return;

/* minutes can have hours with a colon, otherwise it's minutes only */
        v = strchr( p[3], ':' );
        if (NULL != v) {
            *v = 0;
            v++;
            lh = atoi( p[3] );
            lm = atoi( v );
            lm += (lh * 60);
        } else {
            lm = atoi( p[3] );
//          lh = atoi( p[3] ) / 100;
//          lm = atoi( p[3] ) % 100;
        }

//      lm = atoi( p[3] );
        ls = SECMIN * lm;

/* limit to one day */
        if ( (lm < 1) || (lm > 1440) ) return;

/* FIXME: fails on DST change as next day */
        if ( (st+ls) < utsnow) st += SECDAY;

/* scan count instead of ptc max */
        if ( (st+ls) < utsnow) return;

        if (NULL != p[4])       wd = abtou( p[4] );
        advrlog( LOG_INFO, "wd %d", wd );

/* TODO: p[5] future date */
        if (NULL != p[5])       dd = atoi(  p[5] );
        advrlog( LOG_INFO, "dd %d", dd );

        memset(e, 0, sizeof(e));

        if (0 == wd) {
            if (0 == dd) {

/* old volatile format */
                snprintf(e, sizeof(e), "V%02d:%010d:%03d:%s%s",
                        ch, st, lm, tn, pn );
            } else {

/* new volatile format */
                snprintf(e, sizeof(e), "V%02d:%08d:%02d:%02d:%03d:%s%s",
                        ch, dd, hh, mm, lm, tn, pn );
            }
            parse_volatile_timer( &e[1] );

        } else {
            if (0 == dd) {
                snprintf(e, sizeof(e), "W%02d:%02d:%02d:%03d:%7s:%s%s",
                        ch, hh, mm, lm, p[4], tn, pn );
                parse_weekday_timer( &e[1] );
            } else {
                dvrlog( LOG_INFO, "%s weekday and date not allowed %s",
                        WHO, t);
                return;
            }
        }

        timer_sort = ~0;
        sort_timers();

        refresh.timers = 1;

/* TESTME: run update now? it runs within 1s */
        show_timers();

        advrlog( LOG_INFO, "%s %s", WHO, e);
}


/* add timer can call parse volatile timer, but have to sort list and redraw */
/* static */
void
http_add_epg_timer ( int tnum, char *p )
{
        int ch, st, mt;
        struct qtimer_s *t;
        char *r;

        r = "";
        st = 0;
        mt = 0;
        p++;
        ch = atoi( p );
        r = strchr( p, ':' );
        if (NULL != r) {
            r++;
            st = atoi( r );
            r = strchr( r, ':' );
        }

/* don't add bogus timer */
        if (st < 1) return;

/* don't add overlapping timer */
        if (CAP_TIME == cap_now ) {
            t = &timer[0];
            if ( (st >= t->start) && (st < (t->start + t->len)) )
                return;
        }

        advrlog( LOG_INFO, "%s %d %d %s", WHO, ch, st, r );

/* stop any info cap before parsing the timer */
        if (st <= utsnow) {
            if (CAP_INFO == cap_now) {
                stop_capture( WHO, 0 );
                nanosleep( &signal_long_sleep, NULL );
            }
        }

        parse_volatile_timer( p );
/* volatile timer needs to be saved and console timer list updated */
        display_type = D_TIMERS;
        refresh.timers = 1;
        sort_timers();
        save_config( WHO );

/* current event will wait 4s until cap starts before refreshing page */
//      if (st <= utsnow) nanosleep( &msg_longer_sleep, NULL );
}

/* Extract channel, program number and start time. If match on timer list,
    remove it. This only removes the timer and not the capture file.
    If a capture is in progress, it will be stopped but not deleted.
    If first char of p is V, only timers without daybits will be removed.
    If first char of p is W, only timers with daybits will be removed.
    If first char of p is neither W nor V, nothing will be done.
*/
/* static */
void
http_del_timer ( int tnum, char *s )
{
        int i, ch, st, lm, ls, pn, tt;
        struct qtimer_s *t;
        char *p[8], *n, *r;

        advrlog( LOG_INFO, "%s s %s", WHO, s);
        tt = 0;
        if ('V' == *s) tt = 1;
        if ('W' == *s) tt = 2;

/* skip 'V' or 'W' char */
        s++;
        build_args( p, 4, s, ':', WHO );

        st = lm = ls = ch = pn = 0;
        n = NULL;

/* sanity checks */
        if ( NULL == p[0] ) return;
        ch = atoi( p[0] );
        advrlog( LOG_INFO, "%s ch %d", WHO, ch);

        if ((ch < 0) || (ch > ptc_max)) return;

        if ( NULL != p[1] ) st = atoi( p[1] );
        advrlog( LOG_INFO, "%s st %d", WHO, st);

        if ( NULL != p[2] ) lm = atoi( p[2] );
        if (lm < 1) return;
        ls = SECMIN * lm;

        if ((st+ls) < utsnow) return;
        advrlog( LOG_INFO, "%s ls %d", WHO, ls);

        if ( NULL != p[3] ) n = p[3];
        if (0 == *n) return;

        advrlog( LOG_INFO, "%s n %s", WHO, n);

        r = strrchr( n, '.' );
        pn = 0;
        if (NULL != r) {
            r++;
            pn = atoi( r );
        }
        if (pn < 1) return;
        advrlog( LOG_INFO, "%s pn %d", WHO, pn);

        ahttp_log( tnum, "%s tt %d ch %d.%d n %s st %d ls %d",
                    WHO, tt, ch, pn, n, st, ls);

/* start the loop */
        for (i = 0; i < timer_idx; i++) {
                t = &timer[i];
                if ( (ch == t->chan)
                  && (pn == t->pn)
                  && (st == t->start)
                  && (ls == t->len)
#if 0
/* name could be anything because of extra flags */
                 && (0 == strncmp( n, t->name, TIMER_NAME_MAX))
#endif
                    )
                {
                    if ((1 == tt) && (0 == t->days)) {
                        ahttp_log( tnum, "del vtimer[%d] %d.%d %d %d %s",
                                    i, ch, pn, st, ls, n);
                        delete_timer( i, WHO );
                    }

                    if ((2 == tt) && (0 != t->days)) {
                        ahttp_log( tnum, "del wtimer[%d] %d.%d %d %d %s",
                                    i, ch, pn, st, ls, n);
                        delete_timer( i, WHO );
//                      reschedule_timer( i, WHO );
                    }
                }
        }

/*      save_config( WHO ); // delete timer did this */
        refresh.timers = 1;
}

/* Extract channel, program number and start time. If match on timer list,
    remove it. This is different from http_del timer because it deletes
    the .ts capture, the .tsx frame and the .html log files.
*/
/* static */
void
http_zap_timer ( int tnum, char *p )
{
        int ch, st, ls, pn, i;
        char *n, *r;
        struct qtimer_s *t;

/* only if a timer cap is running, manual cap control requires console */
        if (CAP_TIME != cap_now) return;
        advrlog( LOG_INFO, "%s %s", WHO, p);

        p++;
        ch = ls = st = pn = 0;

        n = "";
        ch = atoi( p );
        r = strchr( p, ':');
        if (NULL != r) {
            r++;
            st = atoi( r );
            r = strchr( r, ':' );
            if (NULL != r) {
                r++;
                ls = atoi( r );
                r = strchr( r, ':' );
                if (NULL != r) {
                    r++;
                    n = r;
                }
            }
        }


        if (0 == *n) return;

        r = strrchr( n, '.' );
        if (NULL != r) {
                r++;
                pn = atoi( r );
        }

        ahttp_log( tnum, "zap timer[%d] %d.%d %d %d %s",
                    timer_rec, ch, pn, st, ls, n);

/* check for each match in this order of precedence: channel pgm start */
        t = &timer[timer_rec];
        if (ch != t->chan) return;
        if (pn != t->pn) return;
        if (st != t->start) return;

        ahttp_log( tnum, "zapping timer %d", timer_rec);

/* if match found. cap stops and timer is removed from RAM + config file */
        cap_zap = ~0;                           /* zap deletes current cap */
/*      stop_capture( WHO, 0 ); / / delete timer handles this */
        delete_timer( timer_rec, WHO );

/* wait til cap done for guide refresh, is ts capture async thread event */
/* four tries, but two seconds is enough for xfs not ext2/3 */
        i = 4;
        while( 0 == cap_done) {
            nanosleep( &guide_sleep, NULL); /* half second wait */
            if (0 == i--) break; /* two second max */
        }
}

/* static */
void
http_zap_info ( int tnum, int ch )
{
        if (ch == cap_chan) {
            if (CAP_INFO == cap_now) {
                cap_now = CAP_NONE;
            ahttp_log( tnum, "zap info %d %d", WHO, ch, cap_now );
            }
        }
}

/* static */
void
http_toggle_find ( int tnum, int ch )
{
        pgm3.find = ~pgm3.find;
        ahttp_log( tnum, "toggle find %d %d", ch, pgm.find );
}

/* static */
void
http_toggle_spam ( int tnum, int ch )
{
        pgm3.hide = ~pgm3.hide;
        ahttp_log( tnum, "toggle spam %d %d", ch, pgm.hide );
}

/* static */
void
http_toggle_aged ( int tnum, int ch )
{
        pgm3.age = ~pgm3.age;
        ahttp_log( tnum, "toggle aged %d %d", ch, 1 & pgm3.age );
}

/* Enable/disable signal chart display. saved in .conf on I line */
/* static */
void
http_set_sigpng ( int tnum, int a )
{
        if (0 == a) scan_png = 0;
        if (0 != a) scan_png = ~0;
        http_log( tnum, "set PNG %d", 1 & scan_png );
}

/* static */
void
http_toggle_sigsnr ( int tnum )
{
        scan_snr = ~scan_snr;
        ahttp_log( tnum, "set SNR %d", 1 & scan_snr );
}

/* static */
void
http_toggle_sigkhz ( int tnum )
{
        scan_khz = ~scan_khz;
        ahttp_log( tnum, "set KHz %d", 1 & scan_khz );
}

/* toggle signal for all channels on and off. if not capturing. */
/* static */
void
http_scan_all ( int tnum, int op )
{
        if (CAP_NONE != cap_now) return;
#ifdef USE_POWERDOWN
        utspdd = utsnow + USE_POWERDELAY;
#endif
        if (0 == op) {
                scan_sig = 0;
                scan_one = ~0;
        } else {
                scan_sig = ~0;
                scan_one = 0;
        }
/* keep show channels display redux from limiting web started scan */
        display_type = D_TIMERS;
        set_refresh();
}

/* signal scan on for ch, or scan off if ch is zero */
/* do nothing if in capture, but could use it to toggle -x option? */
/* static */
void
http_scan_one ( int tnum, int ch )
{
        if (CAP_NONE != cap_now) return;

#ifdef USE_POWERDOWN
        utspdd = utsnow + USE_POWERDELAY;
#endif

/* toggle on and off, or jump to new channel */
        if ((0 != scan_sig) && (cap_chan == ch)) {
/* turn off signal scan */
                scan_sig = 0;
        } else {

/* scan_next 0 is nop, 1st channel is selected with 1 by console scan() */
                scan_next = 1 + get_scanlist_offset( ch );
                scan_sig = ~0;
                scan_one = ~0;
                scan_pos = ch;
                cap_chan = ch;
                load_guide( ch, WHO );
        }

/* kick console back to timer list so signal scan can run */
        display_type = D_TIMERS;
        set_refresh();
}

/* zap, lightning bolt img, delete .ts, .tsx, .html matching file s */
/* static */
void
http_unlink_cap( int tnum, char *s)
{
        int ch;
        char f[256], n[256], *r, *p;
        struct wss_s *w;
        struct tts_s *t;
        
        w = &wss;
        t = &w->tss[tnum];

        ch = 0;
        r = strchr( s, ':' ); /* ch:file.ts updates epg ch; file.ts no epg */
        if (NULL != r) {        /* has : ? */
            ch = atoi(s);       /* extract channel */
            r++;                /* skip to filename */
        } else {
            r = s;              /* file name only */
        }

/* only .ts files */
        filebase( n, r, F_TFILE );

        p = s;
        if (strlen(p) < 4) return;
        p += strlen(p);
        p -= 3;
        if (0 != strncmp(p, ".ts", 4)) return;

/* only if current working directory is / or /cut/ */
        if (0 != strncmp( t->cwd, "/", 2))
            if (0 != strncmp( t->cwd, "/cut/", 6))
                return;
        
        ahttp_log( tnum, "unlink %d %s %s %s .*", ch, w->root, t->cwd, n );

/* NOTE: unlink 0 is not return code for unlink, 0 is channel # if from EPG */
        snprintf( f, sizeof(f), "%s%s%s.tsx", w->root, t->cwd, n );
        ahttp_log( tnum, "unlink %d %s", ch, f );
        unlink( f );

        snprintf( f, sizeof(f), "%s%s%s.tsc", w->root, t->cwd, n );
        ahttp_log( tnum, "unlink %d %s", ch, f );
        unlink( f );

        snprintf( f, sizeof(f), "%s%s%s.html", w->root, t->cwd, n );
        ahttp_log( tnum, "unlink %d %s", ch, f );
        unlink( f );

/* ts file last */
        snprintf( f, sizeof(f), "%s%s%s.ts", w->root, t->cwd, n );
        ahttp_log( tnum, "unlink %d %s", ch, f );
        unlink( f );
        sync();

/* wait a second so the new index.html will reflect free space */
        nanosleep( &msg_sleep, NULL );
}

/* t has ch:name to add or remove from search list */
/* static */
void
http_search( int tnum, char *t )
{
        int i, j, ch;
        char *n;

        ch = atoi( t );
        n = strchr(t, ':');
        if (NULL == n) return;
        n++;

        i = find_search_timer( n );
        if (-1 == i) {

/* if not found, add it */
            j = add_search( n, ch );
            advrlog( LOG_INFO, "%s add search %s %d", WHO, n, search_idx);
            if (-1 != j) {
                sort_searchlist();
            }
        } else {

/* if found, remove it */
            delete_search_event( i, WHO );
            advrlog( LOG_INFO, "%s del search %s %d", WHO, n, search_idx);
        }
        save_config( WHO );

        display_type = D_TIMERS;
        refresh.timers = 1;
}

/* p is trunc event name:time to add or remove from spam list */
/* FIXME? build epg href is broken with ch:name right now */
/* static */
void
http_spam( int tnum, char *p )
{
        int i, t;
        char *s;

        s = strchr(p, ':');
        if (NULL == s) return;
        *s = 0;
        s++;
        sscanf( s, "%d", &t);

        i = test_spam_name( p );
        if (-1 == i) {

/* if not found, add it */
            add_spam( p, t );
            sort_spamlist( 0 ); /* sort by name for fast lookup */
        } else {

/* if found, remove it */
            delete_spam( i );
        }
        save_spamlist( WHO );
}

/* toggle auto-epg status for ch and dump html stats to reflect it */
/* static */
void
http_auto_epg( int tnum, int ch )
{
        struct sig_s *s;

        s = &ptc[ ch ].sig;

        if (ch != s->chan) return;

/* toggle */
        if (0 == s->pgto) {
/* add to auto epg list */
                s->pgto = 1; /* 3hr timeout */
                s->pgmt = 0;

/* triggers immediate test and load if expired */
                utstpg = 0;
        } else {

/* remove from auto epg list */
                s->pgto = 0;
                s->pgmt = 0;
        }

/*      dump_html_stats( WHO ); */ /* request does this now */
        advrlog( LOG_INFO, "%s ch %02d to %d", WHO, ch, s->pgto);
        utstpg = 0;
}

/* static */
void
http_toggle_weekdays( char *p )
{
        int ch, i, days;
        char n[TIMER_NAME_MAX], *r, *s;
        struct qtimer_s *t;

        advrlog( LOG_INFO, "%s1 p %s", WHO, p);

/* need all 3: ch:name:weedaybits */

/* strip channel */
        r = strchr(p, ':');
        if (NULL == r) return;
        *r = 0;
        r++;
        ch = atoi(p);

/* strip any thing following name */
        astrncpy(n, r, sizeof(n));
        advrlog( LOG_INFO, "%s2 n %s", WHO, n);
        s = strchr(n, ':');
        if (NULL != s) *s = 0;

/* strip weekday bits */
        s = strchr(r, ':');
        if (NULL == s) return;
        *s = 0;
        s++;

        days = atoi(s);

        dvrlog( LOG_INFO, "%s3 n %s c %d d %d ", WHO, n, ch, days);

        for (i=0; i<timer_idx; i++) {
            t = &timer[i];
            if (T_SEARCH == t->qstat) continue;
            if (0 == t->days) continue;
            if (0 != strncmp(n, t->name, TIMER_NAME_MAX)) continue;

/* XOR the new day bits */
            days ^= t->days;

/* don't let it remove the only weekday, thus converting it to volatile */
            if (0 == days) break;
            t->days = days;

/* need to save the changes */
            save_config( WHO );

            calc_first_weekday(t);
            t->future = calc_future_date(i);
            display_type = D_TIMERS;
            timer_sort = 1;
            sort_timers();

/* update console too */
            refresh.timers = 1;
            show_timers();
            break; /* only process first set day bit */
        }
}

/* static */
void
http_set_vc( char *p )
{
        char *r;
        int vn, va, ch;
        struct sig_s *s;

        refresh.vstats = 1;

        ch = cap_chan;
        r = p;
        va = 0;
#if 0
/* FIXME: http desync problem, make url specify channel to change vc/va.
   It's not really a problem, more of a limitation during capture.
*/
        ch = atoi(r);
        r = strchr(p, ':');
        if (NULL != r) {
            r++;
            *r = 0;
        }
#endif
        s = &ptc[ch].sig;

        vn = atoi(p);

/* always can toggle mpeg and atsc stats */
        if (-2 == vn) s->ms = ~s->ms;
        if (-3 == vn) s->as = ~s->as;

/* only idle can change capture vc via web ui */
        if (CAP_NONE != cap_now) return;

        r = strchr(p, ',');
        if (NULL != r) {
                r++;
                va = atoi(r);
        }

/* TODO: set full cap stat, no href for it yet. has dubious value. */
        if (-1 == vn) {
             s->pn = s->vc = s->va = cap_pn = cap_vc = cap_va = -1;
        }

/* FIXME: check for valid program # or valid vc structure at least */
        if (vn >= 0) {
            s->vc = vn;
            s->pn = vc[vn].pn;
            s->va = va;

/* set next manual capture parameters (only affects console for now) */
            cap_vc = vn;
            cap_pn = s->pn;
            cap_va = va;
        }
}

/* static */
void
http_epg_setday( char *p )
{
        int ch, dn;
        char *r;
        struct sig_s *s;

        ch = atoi( p );
        if ((ch >= ptc_max) || (ch < 0)) return;
        s = &ptc[ch].sig;

/* set to today in case the parse fails */
        s->yday = tloc.tm_yday;
        r = strchr( p, ':');
        if (NULL == r) return;
        r++;
        dn = atoi(r);
        if ( (dn < 0) || (dn > 365) ) return;
        s->yday = dn;
        advrlog( LOG_INFO, "%s %d:%d", WHO, ch, dn);
}


/*****************************************************************************
 Pseudo-CGI interface. Normally, CGI runs an executable but that's not used
    here since these commands change internal settings that a script can't.

    All of these should do some kind of page refresh so user sees update.

    Trying to use single letters to keep the generated HTML fairly small.
    Most of these return HTTP 200 or 201.

        201 is used when the user change has data immediately available.

        202 is used when doing EPG load; unknown time until data ready.

    The following options after ? are defined, one per request:
        (n is numeric, s is string)

        a=s     Add volatile timer s from EPG
        b=n     bits to set for sorting index.html
        c=n[,an] -2 & -3 stats detail MPEG/ATSC, n sets VC, an sets audio num
        d=s     Delete timer s
        e=n     Toggle auto-epg for guide n
        f=n     toggle HTML format: 0 HTML 3.2, 1-3 HTML 4.01 + CSS
        g=n     Get guide n, tries to start info cap. uses 202 return.
        h=n     Toggle hide spam for guide n

i unassigned

        j=s     Toggle junk status for s (add/remove from spam list)
        k=n     0 hide 1 show uptime, memory and stats with vc select too
        l=n     toggle EPG legend: 0 hide, 1 show
        m=n     Toggle search match for guide n
        n=n     day number to show for EPGs
        o=n     Toggle hide aged for guide n
        p=n     PNG signal chart toggle 0 off, 1 on
        q=n     Toggle SNR vs Strength%
        r=n     Refresh guide n, saves new version of guide
        s=s     search add/remove

        t=s     FORM GET for weekday or volatile future timer, non EPG

        u=s     Unlink file s (only *.ts in / or cut/ allowed)
        v=n     Start signal scan for channel n, 0 stops scan.
        w=n     signal scan all toggle disable 0 enable 1
        x=n     stop info cap (should be same as zap?)
        y=n     toggle weekdays for weekday timer matching n
        z=n     zap filename (.ts .tsc .tsx .html)

TODO:
        combine o m h into m for mask
*/


/* CGI request is in t->cgi, figure out what to do with it */
/* static */
void
http_cgi( struct tts_s *t )
{
        char *p;
//      char *r;
        char c;
        int ch, op;

        if (NULL == t) return;
        p = t->cgi;
        if (0 == *p) return;

        if ('?' == *p) p++;

#if USE_CGI_NO_EXTRA_PARMS
        r = strchr(p, '&');
        if (NULL != r) *r = 0;
        r = p + strlen(p);
#endif
        op = 0;

        ahttp_log( t->num, "%s %s", WHO, p);
        ch = 0;
        c = *p;
        p++;

/* only allowing single char options */
        if ('=' != *p) return;
        p++;

/* s is before = char, p is after */
        switch ( c ) {

/* HTTP t->rnum:
        201 very short delay before reading the requested file
        202 is content created but long delay before part of it arrives
*/


/* set epg grid index */
        case 'i':
                op = atoi( p );
                op /= 3600;
                op *= 3600;
                epg_gs = op;
                break;


/* add timer */
        case 'a':
                http_add_epg_timer( t->num, p );
                t->rnum = 201;
                break;

/* cap/cut dir index.html sorted by date or name */
        case 'b':
                op = atoi( p );
                idx_sort = op;
                advrlog( LOG_INFO, "http idx sort %0X", op);
                t->rnum = 201;
                break;

/* set virtual channel to 0-n, or:
    -1 sets full cap,
    -2 enables mpeg stats render
    -3 enables atsc stats render
    if v channel has a comma, it uses value after comma for v audio ch
*/
        case 'c':
                http_set_vc( p );
                refresh.vstats = 1;
                refresh.estats = 1;

                advrlog( LOG_INFO, "http idx sort %0X", op);
                t->rnum = 201;
                break;

/* delete timer */
        case 'd':
                http_del_timer( t->num, p );
                t->rnum = 201;
                break;

/* toggle auto guide */
        case 'e':
                ch = atoi( p );
                http_auto_epg( t->num, ch);
                t->rnum= 201;
                break;

/* set HTML format */
        case 'f':
                op = atoi( p );

/* bit 4 is all/one-day-pgm toggle */
                if (0 != (16 & op)) epg_all = ~epg_all;

/* bit 3 is srollbar toggle */
                if (0 != (8 & op)) epg_sb = ~epg_sb;

/* bit 2 is grid setting */
                if (0 != (4 & op)) epg_grd = ~epg_grd;

/* bits 0 and 1 are 0=no css, 1=large, 2=small, 3=tiny */
                if (0 == (0x1C & op)) use_css = 3 & op;
                save_config( WHO );
                t->rnum = 201;
                break;

/* get guide */
        case 'g':
                ch = atoi( p );
                http_reload_epg( t->num, ch );
/* accepted: content created but long delay before part of it arrives */
                t->rnum = 202; /* was 202, trying 201 now? */
#ifdef USE_POWERDOWN
                utspdd = utsnow + 180 + USE_POWERDELAY;
#endif
                break;


/* filter toggle spam/junk match hidden */
        case 'h':
                ch = atoi( p );
                if (ch >= ptc_max) break;
                http_toggle_spam( t->num, ch );
                t->rnum = 201;
                break;      

/* toggle event junk status */
        case 'j':
                http_spam( t->num, p);
                t->rnum = 201;
                break;

/* extended statistics toggle */
        case 'k':
                op = atoi( p );
                web_stats = op;
                t->rnum = 202;
                break;

/* PNG legend toggle doesn't care which html page is being displayed */
        case 'l':
                op = atoi( p );
                if (0 != (1 & op)) web_legend = ~web_legend;
                if (0 != (2 & op)) web_config = ~web_config;
                advrlog( LOG_INFO, "op %d config %d legend %d",
                        op, web_config, web_legend);
                t->rnum = 201;
                break;

/* filter toggle timer/search match hidden */
        case 'm':
                ch = atoi( p );
                if (ch >= ptc_max) break;
                http_toggle_find( t->num, ch );
                t->rnum = 201;
                break;      

/* set day# to use for EPG, or zero for all days */
        case 'n':
                http_epg_setday( p );
                t->rnum = 201;
                break;

/* filter toggle aged/expired hidden */
        case 'o':
                ch = atoi( p );
                if (ch >= ptc_max) break;
                http_toggle_aged( t->num, ch );
                t->rnum = 201;
                break;      

        case 'p':
                op = atoi( p );
                http_set_sigpng( t->num, op );
                t->rnum = 202;
                break;

        case 'q':
                op = atoi( p );
                if (1 & op) http_toggle_sigsnr( t->num );
                if (2 & op) http_toggle_sigkhz( t->num );
                t->rnum = 202;
                break;

#if 0
/* this is now equivalent to requesting ch.html. is for href img */
/* refresh guide to update 'current' and 'aged' status */
        case 'r':
                ch = atoi( p );
                if (ch >= ptc_max) break;
                t->rnum = 201;
                break;
#endif

/* toggle event search status */
        case 's':
                http_search( t->num, p );
                t->rnum = 201;
                break;

/* timer for any or all weekdays *or* volatile timer for any future event */
        case 't':
                p--;
                p--;
                http_form_timer( t->num, p );
                t->rnum = 202;
                break;

/* delete capture .ts file, .tsx frame data file and .html log file */
        case 'u':
                t->rnum = 201;
                http_unlink_cap( t->num, p);
                break;

/* start or stop signal scan for one channel, if not capturing */
        case 'v':
                op = atoi( p );
                http_scan_one( t->num, op );
                t->rnum = 202;
                break;

/* toggle scanning all channels */
        case 'w':
                op = atoi( p );
                http_scan_all( t->num, op );
                t->rnum = 202;
                break;

/* interrupt info cap */
        case 'x':
                ch = atoi( p );
                http_zap_info( t->num, ch );
                t->rnum = 201;
                break;

/* toggle weekday bits */
        case 'y':
                http_toggle_weekdays(p);
                advrlog( LOG_INFO, "http toggle weekdays %s", p);
                t->rnum = 201;
                break;

/* zap is same as delete timer plus unlink capture */
        case 'z':
                http_zap_timer(t->num, p);
                t->rnum = 201;
                break;

        default:
                break;
        }
}

/* accept a TCP connection, if it passes test_host_allow check */
/* static */
int
http_accept ( struct wss_s *w, int tnum )
{
        int ok;
        struct tts_s *t;
        time_t now;
//      socklen_t z = sizeof(struct sockaddr_in);
        socklen_t z;

        z = sizeof(struct sockaddr);
    
        t = &w->tss[ tnum ];

        ahttp_log( tnum, "%s blocks... z %d, tnum %d", WHO, z, tnum);

/* blocks and waits to accept a connection */
        t->accepted = accept( w->sock, (struct sockaddr *)&t->remote_addr, &z );

        ahttp_log( tnum, "%s unblocks z %d", WHO, z);

        if (-1 == t->accepted) {
                http_log( tnum, "accept() failed %d", tnum, errno);
                return -1;
        }

        uintodot( t->remote_number, ntohl(t->remote_addr.sin_addr.s_addr) );
/* copy number to name in case address does not resolve */
        astrncpy( t->remote_name, t->remote_number, sizeof(t->remote_name) );

        ahttp_log( tnum, "%s remote is %08X %s", WHO,
                    ntohl(t->remote_addr.sin_addr.s_addr),
                    t->remote_name);

        z = sizeof(struct sockaddr_in);

/* get the local socket IP address for netmask test */
        ok = getsockname( t->accepted,
                    (struct sockaddr_in *) &t->local_addr, &z );
        if (0 != ok) {
                http_log( tnum, "accept failed, no local IP address?");
                return -1;
        }

/* fill in name from -whost arg */
        astrncpy( t->local_name, arg_whost, sizeof(t->local_name) );

        ahttp_log( tnum, "%s local is  %08X %s", WHO,
                    ntohl(t->local_addr.sin_addr.s_addr),
                    t->local_name);

/* accept time */
        now = time(NULL);
        ctime_r( &now, t->date );
        t->date[16] = 0;

/* remote and local address same doesn't need access control */
        if (t->remote_addr.sin_addr.s_addr == t->local_addr.sin_addr.s_addr) {
                strncpy(t->remote_name, t->local_name, sizeof(t->remote_name));
                ahttp_log( t->num, "accept localhost");
                return 0;
        }

/* not same address, check netmask for access control */
        if ( 0 == http_test_netmask( htonl(t->remote_addr.sin_addr.s_addr),
                            htonl(t->local_addr.sin_addr.s_addr), w->mask) ) {
/* if subnet mask non-zero, but passes netmask test, don't check hosts.allow */
                if (0 != w->mask) {
                    ahttp_log(  t->num, "accept subnet %s", t->remote_name);
                    return 0;
                }
        }

/* not in subnet or subnet mask 0, check hosts.allow for access control */
        if (0 == http_test_allows( t, &t->remote_addr )) {
                ahttp_log( t->num, "accept name %s", t->remote_name);
                return 0;
        }

/* slam the door closed, no popup in mozilla saying "no data" */
        http_log( t->num, "accept refused %s (%s)",
                t->remote_name, t->remote_number );

        shutdown( t->accepted, SHUT_RDWR );
        close( t->accepted );
        t->accepted = -1;
        return -1;
}

/* store If Modified Since GMT date as local adjusted time_t for 304 return */
/* static */
void
http_ims( struct tts_s *t, char *p )
{
        struct tm imtm;
        char *r, d[64];

        memset( &imtm, 0, sizeof(imtm) );
        memset( &d, 0, sizeof(d) );
        astrncpy( d, p, sizeof(d) );

        r = strchr(d, '\n');
        if (NULL != r) *r = 0;
        r = strchr(d, '\r');
        if (NULL != r) *r = 0;
        r = strptime( d, "%a, %d %b %Y %T %Z", &imtm );
        if (NULL != r) t->imstime = mktime( &imtm ) + utsgmt;
//      ahttp_log( t->num, "%s:%d %d %s", WHO, WHERE, t->imstime, d );
}


/* Read HTTP request and validate it.
    Only GET is supported. This makes t->cwd and t->file.
    Returns 0 for ok, or -1 if request was ignored.
*/
/* static */
int
http_request ( struct wss_s *w, int tnum )
{
    int i, 
        recvd,
        ok,
        rfs,
        ch,             /* channel number */
        a;              /* alpha channel for sig png */

    char *p,
        *r,
        *rt,
        *s[4],
        req[ WWW_TCP_MAX ],
        fn[ WWW_TCP_MAX ],
        rfile[ WWW_TCP_MAX - WWW_ROOT_MAX ],
        rver[ 16 ];

    struct stat64 fs;
    struct tts_s *t;
    struct timeval rfto;
    fd_set rfds;
    
    t = &w->tss[ tnum ];

    if (NULL == t) {
            dvrlog( LOG_INFO, "%s has null thread %d pointer", WHO, tnum);
            return -1;
    }

/* default is this if nothing else done */
    t->rnum = 200;

    strcpy( t->cwd, "/" );
    strcpy( t->file, "index.html");
    
    recvd = 0;
    t->ka = t->utska - utsnow;
    while ( utsnow < t->utska ) {
        if (-1 == t->accepted) return -1;

        t->ka = t->utska - utsnow;
        if (t->ka < 0) t->ka = 0;
        if (0 == t->ka) return -1;

        rfto.tv_sec = t->ka;
        rfto.tv_usec = 0;

/* select is 1 if ok to read data */
        FD_ZERO( &rfds );
        FD_SET( t->accepted, &rfds );
        rfs = select( t->accepted+1, &rfds, NULL, NULL, &rfto);
        
/* stop looping once read data becomes available */
        if (1 != rfs) {
/* CPU redux */
            nanosleep( &console_read_sleep, NULL );
            continue;
        }
        if (!FD_ISSET(t->accepted, &rfds)) return -1;

/* get HTTP request */
        recvd = recv(t->accepted, t->request, WWW_TCP_MAX, 0);
        if (recvd > 0) break;
        return -1;
    }

    if (0 == recvd) return -1;

/* NUL term the request */

    t->request[recvd] = '\0';
    astrncpy( req, t->request, sizeof(req));
    
/* break apart request into 3 individual strings */
    p = req;
    ahttp_log( tnum, "Request: %s", p);

/* request should have NL [or CR/NL?], trunc everything after it */
    r = strchr( p, '\n');
    if (NULL == r) {
        t->request[32] = 0;     // truncate the bogus request
        http_log( tnum, "ignoring %s", t->request);
        return -1;
    }
    *r = 0;
    r = strchr( p, '\r'); // truncate NL and CR
    if (NULL != r) *r = 0;

    for (i = 0; i < 3; i++) {
        s[i] = p;
        if (0 == *p) break;
        r = strchr( s[i], ' ');
        if (NULL == r) break;
        *r = 0;
        r++;
        p = r;
    }

/* not three parameters? */
    if (i < 2) {
        http_log( tnum, "ignoring %s", req, t->rfile);
        return -1;
    }

/* req is already loaded with first parm */
    astrncpy( rfile, s[1], sizeof(rfile));
    astrncpy( rver,  s[2], sizeof(rver));

/* extract file request: add root, add index.html if request is path delim */
//    sscanf(t->request, "%s %s %s", req, t->rfile, rver);

    astrncpy( t->rfile, rfile, sizeof(rfile) );

/* don't log the image GETs, is TMI */
    if (NULL == strstr( t->rfile, ".png" )) {
        ahttp_log( t->num, "%s %s %s %s",
                    t->remote_number, req, rfile, rver );
    }

/* HTTP 1.1 if greater than 1.1, else HTTP 1.0 */
    t->htver = 0; /* default is old style for old clients */
    if (0 == strncmp(rver, "HTTP/1.", 7) ) {
        t->htver = atoi( &rver[7] );
        if (t->htver > 1) t->htver = 1; /* used for response control */
    }

    ahttp_log( t->num, "Request version: [%s], reply HTTP/1.%d",
        rver, t->htver);

/* limit output to headers only, if not GET, for link-checkers */
    t->rtype = 0;

    if (0 == strncmp( req, "GET", 4))  t->rtype = 1;

    if (0 == t->rtype) {
        http_log( tnum, "ignoring %s %s", req, t->rfile);
        return -1;
    }

    r = rfile;

/* any ../ badness? */
    p = strstr( r, "../" );
    if (NULL != p) {
        dvrlog( LOG_INFO, "remove ../ from %s", r);
/* remove it */
        while (NULL != p) {
            p = r + 3;
/* any more left? FIXME: trailing ../ without / prior is ok? NO */
            r = strstr( p, "../" );
            if (r != NULL) continue;
/* set r to last p */
            r = p;
            p = NULL;
/* stop the loop */
            dvrlog( LOG_INFO, "removed ../ now %s", r);
            break;
        }
    }

/* skip initial duplicate /'s */
    while ( ('/' == r[0]) && ('/' == r[1]) ) r++;

/* reset cgi string */
    *t->cgi = 0;

/* CGI parse re-uses p, it gets re-used again */
    p = strchr(r, '?');

    if (NULL != p) {
        if (strlen(p) > 1) { /* need more than ? by itself */
            astrncpy( t->cgi, p, WWW_ROOT_MAX); /* true, has cgi */
        }

/* remove cgi from request */
        *p = 0;
/* set to null so re-use will force segfault if not re-used correctly */
        p = NULL;
    }

    if (0 != *t->cgi) ahttp_log( t->num, "CGI %s", t->cgi);

    advrlog( LOG_INFO, "request remaining %s", r);

    if (strlen(r) > 0)
    {

/* if last char is path delim then entire request is new dir + index.html */
        if ( '/' == r[ strlen(r) - 1 ] ) {
                astrncpy( t->cwd, r, sizeof( t->cwd) );
                r = "index.html";
                astrncpy( t->file, r, sizeof( t->file ));
        }

/* any path left must be new dir */
        p = strrchr(r, '/');
        if (NULL != p) {
                *p = 0;
/* copy directory and put ending / back in */
                snprintf( t->cwd, sizeof(t->cwd), "%s/", r);
/* point to file */
                r = p;
                r++;
        }

/* copy file */
        astrncpy( t->file, r, sizeof( t->file ) );

    } else { /* blank request gets /index.html */
            strcpy( t->cwd, "/" );
            strcpy( t->file, "index.html" );
    }

/* hosts.allow should not be retrievable */
    if (NULL != strstr(t->file, "hosts.allow")) {
            strcpy( t->cwd, "/" );
            strcpy( t->file, "index.html" );
    }
            
/* filename and path should be parsed into t-> by this point */

    snprintf(fn, sizeof(fn), "%s%s%s", w->root, t->cwd, t->file);

/* atscap* and pg/ in ram, fix dir for test */
    if (0 != arg_tmpfs) {
        if ( (NULL != strstr( t->cwd, "pg/" ))
          || (NULL != strstr( t->file, NAME )) )
        {
            snprintf( fn, sizeof(fn), "%s/ram%s%s", w->root, t->cwd, t->file);
        }
    }

    ok = stat64( fn, &fs );
    ahttp_log( tnum, "%s:%d stat64 %d %s", WHO, __LINE__, ok, fn);

/* stat worked, root+cwd is good, otherwise fix name to /index.html */
    if (0 != ok) {
        strcpy( t->cwd, "/");
        strcpy( t->file, "index.html" );
        t->rnum = 302; /* redirect to root if dir not found */
    }


/* full content is default */
    t->rseek = 0LL;

/* is partial content request? mplayer can use stream slider, xine can not */
    rt = "Range: bytes=";
    p = strstr( t->request, rt );
    if (NULL != p) {
        p+= strlen(rt);
        sscanf( p, "%lld", &t->rseek);
    }

    ahttp_log( tnum, "requests %s %s seek %lld", t->cwd, t->file, t->rseek);

    t->imstime = 0;
    rt = "If-Modified-Since: ";
    p = strstr( t->request, rt );
    if (NULL != p) {
        p += strlen(rt);
        http_ims( t, p );
    }

/* default is off for HTTP 1.0 */
    t->ka = 0;

/* my default keep alive is 5 seconds for HTTP 1.1 */
    if (t->htver > 0) t->ka = 5;

    rt = "Connection: ";
    p = strstr( t->request, rt);
    if (NULL != p) {
        p += strlen(rt);

/* HTTP 1.1 defaults to persistent connection, close is now provided */
        if (NULL != strstr(p, "close")) t->ka = 0;

/* HTTP 1.0 compatibility, old buggy ka, give it 15 clicks */
        if (NULL != strstr(p, "Keep-Alive"))
            t->ka = 5;
    }

/* client requests different keep alive? */
    rt = "Keep-Alive: ";
    p = strstr( t->request, rt );
    if (NULL != p) {
        p += strlen(rt);
        t->ka = atoi(p);
        ahttp_log( tnum, "client request %d keepalive", t->ka);
    }

/* keepalive limit */
    if (t->ka > 1) t->ka = 1;

/* tells select when to quit http request */
    t->utska = utsnow + t->ka;
    ahttp_log( tnum, "keepalive %d expires %u", t->ka, t->utska-utsnow);

/* cwd is always / if not specified */
    if (0 == *t->cwd) strcpy( t->cwd, "/");

#ifdef USE_PNG
/* request is for signal strength .png, create latest */
    if (0 == strncasecmp( t->cwd, "/pg/", strlen(t->cwd))) {
        if (NULL != strstr( t->file, ".png")) {

/* skip the devnum- */
            ch = atoi( &t->file[2] );
            if ((ch >= 0) && (ch < ptc_max)) {
                a = 0x6F;

/* PNG OPACITY */

/* scan all or current channel needs more opacity */
                if ( ((0 != scan_sig) && (0 == scan_one))
                  || (ch == cap_chan) ) a = 0xDF;

                build_sig_png( ch, a, WHO );
            }
        }
    }
#endif

/* handle cgi before serving file it might refer to */
    if ('?' == *t->cgi)
        http_cgi( t );

/* individual root file handling, index and top level nav for each server */
    ok = strncmp( t->cwd, "/", 2 ); /* count the nul too */
    advrlog( LOG_INFO, "strncmp t->cwd / %d '%s' '%s'", ok, t->cwd, "/" );

/* breaks w->root only security? */
/*    if (0 == ok) */
    {
        char *x, *y;

/* if file is index.html, need to build a current one */
        ok = strncmp( t->file, "index.html", 11); /* count the NUL too */
        advrlog( LOG_INFO, "strncmp t->file %d '%s' index.html", ok, t->file );
        if (0 == ok) {
            http_index_html( w, tnum, WHO );
        }

/* if file is atscap[arg_dev].html, need to build a current one */
        x = NAME;
        if ( 0 == strncmp( t->file, x, strlen(x)) ) {
            y = ".html";
            if ( 0 == strncmp( &t->file[1+strlen(x)], y, strlen(y)) ) {
                if ( ( '0' + arg_devnum) == t->file[6] ) {
                    dump_cfg_html( WHO );
                }
            }
        }
    }

#if 0
/* failsafe */
    if (0 == *t->cwd) {
        dvrlog( LOG_INFO, "cwd blank!");
        strcpy( t->cwd, "/" );
    }
#endif

    advrlog( LOG_INFO, "%s:%d %s %s %s", WHO, WHERE, w->root, t->cwd, t->file);

/* auto-refresh every time guide html requested in case href changed. */
/* move between instances easier with update of epg to current instance */
    if ( (NULL != strstr( t->cwd, "/pg/"))
      && (NULL != strstr( t->file, ".html")) )
    {

/* is it the big grid or a single epg? */
        if (0 == strncmp( t->file, "grid", 4 )) {
                dump_epg_grid();
        } else {
/* NOTE: is why callsign.html doesn't work */
            ch = atoi( t->file );
            if ((ch >= 0) && (ch < ptc_max))
                    http_refresh_epg( tnum, ch );
        }
    }

    snprintf( fn, sizeof(fn), "%s%s%s", w->root, t->cwd, t->file);

/* request is for atscap* and pg/. may be in ram, fix dir for test */
    if (0 != arg_tmpfs) {
        if ( (NULL != strstr( t->cwd, "pg/" ))
          || (NULL != strstr( t->file, NAME )) )
        {
            snprintf( fn, sizeof(fn), "%s/ram%s%s", w->root, t->cwd, t->file);
        }
    }

/* see again if the file is actually there */
    ok = stat64(fn, &fs);
    advrlog( LOG_INFO, "%s:%d stat64 %d %s", WHO, __LINE__, ok, fn);
    if (0 == ok) {

/* is a regular file no error */
        if (0 != (fs.st_mode & S_IFREG)) {
            ahttp_log( tnum, "%s is regular file", fn );

/* set 304 response type */
            if (0 != t->imstime) {
                if ( fs.st_mtime == t->imstime )
                        t->rnum = 304;
            }
            return 0;
        }

/* is a directory, adjust names and make file index.html */
        if (0 != (fs.st_mode & S_IFDIR)) {
            snprintf( fn, sizeof(fn), "%s%s/", t->cwd, t->file );
            astrncpy( t->cwd, fn, sizeof(t->cwd) );
            strcpy( t->file, "index.html" );
            return 0;
        }
    }

    dvrlog( LOG_INFO, "req%d failed %s", tnum, t->rfile);

/* all else is an error */
    strcpy( t->cwd, "/");
    strcpy( t->file, "index.html" );
    chdir( w->root );

    t->rnum = 302; /* smooth redirect */
    ok = -1;
/*  t->rnum = 404; // confuses mozilla? */
    http_log( tnum, "%s returns %d", WHO, ok);
    return ok; /* will close socket */
}

/* sends a file. .png files get Expires: tomorrow sent in header */
/* subset of rfc 2616 http 1.1 sec 8.1.2.1 compliance, single connection */
/* static */
int
http_response ( struct wss_s *w, int tnum )
{
    time_t utnow, utexp;
    long long start, end;
    long long size, count;
    int ok, len;

    char utcnow[32], utcmod[32], utcexp[32];
    char fn[ WWW_TCP_MAX ];

    struct tts_s *t;
    char *server;

    struct timespec e0 = {0,0};
    struct timespec e1 = {0,0};
    struct timespec et = {0,0};
    struct stat64 fs;

#ifdef USE_CGI_WAIT
    struct timespec ns = { 0, 100000000 }; /* 100ms */
    char ft[256];
    int u, z;
#endif


    t = &w->tss[ tnum ];

    utnow = time(NULL);
    http_text_time( utcnow, &utnow );

    snprintf( fn, sizeof(fn), "%s%s%s", w->root, t->cwd, t->file );
    if (0 != arg_tmpfs) {
        if ( (NULL != strstr( t->cwd, "pg/" ))
          || (NULL != strstr( t->file, NAME )) )
        {
            snprintf( fn, sizeof(fn), "%s/ram%s%s", w->root, t->cwd, t->file );
        }
    }

/* test to make sure it's a regular file, failsafe for get request */
    ok = stat64( fn, &fs );
    ahttp_log( tnum, "%s:%d stat64 %d %s", WHO, __LINE__, ok, fn);

/* don't log img files, is TMI */
    if (NULL == strstr( fn, ".png" ))
        ahttp_log( t->num, "%s %d %s ka %d", WHO, t->rnum, fn, t->ka );

/* asnprint wants first char nul if new string */
    *t->reply = 0;


    if (304 == t->rnum) {
        asnprintf( t->reply, WWW_TCP_MAX, "HTTP/1.1 304 Not Modified\n");

        if (0 == t->ka) {
            asnprintf( t->reply, WWW_TCP_MAX, "Connection: close\n\n");
        } else {

/* spec does not define this very well for http 1.1, not at all for 1.0 */
/* NOTE: keep the connection open even through errors */
            asnprintf( t->reply, WWW_TCP_MAX, "Connection: Keep-Alive\n\n");
        }

//      ahttp_log( t->num, "%s:%d %s", WHO, WHERE, t->reply );

/* don't use SIGPIPE handler */
        ok = send( t->accepted, t->reply, strlen(t->reply), MSG_NOSIGNAL );

        if (0 == t->ka)
            http_close( t, &t->accepted, "304" );
        return 0;
    }

    
/* NOTE: This doesn't work right. Mozilla tries to save a file, odd.
   The work around is file not found closes connection; no http response.
 */

/* 404 Not Found */
    if (404 == t->rnum) {
        asnprintf( t->reply, WWW_TCP_MAX, "HTTP/1.1 404 Not Found\n");

        if (0 == t->ka) {
            asnprintf( t->reply, WWW_TCP_MAX, "Connection: close\n\n");
        } else {

/* spec does not define this very well for http 1.1, not at all for 1.0 */
/* NOTE: keep the connection open even through errors */
            asnprintf( t->reply, WWW_TCP_MAX, "Connection: Keep-Alive\n\n");
        }

        ahttp_log( t->num, t->reply );

/* don't use SIGPIPE handler */
        ok = send( t->accepted, t->reply, strlen(t->reply), MSG_NOSIGNAL );

        if (0 == t->ka)
            http_close( t, &t->accepted, "404" );
        return -1;
    }

/* 302 redirects to /index.html */
    if (302 == t->rnum) {
#ifdef WWW_STRICT_HTTP11
/* older clients might not respond to 303 */
        snprintf( t->reply, WWW_TCP_MAX,
                    "HTTP/1.1 303 See Other\n"
                    "Location: http://%s:%d/index.html\n"
                    "Cache-Control: no-cache\n",
                    t->local_name, t->local_port);
#else
/* RFC 2616 section 10.3.3-4, pp 40-41 */
/* older clients should treat 302 same as new 303 */
        snprintf( t->reply, WWW_TCP_MAX,
                    "HTTP/1.1 302 Found\n"
                    "Location: http://%s:%d/index.html\n"
                    "Cache-Control: no-cache\n",
                    t->local_name, t->local_port);

#endif
        if (0 == t->ka) {
            asnprintf( t->reply, WWW_TCP_MAX, "Connection: close\n\n");
        } else {
            asnprintf( t->reply, WWW_TCP_MAX, "Connection: Keep-Alive\n\n");
        }

        ahttp_log( t->num, t->reply );
        ok = send( t->accepted, t->reply, strlen(t->reply), MSG_NOSIGNAL );
        if (0 == t->ka)
            http_close( t, &t->accepted, "302" );
        return 0;
    }
    

/* FIXME: is this directory check needed? http request should 302 redirect */
/* dir enable should test for dirs, but not rewriting apache here */
    if (0 == (S_IFREG & fs.st_mode)) {

#ifdef WWW_STRICT_HTTP11
/* older clients might not respond to 303 */
        snprintf( t->reply, WWW_TCP_MAX,
                    "HTTP/1.1 303 See Other\n"
                    "Location: http://%s:%d/index.html\n"
                    "Cache-Control: no-cache\n",
                    t->local_name, t->local_port);
#else
/* RFC 2616 section 10.3.3-4, pp 40-41 */
/* older clients should treat 302 same as new 303 */
        snprintf( t->reply, WWW_TCP_MAX,
                    "HTTP/1.1 302 Found\n"
                    "Location: http://%s:%d/index.html\n"
                    "Cache-Control: no-cache\n",
                    t->local_name, t->local_port);
#endif
        if (0 == t->ka) {
            asnprintf( t->reply, WWW_TCP_MAX, "Connection: close\n\n");
        } else {
            asnprintf( t->reply, WWW_TCP_MAX, "Connection: Keep-Alive\n\n");
        }

        ahttp_log( t->num, t->reply );
        ok = send( t->accepted, t->reply, strlen(t->reply), MSG_NOSIGNAL );
        if (0 == t->ka)
            http_close( t, &t->accepted, "302" );
        return 0;
    }

/* CGI */
/* Do not want CGI request to leave the request in browser uri entry,
   but seems no easy way to prevent document view from changing?
*/
    if (0 != *t->cgi) {

/* Go back to what brought us here to remove the browser uri cgi data */
        snprintf( t->reply, WWW_TCP_MAX, "HTTP/1.1 ");

/* #define USE_303 */
#ifdef USE_303
        asnprintf( t->reply, WWW_TCP_MAX, "303 See Other\n");
#else
        asnprintf( t->reply, WWW_TCP_MAX, "302 Found\n");
#endif

/* #define USE_FULL_LOCATION */
#ifdef USE_FULL_LOCATION
        asnprintf( t->reply, WWW_TCP_MAX, "Content-Location: "
                    "http://%s:%d%s%s\n",
                    t->local_name, t->local_port, t->cwd, t->file);
        asnprintf( t->reply, WWW_TCP_MAX, "Location: "
                    "http://%s:%d%s%s\n",
                    t->local_name, t->local_port, t->cwd, t->file);
#else
        asnprintf( t->reply, WWW_TCP_MAX, "Content-Location: %s%s\n",
                    t->cwd, t->file);
        asnprintf( t->reply, WWW_TCP_MAX, "Location: %s%s\n",
                    t->cwd, t->file);
#endif

/* always close after redirect */
        if (0 == t->ka) {
            asnprintf( t->reply, WWW_TCP_MAX, "Connection: close\n");
        } else {
            asnprintf( t->reply, WWW_TCP_MAX, "Connection: Keep-Alive\n");
        }

        asnprintf( t->reply, WWW_TCP_MAX, "\n");

/* Send the response as 302 redirect to remove cgi from browser URI. */
        ahttp_log( t->num, t->reply );
        ok = send( t->accepted, t->reply, strlen(t->reply), MSG_NOSIGNAL );
        if (0 == t->ka) {
/*          http_close( t, &t->accepted, "302" ); */
            return -1; /* error return will close socket */
        }
    }

    http_get_content( t );              /* set t->ctext and t->ctype */


/* Last-Modified */
    memset( utcmod, 0, sizeof(utcmod));
    http_text_time( utcmod, &fs.st_mtime);

#if 0

/* Cache image files. Want everything else not cached because
     old program guide data should not sit in any proxy, anywhere.

    Request: If-Modified-Since: date
    Reply: 304 NOT MODIFIED and return 0 if date matches file mod time
    Date: and Last Modified: need to be sent, too:

        my httpdate code for remote clock sync will need it
*/
    if (0 == t->ctype) {                                /* is cacheable? */
        if (0 == strncmp( utcmod, t->ims, sizeof(utcmod))) { /* mod since? */
            snprintf( t->reply, WWW_TCP_MAX,
                    "HTTP/1.1 304 Not Modified %s\n"
                    "Date: %s\n"
                    "Last Modified: %s\n", t->file, utcnow, utcmod );
            if (0 == t->ka) {
                asnprintf( t->reply,WWW_TCP_MAX, "Connection: close\n\n");
            } else {
                asnprintf( t->reply,WWW_TCP_MAX, "Connection: Keep-Alive\n\n");
            }

            ahttp_log( t->num, t->reply ); 
            ok = send( t->accepted, t->reply, strlen(t->reply), MSG_NOSIGNAL );
            if (0 == t->ka)
                http_close( t, &t->accepted, "304" );   /* not persistent */
            return 0;
        }
    }
#endif

/* Range error */
    size = fs.st_size;
    if (t->rseek >= fs.st_size) {
        snprintf( t->reply, WWW_TCP_MAX,
                     "HTTP/1.1 416 Range Error\n"
                    "Cache-Control: no-cache\n"
                    "Content-Length: %lld\n", size);

        if (0 == t->ka) {
            asnprintf( t->reply,WWW_TCP_MAX, "Connection: close\n\n");
        } else {
            asnprintf( t->reply,WWW_TCP_MAX, "Connection: Keep-Alive\n\n");
        }

        ahttp_log( t->num, t->reply ); 
        ok = send( t->accepted, t->reply, strlen(t->reply), MSG_NOSIGNAL );
        if (0 == t->ka)
            http_close( t, &t->accepted, "416" );
        return -1;
    }

    size = fs.st_size;

/* open file */
    clock_gettime( clock_method, &e0 );
    t->infile = open( fn, O_RDONLY );

    if (t->infile < 3) {

/* 404 here is error opening it for read only */
        snprintf( t->reply, WWW_TCP_MAX,
                    "HTTP/1.1 404 Not Found\n"
                    "Cache-Control: no-cache\n" );

        if (0 == t->ka) {
            asnprintf( t->reply,WWW_TCP_MAX, "Connection: close\n\n");
        } else {
            asnprintf( t->reply,WWW_TCP_MAX, "Connection: Keep-Alive\n\n");
        }

        ahttp_log( t->num, t->reply );
        ok = send( t->accepted, t->reply, strlen(t->reply), MSG_NOSIGNAL );
        return -1;
    }

    advrlog( LOG_INFO,  "%s t%d open %2d seek %lld %s\n",
                WHO, tnum, t->infile, t->rseek, fn);

    count = 0LL;
    end = size - 1LL;
    start = t->rseek;

    *t->reply = 0;

    if (0 != t->rseek) { /* wget with -c continue option */
        asnprintf( t->reply, WWW_TCP_MAX, "HTTP/1.1 206 Partial Content\n" );
        asnprintf( t->reply, WWW_TCP_MAX, "Content-Length: %lld\n", size-start);
        asnprintf( t->reply, WWW_TCP_MAX, "Content-Range: %lld-%lld/%lld\n",
                start, end, size);
    } else {
        asnprintf( t->reply, WWW_TCP_MAX, "HTTP/1.1 %03d OK\n", t->rnum);
        asnprintf( t->reply, WWW_TCP_MAX, "Content-Length: %lld\n", size);
    }
    asnprintf( t->reply, WWW_TCP_MAX, "Content-Type: %s\n", t->ctext);
    asnprintf( t->reply, WWW_TCP_MAX, "Accept-Ranges: bytes\n" );
    asnprintf( t->reply, WWW_TCP_MAX, "Last-Modified: %s\n", utcmod );

#if USE_20X_LOCATION
/* this breaks xine for some reason, maybe needs Content-Location: */

/*
    asnprintf( t->reply, WWW_TCP_MAX, "Location: %s%s\n",
                t->cwd, t->file);
*/
    asnprintf( t->reply, WWW_TCP_MAX, "Content-Location: %s%s\n",
                t->cwd, t->file);
#endif

/* if expiration date is in the future, browser cache should not get it.
   if expiration date is in the past:
        if-modified-since, see above, limits what is returned
*/
    server = NAME "-" VER "-" LASTEDIT;

    asnprintf( t->reply, WWW_TCP_MAX, "Server: %s\n", server);
    asnprintf( t->reply, WWW_TCP_MAX, "Host: %s\n", t->local_name);
    asnprintf( t->reply, WWW_TCP_MAX, "Date: %s\n", utcnow);

/* images need Expires: header for browser cache to work,
    depending on browser http level */
    if (0 == t->ctype) {
        utexp = utnow + 86400; /* 24 hours ahead */
        http_text_time( utcexp, &utexp );

        asnprintf( t->reply, WWW_TCP_MAX, "Expires: %s\n", utcexp);

/* FIXME: this will make it always redraw the images, not very efficient,
          but for ch.png signal image, it might improve initial load.

        asnprintf( t->reply, WWW_TCP_MAX, "Cache-Control: must-revalidate\n");
*/

    } else {

/* everything else gets no-cache */
        asnprintf( t->reply, WWW_TCP_MAX, "Cache-Control: no-cache\n");
    }

#if 1
    if (0 == t->ka) {
        asnprintf( t->reply, WWW_TCP_MAX, "Connection: close\n\n");
    } else {
        asnprintf( t->reply, WWW_TCP_MAX, "Connection: Keep-Alive\n\n");
    }
#endif

//    ahttp_log( tnum, "%s:%d %s", WHO, WHERE, t->reply );

    ok = send( t->accepted, t->reply, strlen(t->reply), MSG_NOSIGNAL );
    if (ok != strlen( t->reply)) return -1;
    if (0LL != t->rseek) {
        if (t->rseek >= size) t->rseek = 0LL;
        count = lseek( t->infile, t->rseek, SEEK_SET );
    }
      
/* at least one block to try */
    ok = 1;

/* FIXME: check for receiving close connection to terminate transfer early */
/*    ahttp_log( t->num, "Sending %d bytes...", size); */

/* use the memory string instead? it has to be broken down to w->mtu chunks */
    if ((NULL != t->ram) && (t->ramz > 0)) {
        dvrlog( LOG_INFO, "%s uses memory", t->file);
#if 0
        count = 0;
        while(1) {
            len = t->ramz - count;
            if (len <= 0) break;
            if (len > w->mtu) len = w->mtu;
            ok = send( t->accepted, &t->ram[count], len, MSG_NOSIGNAL );
            count += len;
        }
//      ifree(t->ram);
        t->ramz = -1;

        dvrlog( LOG_INFO, "%s sent %d", t->file, t->ramz);
#endif

    } else {

/* is not using memory string, consider above string commented until tested */
        advrlog( LOG_INFO, "tcp send blkz %d", w->mtu);
        while (ok > 0) { 
            if (0 == t->rtype) {
                ahttp_log( t->num, "headers only");
                break; /* only sending headers */
            }
            if (count < 0LL) break;
            len = read( t->infile, t->tsbuf, w->mtu );

/* EOF or error */
            if (len < 1) break;

/* NOTE: byte count return from read handles EOF last block len correctly */
            count += len;
            ok = -1;
            if (t->accepted < 3) break;

            ok = send( t->accepted, t->tsbuf, len, MSG_NOSIGNAL );
/*          ahttp_log( t->num, "send() returns %d", ok); */

#if 0
/* cpu usage redux. also reduces 1g enet r8169 speed from 62m/s to 58m/s */
            if ( (count & 0xFF) == 0)  {
                pthread_yield();
                nanosleep( &www_write_sleep, NULL );
            }
#endif
        }
    }
/*    ahttp_log( t->num, "SENT %d bytes", count); */
      
    if (ok < 0) t->rtype = 3;

    if (0 == count) count = 1;

    if (1 == t->rtype) {
        if (start > 0) {
            t->rtype = 3;
        }
    }

    if ((t->rtype < 1) || (t->rtype > 3)) t->rtype = 0;

/* TODO: rate computation to set refresh delay. pretzel logic */
    clock_gettime( clock_method, &e1 );
    time_diff( &et, &e0, &e1 );
     
    ahttp_log(t->num, "ETA %d.%09d %s",(int)et.tv_sec, (int)et.tv_nsec, fn);

    close( t->infile );

    if (0 == t->ka) {
        ahttp_log(t->num, "http/1.%d closing socket %d t->ka=%d EOF",
                    t->htver, t->accepted, t->ka);
        http_close( t, &t->accepted, "EOF");
    } else {
        ahttp_log(t->num, "http/1.%d keeping socket %d t->ka=%d EOF",
                    t->htver, t->accepted, t->ka);
    }

    return 0;
}

/* Each invocation runs/blocks/sleeps until SIGINT kills all of them. */
/* static */
void *
http_loop( void * targ )
{
        struct tts_s *t = (struct tts_s *) targ;
        struct wss_s *w;
        int tnum, ok1, ok2, ok3;
    
        w = &wss;

        tnum = t->num;

        chdir( w->root ); /* jail */

/* this loop runs detached so it can die asynchronously */
        advrlog( LOG_INFO, "%s%d detached %d", WHO, tnum, getpid() );

        w->ptuse++;
        w->sig = -1;

        t->tid = getpid();
        t->accepted = -1;

        while( 1 )  {
                if (0 == t->tid) break;

/* Set mtu size to a multiple of transport packet size.
   See http://www2.rad.com/networks/2006/pmtu/detect.htm
    Bob and Alice have overkill for the local net design of this application,
    but the ICMP fragmentation detection is a great idea for using routers.
*/

                t->rnum = 0;    /* reply # cleared until changed */

/* FIXME? default to keepalive off, should be on: is done already? */
                t->local_port = w->port;

                memset( t->file, 0, WWW_TCP_MAX);
                memset( t->cwd, 0, WWW_TCP_MAX);

                astrncpy( t->file, "index.html", 16 );
                astrncpy( t->cwd, "/", 4);

                ok1 = ok2 = ok3 = 0;

                ok1 = http_accept( w, tnum );
                t->utska = utsnow + 5;

/* keep reading/responding until keep alive expires */
                while (0 == ok1) {
                        if (-1 == t->accepted) ok1 = -1;
                        if (t->utska < utsnow) ok1 = -1;
/* aborted connect should close */
                        if (0 != ok1) break;

/* aborted request should close connection, client or host can do it */
                        ok2 = http_request( w, tnum );
                        if (0 == ok2) {
/* TODO: pipeline mode */
                                ok3 = http_response( w, tnum );
                                if (0 != ok3) break;
/* look for next request or stop looping if no keep alive */
                                continue;
                        } else break;

/* aborted response should close the connection */
                }

/* close connection */
                if (t->accepted > 2) {
                        if (0 != ok1)
                                http_close( t, &t->accepted, "accept");
                        if (0 != ok2) 
                                http_close( t, &t->accepted, "request");
                        if (0 != ok3)
                                http_close( t, &t->accepted, "response");
                }
/*              nanosleep( &www_bind_sleep, NULL); */
        }

        
        dvrlog( LOG_INFO, "%s %d terminating %d",
                WHO, tnum, getpid() );

        w->ptuse--;
        t->tid = 0;
        return NULL;
}

/* create up to w->ptmax threads, or none */
/* static */
int
http_create_threads( struct wss_s *w )
{
        int i, ok;
        struct tts_s *t;

        if (0 == w->ptmax ) return -1;
    
        for (i=0; i < w->ptmax; i++) {
                t = &w->tss[ i ];
                t->num = i;

/* all have to return 0 or nothing done */
                memset( &t->thttp, 0, sizeof(pthread_t) );
                ok = pthread_attr_init( &t->tattr );
                ok |= pthread_attr_setdetachstate( &t->tattr,
                                    PTHREAD_CREATE_DETACHED );
                ok |= pthread_create( &t->thttp, &t->tattr,
                                    http_loop, (void *) &w->tss[i] );

/* no errors */
                if (0 == ok) {
                        advrlog( LOG_INFO,  "www t%d created\n", i);
                        strcpy( t->cwd, "/");
                        strcpy( t->file, "index.html");
                }

/* an error, shutdown server */
                if (0 != ok)  {
                        http_close_sockets();
                        return -1;
                }

/*              nanosleep( &www_tcreate_sleep, NULL); */
        }
        return 0;
}

/* wait for bind socket and create threads.
   this is done as a thread itself so it does not interfere
   with the startup of any current timers */
/* static */
void *
http_start ( void * targ )
{
        struct wss_s *w;
        struct ifreq ifr;
        int ioc, mtu, tb;

        w = &wss;

        w->bind_try = 1;

        if (0 != http_bind_socket( w )) return NULL;
        
        epg_www = ~0;

/* set socket to listen for activity; TESTME: backlog is 2 */
        if (0 == http_socket_listen( w, 2 ) ) {
                        http_create_threads( w );
                        nanosleep( &www_bind_sleep, NULL);
        }

/* FIXME: query 'eth0' until can figure out how to query by address */
        ifr.ifr_addr.sa_family = AF_INET;
        astrncpy( ifr.ifr_name, "eth0", sizeof(ifr.ifr_name) );
        ioc = ioctl( w->sock, SIOCGIFMTU, &ifr);

/* normal ethernet default if ioctl fails */
        mtu = 1492;
        if (0 == ioc) mtu = ifr.ifr_mtu;
        advrlog( LOG_INFO, "%d SIOCGIFMTU %d", ioc, mtu);

/* compute w->mtu setting from compiled default to override above */
        tb = mtu;
        tb /= 188;

/* at least one packet will be sent regardless of how small mtu is */
        if (tb < 1) tb = 1;
        tb *= 188;

/* limit http response to use w->mtu or WWW_TCP_MAX chunks */
        w->mtu = WWW_TCP_MAX;
        if (tb < WWW_TCP_MAX) w->mtu = tb;

        advrlog( LOG_INFO, "using MTU %d (%d*188)", w->mtu,w->mtu/188);
        return NULL;
}

/* static */
void
http_init ( void )
{
        int ok;
        struct wss_s *w;
        struct tts_s *t;
        char *p;
    
        w = &wss;

        w->ptuse = 0;                   /* threads in use */
        w->ptmax = arg_wthreads;        /* threads to spawn */
        w->ptz = sizeof( struct tts_s );

        w->sock = -1;                   /* main socket state */
        w->bound = -1;
        w->port = arg_wport;
        w->mask = arg_wmask;
        w->addr = arg_waddr;
        w->bind_try = 0;

/* Thread task state structure allocation. */
/* Valgrind says no one frees this, whoops */
/* Here's why:
    SIG* handler so far has no way of finding thread ID, so no way yet
    to synchronize the thread destruction until only main left.
    Leaving this thread for valgrind to complain about solves segfault.
    dvrlog thread is also left allocated and is source of other unfreed bytes.
    An ithread allocation list similar to imalloc could help this.
*/

        w->tss = (struct tts_s *)icalloc( w->ptmax, w->ptz, "http tts" );

        if (NULL == w->tss) {
                dvrlog( LOG_INFO,
                        "%s failed tts_s calloc %d = (%dx%d)\n", WHO,
                w->ptmax * w->ptz, w->ptmax, w->ptz );
                return;
        }

        get_time();
        http_log( 0, "HTTP Started" );

/* out_path is smaller than w->root */
        astrncpy( w->root, out_path, sizeof(w->root) );

/* remove multiple following // */
        if (strlen( w->root) > 1) {
                p = w->root + strlen(w->root);
                p--;
                while('/' == *p) *p-- = 0;
        } else {
                strcpy( w->root, "/dtv");
                http_log( LOG_INFO, "www root jailed to %s", w->root);
        }


        t = &w->tss[0];
        strcpy( t->cwd, "/" );
        strcpy( t->file, "index.html" );

/* need to create the initial index html file */
        http_index_html( w, 0, WHO );

/* need to create the server status and configuration html file */
        dump_cfg_html( WHO );
        
/* http start binds and listen, then starts threads to handle connects */
/* It's done as a thread so it doesn't interfere with current timer start. */

        memset( &w->tws, 0, sizeof(pthread_t) );
        ok = pthread_attr_init( &w->twsattr );
        ok |= pthread_attr_setdetachstate( &w->twsattr,
                                PTHREAD_CREATE_DETACHED );
        ok |= pthread_create( &w->tws, &w->twsattr,
                              http_start, NULL );

        if (0 != ok) dvrlog( LOG_INFO, "http_start thread failed");
        nanosleep( &www_tcreate_sleep, NULL );

#if 0
/* initial epg filters */
        pgm3.hide = pgm.hide;
        pgm3.age = pgm.age = ~0;
        pgm3.find = pgm.find;
#endif

}

/* USE_WWW end */
#endif

/* parse args, open video device
    toggle between timer/channel list or capture
 */
/************************* httpd functions end *****************************/

/* mutex init for non-fifo, fifo is init elsewhere */
/* static */
void
init_mutex( void )
{
        pthread_mutex_init( &dvrlog_mutex, NULL );
        pthread_mutex_init( &caplog_mutex, NULL );
        pthread_mutex_init( &tsid_mutex, NULL );
        pthread_mutex_init( &grid_mutex, NULL );
        pthread_mutex_init( &epg_mutex, NULL );
        pthread_mutex_init( &spam_mutex, NULL );

#ifdef USE_PNG
        pthread_mutex_init( &png_mutex, NULL );
#endif

#ifdef USE_GNU_BACKTRACE
        pthread_mutex_init( &bt_mutex,  NULL );
#endif

}


/**************************** main start ***********************************/
int
main( int argc, char ** argv, char ** envp )
{
    int i;
    char *sty;
    char n[64];
    FILE *f;

    udp_mcast = 0;      /* shut up compiler */

/* clear log */
    memset(dvrlog_list, 0, sizeof(dvrlog_list));
    dvrlog_idx = 0;

    uid = getuid();
    euid = geteuid();
    gid = getgid();
    egid = getegid();

    init_allocs();

    init_mutex();       /* logfile and epg mutex init */

    get_time();

#ifdef USE_POWERDOWN
    utspdd = utsnow + USE_POWERDELAY;
#endif

    test_clock_res();   /* find most accurate clock */

#ifndef USE_DYNAMIC
/* only allocate the big 9M FIFO once at the start if not USE_DYNAMIC */
    init_fifo( &ts_fifo, fifoz );
#endif

    pid_m = getpid();

#ifdef USE_SIGNALS
    signal_init(); /* sigaction setup for control c trap */
#endif
    signal_timeout = 0;

/* in case starts up in middle of a timer, will get something */
    cap_vc = cap_va = 0;

/* set utc_offset for ATSC timestamp vs Unix timestamp difference */
    atsc_calc_epoch();

/* save current DST status to prevent extra config load from DST change */
    get_time();
    pisdst = tloc.tm_isdst;

/* config z line, if Z set force time update asap. zero does not? utszto? */
/*   cap_zto = utsnow - 1801; // make time update trigger asap */

    utc_up = utsnow; /* uptime */

/* hold down test guides, user sanity and if start in middle of event */
/* -1 for arg_devnum will make it timeout immediately */
    utstpg = utsnow + (PROGRAM_GUIDE_TIMEOUT * arg_devnum);

    parse_args( argc, argv );

/* initialize the frequency tables to ATSC (default) or various QAM256 modes
    because might be doing non-forked interactive modes, i.e.
        not using screen or bash script with -s option
*/
    init_channels();

    set_title();

#ifdef SCREEN
    sty = getenv( "STY" );
    /* detach mode doesn't need screen, screen has more flexible detach */
    if ((arg_detach == 0) && (arg_screen != 0) )
    {
        /* STY set means screen is already running, else needs to run */
        if (NULL == sty) {
            /* copy parms to argx, first is screen, last is null */
            char *argx[32];
            char argn[8]; /* device num */
            int k;
            snprintf( argn, sizeof(argn)-1, "dtv%d", arg_devnum);
            /* start screen with parameters passed to pchdtvr */
            k = 0;
/*
 -R option to reattach a screen session matching the device number
 it's a one way ticket if there is an error, so show the parms
*/
            if (arg_sattach != 0) {
                argx[k++] = "screen";
                argx[k++] = "-d";
                argx[k++] = "-r";
                argx[k++] = argn;
                argx[k++] = NULL;
                fprintf( stdout, "re-attach execvp: %s %s %s %s\n",
                         argx[0], argx[1], argx[2], argx[3]);
                asyslog( LOG_INFO, "screen reattaching %s with %s %s %s %s",
                        argn, argx[0], argx[1], argx[2], argx[3]);

                i = execvp( "screen", argx );
                syslog( LOG_INFO, "screen de/reattach failed, return %d", i);
/* should only see if error in exec like file not found? */
/* this fall through should never happen */
                uses_screen = 0;
                in_screen = 0;
                console_reset();
                fprintf(stderr,
                        CLS BW "GNU screen not found for reattach.\n" BN);
                exit(1);
            } else {
                asyslog( LOG_INFO, "creating new screen named %s", argn);
                k = 0;
                argx[k++] = "screen";
                argx[k++] = "-a";
                if (arg_sdetach != 0) {
                    argx[k++] = "-d"; /* -d detaches screen with no wait */
                    argx[k++] = "-m";
                }
                argx[k++] = "-S";
                argx[k++] = argn;
                for (i=0; i<argc; i++) if ( (i+k) < 32 ) argx[i+k] = argv[i];
                if ( (i+k) < 32) argx[i+k] = NULL;
                argx[31] = NULL;
                asyslog( LOG_INFO, "%s %s %s %s %s %s...\n", argx[0], argx[1], argx[2], argx[3], argx[4], argx[5]);
                fprintf( stdout, "execvp: %s %s %s %s %s %s...\n", argx[0], argx[1], argx[2], argx[3], argx[4], argx[5]);
                i = execvp( "screen", argx );
                syslog( LOG_INFO, "screen failed, return %d", i);
/* should only see if error in exec like file not found? */
/* this fall through seems to be faulty, so exit now with user warning */
/* not sure why it breaks if it falls through instead the exit placed here */
                uses_screen = 0;
                in_screen = 0;
                console_reset();
                fprintf( stderr, CLS BW "GNU screen not found.\n" BN);
                exit(1);
            }
        } else {
            asyslog( LOG_INFO, "GNU screen is running on %s", sty);
            uses_screen = ~0;
            in_screen = ~0;
        }
    }
#endif

    test_termsize(); /* lines and columns */

    display_sigtype = SIG_STR;

/* transport stream save path and program guide save path */
    {
        char opg[256]; /* file name */

/* make /dtv/ (or -p directory) */
        mkdir( out_path, 0777 );
        chdir( out_path );

/* make /dtv/ram */
        snprintf( opg, sizeof(opg)-1, "%s/ram", out_path);
        if (0 != arg_tmpfs) mkdir( opg, 0777 );

/* make /dtv/pg/ */
        snprintf( opg, sizeof(opg)-1, "%s/pg", out_path);
        mkdir( opg, 0777 );

/* make /dtv/pg/img */
        snprintf( opg, sizeof(opg)-1, "%s/pg/img", out_path);
        mkdir( opg, 0777 );

    }

    /* normal or test log, try device open to find out */
    open_device( WHO );

    if (( 0 == arg_dummy) && (0 == arg_nosplash)) {
        
        char kb;
        
/* driver klogs "modulation mode (0) not supported" if wait is too short */
/* this may not be needed anymore ? */
        cap_chan = 2;
        set_channel( (struct sig_s *) &ptc[2].sig, WHO );

/* NOTE: use stderr or else first user input clears the screen:
            as in [r] for reschedule and [t] for timer
 */
        aprintf( stderr, HOM CCE );
        aprintf( stderr, "%s%s", welcome, BN );
        nanosleep( &signal_long_sleep, NULL );
        kb = console_getch();   /* control c trap */
        aprintf( stderr, "\n%s%s", boilerplate, BN );
        nanosleep( &signal_long_sleep, NULL );
        kb = console_getch();   /* control c trap */
        show_mem_use();

/* this delay may need to be increased for software i2c firmware load */
/* it is barely enough for hardware i2c firmware load of 3s */
/* don't set the channel until ucode loaded or you'll get errors */
        nanosleep( &msg_long_sleep, NULL );
        kb = console_getch();   /* control c trap */
        aprintf( stderr, "%s%s", HOM, CCE );
    }

    /* give correct name on assumption it will find a device and open it */
    test_mode = 0;
    snprintf( syslog_name, sizeof(syslog_name)-1, NAME "%d", arg_devnum );

    /* change name on assumption it would not open */
    if ( (0 > in_file) || (0 != arg_dummy) ) {
        test_mode = ~0;
        snprintf( syslog_name, sizeof(syslog_name)-1, NAME "-test" );
    }

    /* only force test mode to zero if dummy not overriding */
    if ( 0 == arg_dummy ) test_mode = 0;

    /* close it in case forking, will open later. set logname */
    if (0 != arg_detach) {
        close_device( WHO );
    }

/* bring up ram filesystem */
    load_tmpfs( );

    openlog( syslog_name, LOG_NDELAY, LOG_DAEMON );

    syslog( LOG_INFO, "%s %s DVB %s %s",
            VERSION, LASTEDIT, in_name, fe_text3  );

#ifndef USE_SYSLOG
    init_dvrlog();
#endif

/* let init val of mtime = 0 cause reload */
    test_config(0, WHO );


/* -S option sets it up by scanning thru all frequencies for stations */
/* if -S option is not specified, but no config file, auto-scan anyway */
    if ((0 != arg_scan) || (0 == scan_idx)){
        arg_scan = ~0;

/* is ok to try to continue after scanning now, instead of old restart */
        find_stations();
    }

    /* blank console */
    aprintf( stderr,  CLS );

    show_headers( 1 );

    display_type = D_TIMERS;
    refresh.timers = 1;
    refresh.pstats = 1;
    refresh.estats = 1;
    refresh.vstats = 1;

/* initial free stats load, updates @ 443s */
    statfs( out_path, &vol_fsp );
    statfs( cut_path, &cut_fsp );

/* FIXME: Keep track of this as only thread that listens for signals */
/* FIXME: pthread_self() does not work as id for main() w/ LinuxThreads 0.10 */
/* FIXME: This fails w/ NPTL because all threads have same getpid(). yikes. */

/* NOTE: fork causes some PITA to open device each branch */
/* FIXME: rewrite ts capture to open the device instead */
/*        this is a dynamic feature i've been thinking about */
/*        but it will require almost 10s for open and AOS, secdt = 10 not 5 */
    
    /* one shot capture for arg_capture seconds */
    if (0 != arg_capture) {
        cap_now = CAP_USER;
        cap_chan = scan_list[0];

        if (0 != arg_detach)
        {
            pid_t fp;
            asyslog( LOG_INFO, "forking main() pid %d", getpid() );

            /* no zombies */
            fp = fork();
            /* two paths of possible execution based on return value
                fp = 0 is forked path, otherwise it's parent path exiting
                NOTE: BOTH will happen, so both need console_ ? exit(0)
             */
            if (0 == fp)
            {
                /* new forked path, no ctl'n tty */
                pid_m = getpid();
                asyslog( LOG_INFO,
                         "capture forked, main() is now pid %d", pid_m );
                /* moved because of fork */
                open_device( WHO );
                if (in_file > 2) ts_capture();
                console_exit(0);
            }

            /* old forked path, fork above is detached, so this path exits */
            console_exit(0);
        }

/* not arg_detach, do it interactive without config file, then exit */
        open_device( WHO );
        if (2 < in_file) ts_capture();
        console_exit(0);
    }

    /* arrival here with arg_detach means timers used, no stdin interaction */
    /* daemon mode, control via config file and http interface only */
    if (0 != arg_detach)
    {
        pid_t fp;
        fp = fork();
        if (0 == fp)
        {
            /* new forked path, will fall thru */
            pid_m = getpid();
            asyslog( LOG_INFO,
                    "daemon forked, main() is now pid %d", pid_m );
            /* fall thru to below */
        } else {
            /* old forker must die right here */
            console_exit(0);
        }
    }

/* detached fork falls thru to here for timer business as usual */
    pid_m = getpid(); /* what is my process id? */

    /* moved here because of fork */
    if (0 != arg_detach) open_device( WHO );

/* parse args and start up should use syslog, rest use dvrlog */
//    nanosleep( &signal_loop_sleep, NULL);

#ifndef USE_SYSLOG
    init_dvrlog();
#endif

    dvrlog( LOG_INFO, VERSION " " LASTEDIT " DVB %s %s",
            in_name, fe_text3 );

    log_clock_res();

    pid_m = getpid();
    advrlog( LOG_INFO, "main pid %d", pid_m );
    snprintf(n, sizeof(n), "/var/run/%s/%s%d.pid", NAME, NAME, arg_devnum);
    f = fopen(n, "w");
    if (NULL != f) {
            fprintf( f, "%d\n", pid_m);
            fflush(f);
            fclose(f);
    } else {
            dvrlog( LOG_INFO, "write %s failed", n);
    }

    get_dvr_count();    /* sets www_dvrs for html header generate */

    /* display device info after second device open */
    dvrlog( LOG_INFO, "%s", fe_text1);
    dvrlog( LOG_INFO, "%s", fe_text2);

#ifdef USE_MCAST
    {
        struct udp_s *u = &udp;
        /* open socket after second device open */
        if (0 != arg_mcport) udp_open_socket( u );
    }
#endif

#ifdef USE_WWW
    if (0 != arg_www) http_init();
#endif


#ifdef USE_MMAN
    mlockall( MCL_CURRENT );
#endif

/* init some display fields in case startup in middle of timer */
    read_capvol_stats();
    read_cutvol_stats();
    get_time();
    utscap = utsnow;
    snprintf(csp, 8, "\033[3;1H");

/* TODO: need more than this. have to change all the owners of all the dirs */
    if (0 != arg_setuid) {
        setgid(arg_setgid);
        setuid(arg_setuid);
    }    
    refresh.headers = 1;

/*************************** main interactive loop ***************************/
    while(1)
    {
        channel_scan( );
        if ( CAP_NONE != cap_now )
        {
/* enable this to debug each loop
        while ( console_getch() == 0 );
 */
            ts_capture( );
        }
/* enable this to debug each loop
        while ( console_getch() == 0 );
 */
    }   
/****************************** main stop ***********************************/

/* nothing below here should be seen, log it if it is */
    dvrlog( LOG_ERR, "main() should not have returned at line %d", __LINE__ );

    fprintf( stdout,
             CLS "main() should not have returned at line %d\n",
             __LINE__ );

    return 0;
}