开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 语音压缩 > 查看源码
diskread.c
资源名称：celp_3.2a.tar.gz　[点击查看]
上传用户：szhypcb168
上传日期：2007-01-06
资源大小：2187k
文件大小：42k
源码类别：

语音压缩

开发平台：

Unix_Linux

diskread.c：源码内容
  1. /*  ----------------------  DATA FILE READ ROUTINES  -----------------------  */
  2. /*  ---------------------  designed and coded by rpc  ----------------------  */
  3. /*  ----------------------  Version 1.5   July 1988  -----------------------  */
  4. /*  ------------------------------------------------------------------------  */
  6. /*   RELEASE NOTES:
  8.      Version 1.0:  The original version for the SUNGRAPH signal data input
  9. module.
  11.      Version 1.1:  Modified the argument list of some routines.  Other changes?
  13.      Version 1.2:  Added the auto error reporting feature.  This feature is
  14. enabled or disabled via disk_io_erh(flag) which is in its own source file.
  15. Also changed dfe[] & ffe[] to DFE & FFE.
  17.      Version 1.3:  Added relative positioning to goto_block & goto_sample.
  18. Deleted all checking for lseek errors since they can't occur.
  20.      Version 1.4:  Increased the amount of text in error reporting and changed
  21. it to print on stderr instead of stdout.
  23.      Version 1.5:  Made goto_sample, read_variable, goto_block and read_block
  24. return the sample or block number to be read next, i.e. the current position.
  25. */
  27. #include "diskio.h"
  28. #include <stdio.h>
  29. #include <strings.h>
  30. #include <sys/file.h>
  31. #include <sys/types.h>   /*  these two files are included for the call  */
  32. #include <sys/stat.h>    /*  to fstat in file length routine            */
  34. /*    variable type definitions:
  35.  *
  36.  *    TYPE  #  |  C TYPE  |  # of BYTES  |  FORTRAN TYPE
  37.  *    --------------------------------------------------
  38.  *       1     |  short   |      2       |  integer*2
  39.  *       2     |   int   |      4       |  integer*4
  40.  *       3     |  float   |      4       |    real*4
  41.  */
  42. static short bytes_in[] = { 2, 4, 4 }; /* number of bytes in the data types */
  43. #define NUM_DATA_TYPES sizeof(bytes_in)/sizeof(bytes_in[0]) /* elements in bytes_in */
  45. struct file_data {
  46.    char filename[MAX_FILENAME_LENG+1];/* file connected to this channel */
  47.    int fd;                            /* file descriptor assigned to above */
  48.    int format[2+2*MAX_VARS_PER_BLK];  /* the format of the data file */
  49.    short open;                        /* channel's status: 0-closed, 1-open */
  50.    short ch_type;                     /* channel type */
  51.    short v;                           /* variable # read on type 1 channels */
  52.    int next;                          /* next sample to read on type 1 chan */
  53.                                       /* next block to read on type 2 chan */
  54.    short samp_p_blk;                  /* total # of samples/block */
  55.    int byte_p_blk;                    /* total # of bytes/block */
  56.    int bytes[MAX_VARS_PER_BLK];       /* # of bytes/block for each variable */
  57.    short samp_avail;                  /* # of unread samples in current block */
  58.    int gap_head;                      /* # of bytes in block before selected variable */
  59.    int gap_total;                     /* # of block bytes not in selected variable */
  60.    };
  62. static struct file_data fd[MAX_CHANNELS];
  64. #define PARAM_OK -999
  65. struct errs {
  66.    char routine[20];               /* name of routine where error was */
  67.    char name[MAX_FILENAME_LENG+1]; /* filename or variable name */
  68.    int param;                      /* illegal argument of call in error */
  69.    };
  71. static struct errs ervar = { "", "", PARAM_OK };
  73. #define DFE   ".sg_data"
  74. #define FFE   ".sg_format"
  76. extern int errno;
  77. extern short auto_er;      /* flag to enable/disable auto error report & halt */
  79. extern long lseek();
  80. extern char *strcpy(), *strcat(), *strncat(), *rindex();
  82. /*  --------------------  OPEN VARIABLE CHANNEL ROUTINE  -------------------  */
  84. /*   DESCRIPTION:
  86.      chan_id = open_var_channel ( filename, var_name )
  88.      This routine is called to establish a new channel to access the values of
  89. one of the variables in a data file.  "filename" is the name of the file and
  90. "var_name" is the name of the variable whose values are to be read.  The
  91. variable's values are accessed with the read_variable routine.  This function
  92. returns a channel id  ("chan_id") which is used to identify the opened channel
  93. when calling other disk read routines.  "filename" can have an extension, but
  94. it is not mandatory.
  96. If "filename" has an extension:
  97.      a) The extension is tested for validity.  (eg. Is it .sg_data or one of
  98.         the other types that can be read by these routines?)  Valid extensions
  99.         are these:  .sg_data; .spd
  100.      b) If the extension is valid, open_var_channel tries to open "filename".
  101.         If the extension is not valid, an error is returned.
  103. If "filename" does not have an extension:
  104.      a) Each valid extension is concatenated with a copy of filename and the
  105.         resulting filename is tested for existance.
  106.      b) If this file exists, open_var_channel tries to open it.
  107.         If none of these files exist, an error is returned.
  109. If the file to be opened has the .sg_data extension, the format information
  110. must reside in a corresponding .sg_format file.
  112. Returned value:
  114.      If there are no errors, the returned value is a channel id which is used to
  115. identify the open channel when using other disk read routines.  A valid channel
  116. id is >= 0.  If an error occurs, the returned value is < 0.
  118. The following errors are detected:
  120.      - filename is too long
  121.      - all channels are open
  122.      - there is a format file problem
  123.      - the specified variable was not found
  124.      - invalid extension in filename
  125.      - no data file found
  126.      - the data file could not be opened
  127. */
  129. open_var_channel ( filename, var_name )
  131. char filename[], var_name[];
  133. {
  134.    int chan_id;
  136.    chan_id = open_channel(filename, 1, var_name);
  138.    strcpy(ervar.routine, "open_var_channel");
  139.    strncpy(ervar.name, filename, MAX_FILENAME_LENG);
  140.    if (chan_id == -15)  strncpy(ervar.name, var_name, MAX_FILENAME_LENG);
  141.    strcat(ervar.name, "");
  143.    if (chan_id < 0 && auto_er) error_exit(chan_id);
  144.    return(chan_id);
  145. }
  147. /*  ---------------------  OPEN BLOCK CHANNEL ROUTINE  ---------------------  */
  149. /*   DESCRIPTION:
  151.      chan_id = open_block_channel ( filename )
  153.      This routine is called to establish a new channel to access the values of
  154. all of the variables in a data file.  The values of the data file variables are
  155. accessed with the read_block routine.  This function returns a channel id
  156. ("chan_id") which is used to identify the opened channel when calling other
  157. disk read routines.  "filename" can have an extension, but it is not mandatory.
  159. If "filename" has an extension:
  160.      a) The extension is tested for validity.  (eg. Is it .sg_data or one of
  161.         the other types that can be read by these routines?)  Valid extensions
  162.         are these:  .sg_data; .spd
  163.      b) If the extension is valid, open_var_channel tries to open "filename".
  164.         If the extension is not valid, an error is returned.
  166. If "filename" does not have an extension:
  167.      a) Each valid extension is concatenated with a copy of filename and the
  168.         resulting filename is tested for existance.
  169.      b) If this file exists, open_var_channel tries to open it.
  170.         If none of these files exist, an error is returned.
  172. If the file to be opened has the .sg_data extension, the format information
  173. must reside in a corresponding .sg_format file.
  175. Returned value:
  177.      If there are no errors, the returned value is a channel id which is used to
  178. identify the open channel when using other disk read routines.  A valid channel
  179. id is >= 0.  If an error occurs, the returned value is < 0.
  181. The following errors are detected:
  183.      - filename is too long
  184.      - all channels are open
  185.      - there is a format file problem
  186.      - invalid extension in filename
  187.      - no data file found
  188.      - the data file could not be opened
  189. */
  191. open_block_channel ( filename )
  193. char filename[];
  195. {
  196.    int chan_id;
  198.    chan_id = open_channel(filename, 2, "");
  200.    strcpy(ervar.routine, "open_block_channel");
  201.    strncpy(ervar.name, filename, MAX_FILENAME_LENG);
  202.    strcat(ervar.name, "");
  204.    if (chan_id < 0 && auto_er) error_exit(chan_id);
  205.    return(chan_id);
  206. }
  208. /*  ------------------------  OPEN CHANNEL ROUTINE  ------------------------  */
  210. /*   DESCRIPTION:
  212.      chan_id = open_channel ( file, chan_type, vname )
  214.      This routine is for use only by the disk_read module; it cannot be called
  215. from anywhere else.  It does the actual channel opening operations for each
  216. channel type.  "chan_type" indicates the type of channel being requested.  Two
  217. channel types are currently defined according to the type of access desired:
  219.      1 - single variable access
  220.      2 - block access (all block variables)
  222. "vname" is the name of the variable accessed on type 1 channels.
  223. */
  225. static open_channel ( file, chan_type, vname )
  227. char file[], vname[];
  228. int chan_type;
  230. {
  231.    int format[2 + 2*MAX_VARS_PER_BLK], var_num, i, temp_fd, chan, file_status;
  232.    char filename[MAX_FILENAME_LENG + sizeof(DFE)];
  233.    static char varnames[MAX_VARS_PER_BLK][MAX_VARNAME_LENG + 1];
  234.    static char *vnames[MAX_VARS_PER_BLK] = {
  235. varnames[ 0], varnames[ 1], varnames[ 2], varnames[ 3],
  236. varnames[ 4], varnames[ 5], varnames[ 6], varnames[ 7],
  237. varnames[ 8], varnames[ 9], varnames[10], varnames[11],
  238. varnames[12], varnames[13], varnames[14], varnames[15],
  239. varnames[16], varnames[17], varnames[18], varnames[19],
  240. varnames[20], varnames[21], varnames[22], varnames[23],
  241. varnames[24], varnames[25], varnames[26], varnames[27],
  242. varnames[28], varnames[29], varnames[30], varnames[31],
  243. varnames[32], varnames[33], varnames[34], varnames[35] };
  244. /*
  245.  *    do the easy error checking:
  246.  */
  247.    if (strlen(file) > MAX_FILENAME_LENG) return(-2);
  248. /*
  249.  *    look for first available channel:
  250.  */
  251.    chan = -1;
  252.    for (i=0; i<MAX_CHANNELS; i++)
  253.    {
  254.       if (fd[i].open == 0)
  255.       {
  256.          chan = i;
  257.          break;
  258.       }
  259.    }
  260.    if (chan == -1) return(-14);
  261. /*
  262.  *    read format file:
  263.  */
  264.    if (read_format( file, format, vnames ) < 0)  return(-12);
  265. /*
  266.  *    if type 1 channel, find the variable number from the variable name:
  267.  */
  268.    var_num = 0;
  269.    if (chan_type==1)
  270.    {
  271.       for (i=0; i<format[1]; i++)
  272.       {
  273.          if (strcmp(vname, vnames[i]) == 0)
  274.          {
  275.             var_num = i+1;
  276.             break;
  277.          }
  278.       }
  279.       if (var_num == 0) return(-15);
  280.    }
  281. /*
  282.  *    check for filename extension options and open the data file:
  283.  */
  284.    file_status = test_filename(file, filename, 1);
  285.    if (file_status == -2) return(-10);  /* invalid extension */
  286.    if (file_status == -1) return(-16);  /* no data file found */
  287.    if( (temp_fd = open(filename, O_RDONLY)) == -1)  /* couldn't open */
  288.    {
  289.       perror("The system call error in disk read is");
  290.       return(-13);
  291.    }
  292. /*
  293.  *    write the data file structure variables:
  294.  */
  295.    fd[chan].open = 1;
  296.    strcpy( fd[chan].filename, file );
  297.    for (i=0; i < 2*format[1]+2; i++) fd[chan].format[i] = format[i];
  298.    fd[chan].fd = temp_fd;
  299.    fd[chan].ch_type = chan_type;
  300.    fd[chan].v = var_num;
  301.    fd[chan].next = 1;
  302.    fd[chan].samp_p_blk = 0;
  303.    fd[chan].byte_p_blk = 0;
  304.    for (i=1; i<=format[1]; i++)
  305.    {
  306.       fd[chan].samp_p_blk += format[2*i+1];
  307.       fd[chan].byte_p_blk += bytes_in[format[2*i] -1] * format[2*i+1];
  308.       fd[chan].bytes[i-1]  = bytes_in[format[2*i] -1] * format[2*i+1];
  309.    }
  310.    fd[chan].gap_head = 0;
  311.    fd[chan].gap_total = 0;
  312.    if (chan_type == 1 && format[1] > 1)  /*  the general case  */
  313.    {
  314.       fd[chan].samp_avail = format[2*var_num + 1];
  315.       fd[chan].gap_total = fd[chan].byte_p_blk
  316.               - bytes_in[format[2*var_num] -1] * format[2*var_num + 1];
  317.       for (i=1; i<var_num; i++)
  318.             fd[chan].gap_head += bytes_in[format[2*i] -1] * format[2*i+1];
  319.       lseek(fd[chan].fd, (long) fd[chan].gap_head, 1);
  320. /*
  321.  *    for testing only, print gap_head & gap_total:
  322.  *
  323.       printf("n%d gap_headn%d gap_totaln",
  324.              fd[chan].gap_head, fd[chan].gap_total );
  325.  */
  326.    }
  328. /*
  329.  *    for testing only, print samples/block & bytes/block:
  330.  *
  331.    printf("n%d samples/blockn%d bytes/blocknn",
  332.           fd[chan].samp_p_blk, fd[chan].byte_p_blk );
  333.  */
  334.    return(chan);
  335. }
  337. /*  ------------------------  READ FORMAT ROUTINE  -------------------------  */
  339. /*   DESCRIPTION:
  341.      status = read_format ( filename, format, vnames )
  343.      This routine determines the format associated with file "filename" and
  344. returns this information.  As with the filename argument in the open channel
  345. routines, read_format accepts filenames with or without extensions.  It uses the
  346. same process that the open channel routines use to determine for what data file
  347. the format information is sought.  Hence, for a given filename, read_format
  348. always gets the format which corresponds to the data file opened by an open
  349. channel routine.  (However, read_format accepts filenames that end with
  350. .sg_format.  Such a filename would cause an error if given to an open channel
  351. routine.)
  353. The format array contains the following information:
  355.      format[0]   -   file type indicator
  356.                      current meaning (will be expanded later):
  357.                      1 if .sg_data file allows sample & block positioning;
  358.                      0 if this is NOT allowed
  359.      format[1]   -   number of variables/block in .sg_data file
  360.      format[2*n]  -  data type of variable n in .sg_data file
  361.                      1 - short; 2 - int; 3 - float
  362.      format[2*n+1] - number of entries/block of variable n in .sg_data file
  364. "vnames" is an array of pointers to the names of variables saved in the data
  365. file.  Thus, vnames[0] points to the name of the first variable, vnames[1]
  366. points to the name of the second variable, etc.
  368.      The format information comes from a .sg_format file when the data file is
  369. a .sg_data file.  Other data file types have fixed formats which return a set
  370. of parameters stored in this routine.  Below are listed the format parameters
  371. for each of these other data file types.
  373. Format parameters for .spd data files:
  375.      format[0] = 1
  376.      format[1] = 1
  377.      format[2] = 1
  378.      format[3] = 512
  379.      vnames[0] = "speech_data"
  381. Returned value:
  383.      The returned value indicates the error status of the routine.  If no error
  384. occurs, the returned value is 0.  If an error occurs, the value is < 0.
  386. The following errors are detected:
  388.      - filename is too long
  389.      - invalid extension in filename
  390.      - no data file found, so can't determine format
  391.      - the format file could not be opened
  392.      - the format file is not complete
  393.      - invalid value read for file type
  394.      - invalid value read for variables/block
  395.      - invalid value read for data type
  396.      - invalid value read for values/block
  397. */
  399. read_format ( file, format, vnames )
  401. char file[], *vnames[];
  402. int format[];
  404. {
  405.    short frmt[2 + 2*MAX_VARS_PER_BLK];
  406.    int temp_fd, i, file_status;
  407.    char filename[MAX_FILENAME_LENG + sizeof(FFE)];
  409.    strcpy(ervar.routine, "read_format");
  410.    strncpy(ervar.name, file, MAX_FILENAME_LENG);
  411.    strcat(ervar.name, "");
  413.    if (strlen(file) > MAX_FILENAME_LENG)  /* filename too long */
  414.    {
  415.       if (auto_er) error_exit(-2);
  416.       return(-2);
  417.    }
  418. /*
  419.  *    check for filename extension options:
  420.  */
  421.    file_status = test_filename(file, filename, 2);
  422.    if (file_status == -2)                /* invalid extension */
  423.    {
  424.       if (auto_er) error_exit(-10);
  425.       return(-10);
  426.    }
  427.    if (file_status == -1)                /* no data file found */
  428.    {
  429.       if (auto_er) error_exit(-25);
  430.       return(-25);
  431.    }
  432.    if (file_status == 1)   /* the file is a .spd file */
  433.    {                          /* set default values */
  434.       format[0] = 1;
  435.       format[1] = 1;
  436.       format[2] = 1;
  437.       format[3] = 512;
  438.       strcpy( vnames[0], "speech_data" );
  439.       return(0);
  440.    }
  441. /*
  442.  *    the file is the usual .sg_format type.  open it:
  443.  */
  444.    if( (temp_fd = open(filename, O_RDONLY)) == -1) /* can't open format file */
  445.    {
  446.       perror("The system call error in disk read is");
  447.       if (auto_er) error_exit(-19);
  448.       return(-19);
  449.    }
  450. /*
  451.  *    read format[0] & format[1]:
  452.  */
  453.    if (read(temp_fd, (char *) frmt, 4) != 4) /* incomplete format file */
  454.    {
  455.       close(temp_fd);
  456.       if (auto_er) error_exit(-20);
  457.       return(-20);
  458.    }
  459. /*
  460.  *    check format[0] & format[1] for proper values:
  461.  */
  462.    if (frmt[0] < 0 || frmt[0] > 1)           /* invalid file type */
  463.    {
  464.       close(temp_fd);
  465.       ervar.param = frmt[0];
  466.       if (auto_er) error_exit(-21);
  467.       return(-21);
  468.    }
  469.    if (frmt[1] < 1 || frmt[1] > MAX_VARS_PER_BLK) /* invalid # of vars/block */
  470.    {
  471.       close(temp_fd);
  472.       ervar.param = frmt[1];
  473.       if (auto_er) error_exit(-22);
  474.       return(-22);
  475.    }
  476. /*
  477.  *    read the data type and number per block from format file:
  478.  */
  479.    if (4*frmt[1] != read(temp_fd, (char *) &frmt[2], (int) 4*frmt[1]))
  480.    {
  481.       close(temp_fd);
  482.       if (auto_er) error_exit(-20);
  483.       return(-20);
  484.    }
  485. /*
  486.  *    check the data type and number per block; and read the variable names:
  487.  */
  488.    for (i=1; i<=frmt[1]; ++i)
  489.    {
  490.       if (frmt[2*i] < 1 || frmt[2*i] > NUM_DATA_TYPES) /* invalid data type */
  491.       {
  492.          close(temp_fd);
  493.          ervar.param = frmt[2*i];
  494.          if (auto_er) error_exit(-23);
  495.          return(-23);
  496.       }
  497.       if (frmt[2*i+1] < 1 || frmt[2*i+1] > MAX_VALUES_PER_VAR) /* invalid # of vals per block */
  498.       {
  499.          close(temp_fd);
  500.          ervar.param = frmt[2*i+1];
  501.          if (auto_er) error_exit(-24);
  502.          return(-24);
  503.       }
  504.       *(vnames[i-1]+MAX_VARNAME_LENG) = '';  /* ensure null termination */
  505.       if (MAX_VARNAME_LENG != read(temp_fd, vnames[i-1], MAX_VARNAME_LENG) )
  506.       {
  507.          close(temp_fd);
  508.          if (auto_er) error_exit(-20);
  509.          return(-20);
  510.       }
  511.    }
  512. /*
  513.  *   everything OK, so transfer format info to int array and close format file:
  514.  */
  515.    for (i=0; i<2*MAX_VARS_PER_BLK + 2; i++) format[i] = frmt[i];
  516.    close(temp_fd);
  517.    return(0);
  518. }
  520. /*  ------------------------  FILE LENGTH ROUTINE  -------------------------  */
  522. /*   DESCRIPTION:
  524.      status = file_length ( chan_id, bytes, samples, blocks )
  526.      This routine returns the length of the file connected to "chan_id" in
  527. terms of bytes, samples and blocks.  I don't know what it should do with
  528. real-time data files yet.
  530. Returned value:
  532.      The returned value indicates the error status of the routine.  If no error
  533. occurs, the returned value is 0.  If an error occurs, the value is < 0.
  535. The following errors are detected:
  537.      - channel number is outside valid range
  538.      - specified channel is not open
  539. */
  541. file_length ( channel, bytes, samples, blocks )
  543. int channel, *bytes, *samples, *blocks;
  545. {
  546.    int length;
  547.    struct stat status;       /* for use with fstat */
  549.    strcpy(ervar.routine, "file_length");
  550.    strcpy(ervar.name, "UNKNOWN");  /* can't determine associated file name */
  552.    if (channel < 0 || channel >= MAX_CHANNELS)   /* bogus channel # */
  553.    {
  554.       ervar.param = channel;
  555.       if (auto_er) error_exit(-3);
  556.       return(-3);
  557.    }
  558.    if (fd[channel].open != 1)                    /* channel not open */
  559.    {
  560.       ervar.param = channel;
  561.       if (auto_er) error_exit(-4);
  562.       return(-4);
  563.    }
  564.    fstat(fd[channel].fd, &status);   /* unix library routine that returns */
  565.    length = status.st_size;          /* file length in structure "status" */
  566.    *bytes = length;
  567.    *blocks = length / fd[channel].byte_p_blk;
  568.    *samples = *blocks * fd[channel].samp_p_blk;
  569.    return(0);
  570. }
  572. /*  ------------------------  GOTO SAMPLE ROUTINE  -------------------------  */
  574. /*   DESCRIPTION:
  576.      position = goto_sample ( chan_id, sample_num, how )
  578.      This routine changes the sample number that the next call to read_variable
  579. on "chan_id" reads from.  When "how" is 0, "sample_num" is measured from the
  580. beginning of the file (i.e. absolute positioning).  When "how" is not 0,
  581. "sample_num" is measured from the current file position (i.e. relative
  582. positioning).  The first sample in the file is called sample 1.  This routine
  583. can be called only if the specified channel is a "variable channel", that is
  584. one opened via open_var_channel.  This routine does not return an error if the
  585. sample to be read is beyond the end of file; this condition is reported when
  586. reading.  
  588. Returned value:
  590.      If there are no errors, the returned value indicates the current file
  591. position (the sample number of the next sample to be read by read_variable).
  592. A valid sample number is 1 or greater.  If an error occurs, the value is < 0.
  594. The following errors are detected:
  596.      - channel number is outside valid range
  597.      - specified channel is not open
  598.      - this routine is for use only with variable channel types
  599.      - the file connected to this channel prohibits positioning
  600.      - effective sample_num is < 1
  601. */
  603. goto_sample ( channel, sample_num, how )
  605. int channel, sample_num, how;
  607. {
  608.    int samp_per_rec, skipped_rec, skipped_samp, next;
  609.    long p;
  611.    strcpy(ervar.routine, "goto_sample");
  612.    strcpy(ervar.name, "UNKNOWN");  /* the first 2 errors have no f or v name */
  613. /*
  614.  *    do the easy error checking:
  615.  */
  616.    if (channel < 0 || channel >= MAX_CHANNELS) /* bogus channel # */
  617.    {
  618.       ervar.param = channel;
  619.       if (auto_er) error_exit(-3);
  620.       return(-3);
  621.    }
  622.    if (fd[channel].open != 1)                 /* channel not open */
  623.    {
  624.       ervar.param = channel;
  625.       if (auto_er) error_exit(-4);
  626.       return(-4);
  627.    }
  628.    strcpy(ervar.name, fd[channel].filename);
  629.    if (fd[channel].ch_type != 1)              /* not a "variable" chan type */
  630.    {
  631.       if (auto_er) error_exit(-7);
  632.       return(-7);
  633.    }
  634.    if (fd[channel].format[0] != 1)            /* file prohibits positioning */
  635.    {
  636.       if (auto_er) error_exit(-9);
  637.       return(-9);
  638.    }
  639.    next = (how == 0) ? sample_num : sample_num + fd[channel].next;
  640.    if (next < 1)                              /* invalid sample # */
  641.    {
  642.       ervar.param = next;
  643.       if (auto_er) error_exit(-27);
  644.       return(-27);
  645.    }
  646.    fd[channel].next = next;
  647.    samp_per_rec = fd[channel].format[2*fd[channel].v + 1];
  648.    skipped_rec  = (fd[channel].next - 1) / samp_per_rec;
  649.    skipped_samp = (fd[channel].next - 1) % samp_per_rec;
  650.    p = skipped_rec * fd[channel].byte_p_blk + fd[channel].gap_head
  651.          + skipped_samp * bytes_in[fd[channel].format[2*fd[channel].v] -1];
  652.    lseek(fd[channel].fd, p, 0);
  653.    fd[channel].samp_avail = samp_per_rec - skipped_samp;
  654.    return(next);
  655. }
  657. /*  -----------------------  READ VARIABLE ROUTINE  ------------------------  */
  659. /*   DESCRIPTION:
  661.      position = read_variable ( chan_id, values, num, num_read )
  663.      This routine returns the next "num" values of the variable connected to
  664. channel number "chan_id".  "values" is a pointer to an array where the returned
  665. values are placed.  In the calling routine, this array type should match that of
  666. the variable being returned.  The size of "n" is limited only by the array size
  667. in the calling routine.  The actual number of values read is returned via the
  668. pointer "num_read".  "num_read" will equal "num" unless an error (specified
  669. below) occurs; in this case, it may be zero to num-1.  This routine can be
  670. called only if the specified channel is a "variable channel", that is one
  671. opened via open_var_channel.
  673. Returned value:
  675.      If there are no errors, the returned value indicates the current file
  676. position (the sample number of the next sample to be read by read_variable).
  677. A valid sample number is 1 or greater.  If an error occurs, the value is < 0.
  679. The following errors are detected:
  681.      - error during the file read operation
  682.      - EOF encountered on the data file
  683.      - channel number is outside valid range
  684.      - specified channel is not open
  685.      - this routine is for use only with variable channel types
  686. */
  688. read_variable ( channel, values, n, n_read )
  690. int channel, n, *n_read;
  691. char values[];
  693. {
  694.    int bytes, b_read, s_read;
  696.    strcpy(ervar.routine, "read_variable");
  697.    strcpy(ervar.name, "UNKNOWN");  /* the first 2 errors have no f or v name */
  699.    *n_read = 0;   /*  set number read in case of an early error   */
  700. /*
  701.  *    do the easy error checking:
  702.  */
  703.    if (channel < 0 || channel >= MAX_CHANNELS) /* bogus channel # */
  704.    {
  705.       ervar.param = channel;
  706.       if (auto_er) error_exit(-3);
  707.       return(-3);
  708.    }
  709.    if (fd[channel].open != 1)                  /* channel not open */
  710.    {
  711.       ervar.param = channel;
  712.       if (auto_er) error_exit(-4);
  713.       return(-4);
  714.    }
  715.    strcpy(ervar.name, fd[channel].filename);
  716.    if (fd[channel].ch_type != 1)               /* not a "variable" channel */
  717.    {
  718.       if (auto_er) error_exit(-7);
  719.       return(-7);
  720.    }
  721. /*
  722.  *    split into two cases, 1 variable or >1 variable in file:
  723.  */
  724.    if (fd[channel].format[1] == 1)   /* .sg_data file has only 1 variable */
  725.    {
  726.       bytes =  bytes_in[fd[channel].format[2] -1] * n;
  727.       b_read = read(fd[channel].fd, values, bytes);
  728.       if (b_read == -1)     /* error during read */
  729.       {
  730.          perror("The system call error in disk read is");
  731.          if (auto_er) error_exit(-6);
  732.          return(-6);
  733.       }
  734.       *n_read = b_read / bytes_in[fd[channel].format[2] -1];
  735.    }
  736.    else          /* .sg_data file has several variables, the general case */
  737.    {
  738.       s_read = read_sg(channel, values, n);
  739.       if (s_read == -1)     /* error during read */
  740.       {
  741.          perror("The system call error in disk read is");
  742.          if (auto_er) error_exit(-6);
  743.          return(-6);
  744.       }
  745.       *n_read = s_read;
  746.    }
  747.    fd[channel].next += *n_read;
  748.    if (*n_read != n)        /* EOF encountered */
  749.    {
  750.       if (auto_er) error_exit(-5);
  751.       return(-5);
  752.    }
  753.    return(fd[channel].next);
  754. }
  756. /*  ------------------------  GOTO BLOCK ROUTINE  --------------------------  */
  758. /*   DESCRIPTION:
  760.      position = goto_block ( chan_id, block_num, how )
  762.      This routine changes the place from which data is read in the file
  763. connected to "chan_id".  When 'how' is 0, 'block_num' is measured from the
  764. beginning of the file (i.e. absolute positioning).  When 'how' is not 0,
  765. 'block_num' is measured from the current file position (i.e. relative
  766. positioning).  It can be used on block channels and on variable channels.
  767. The first block in a file is called block 1.  This routine does not return an
  768. error if positioned beyond the end of file; this condition is reported when
  769. reading.
  771.      On block channels the repositioning is as follows:
  773.      If doing absolute positioning, the block number read by the next read_block
  774. is "block_num".
  775.      If doing relative positioning, the block number read by the next read_block
  776. is changed by "block_num" blocks.
  778.      On variable channels the repositioning is as follows:
  780.      If doing absolute positioning, the first sample read by the next
  781. read_variable is sample number:
  782. 1 + (block_num - 1) * (# of values of variable per block)
  783.      If doing relative positioning, the first sample read by the next
  784. read_variable is changed by "block_num" blocks.
  786. Returned value:
  788.      If there are no errors, the returned value indicates the current file
  789. position.  On variable channels, the returned value is the sample number of the
  790. next sample to be read by read_variable.  On block channels, the returned value
  791. is the block number of the next block to be read by read_block.  A valid sample
  792. number or block number is 1 or greater.  If an error occurs, the value is < 0.
  794. The following errors are detected:
  796.      - channel number is outside valid range
  797.      - specified channel is not open
  798.      - the file connected to this channel prohibits positioning
  799.      - effective block_num < 1
  800. */
  802. goto_block ( channel, block_num, how )
  804. int channel, block_num, how;
  806. {
  807.    int next;
  808.    long p;
  810.    strcpy(ervar.routine, "goto_block");
  811.    strcpy(ervar.name, "UNKNOWN");  /* the first 2 errors have no f or v name */
  812. /*
  813.  *    do the easy error checking:
  814.  */
  815.    if (channel < 0 || channel >= MAX_CHANNELS) /* bogus channel # */
  816.    {
  817.       ervar.param = channel;
  818.       if (auto_er) error_exit(-3);
  819.       return(-3);
  820.    }
  821.    if (fd[channel].open != 1)                  /* channel not open */
  822.    {
  823.       ervar.param = channel;
  824.       if (auto_er) error_exit(-4);
  825.       return(-4);
  826.    }
  827.    strcpy(ervar.name, fd[channel].filename);
  828.    if (fd[channel].format[0] != 1)             /* file prohibits positioning */
  829.    {
  830.       if (auto_er) error_exit(-9);
  831.       return(-9);
  832.    }
  833. /*
  834.  *    partition according to positioning type:
  835.  */
  836.    if (how == 0)   /* absolute positioning */
  837.    {
  838.       next = (fd[channel].ch_type == 2) ? block_num :
  839.               1 + (block_num  - 1) * fd[channel].format[2*fd[channel].v+1];
  840.       if (next < 1)   /* invalid block # */
  841.       {
  842.          ervar.param = block_num;
  843.          if (auto_er) error_exit(-30);
  844.          return(-30);
  845.       }
  846.       p = (block_num - 1) * fd[channel].byte_p_blk;
  847.       lseek(fd[channel].fd, p, 0);
  848. /*
  849.  *    check for the general case and skip gap_head bytes, if so:
  850.  */
  851.       if (fd[channel].ch_type == 1 && fd[channel].format[1] > 1)
  852.       {
  853.          lseek(fd[channel].fd, (long) fd[channel].gap_head, 1);
  854.          fd[channel].samp_avail = fd[channel].format[2*fd[channel].v+1];
  855.       }
  856.    }
  857.    else           /* relative positioning */
  858.    {
  859.       next = (fd[channel].ch_type == 2) ? fd[channel].next + block_num :
  860.              fd[channel].next + block_num * fd[channel].format[2*fd[channel].v+1];
  861.       if (next < 1)   /* invalid block # */
  862.       {
  863.          ervar.param = (fd[channel].ch_type==2) ? next : (fd[channel].next-1) /
  864.                        fd[channel].format[2*fd[channel].v+1] + 1 + block_num;
  865.          if (auto_er) error_exit(-30);
  866.          return(-30);
  867.       }
  868.       p = block_num * fd[channel].byte_p_blk;
  869.       lseek(fd[channel].fd, p, 1);
  870.    }
  871.    fd[channel].next = next;
  872.    return(next);
  873. }
  875. /*  ------------------------  READ BLOCK ROUTINE  --------------------------  */
  877. /*   DESCRIPTION:
  879.      position = read_block ( chan_id, val_pntr )
  881.      This routine returns one block of values from the file connected to
  882. channel "chan_id".  "val_pntr" is an array of pointers having one element for
  883. each block variable.  The calling routine sets each pointer in the array to
  884. specify where the values for each block variable are to go.  Thus, val_pntr[0]
  885. is the address where the first value of the first block variable will be stored;
  886. val_pntr[1] is the address where the first value of the second block variable
  887. will be stored; etc.  Subsequent values of the variables are stored in
  888. sequential locations following the address of the first value.
  890. Returned value:
  892.      If there are no errors, the returned value indicates the current file
  893. position (the block number of the next block to be read by read_block).  A
  894. valid block number is 1 or greater.  If an error occurs, the value is < 0.
  896. The following errors are detected:
  898.      - channel number is outside valid range
  899.      - specified channel is not open
  900.      - this routine is for use only with block channel types
  901.      - error during the file read operation
  902.      - EOF encountered on the data file
  903. */
  905. read_block ( channel, val_pntr )
  907. char *val_pntr[];
  908. int channel;
  910. {
  911.    int i, err;
  912.    short num_left, num_to_read;
  913.    struct iovec {
  914.       char *iov_base;
  915.       int   iov_length;
  916.       };
  917.    struct iovec io_vector[MAX_VARS_PER_BLK];
  919.    strcpy(ervar.routine, "read_block");
  920.    strcpy(ervar.name, "UNKNOWN");  /* the first 2 errors have no f or v name */
  921. /*
  922.  *    do the easy error checking:
  923.  */
  924.    if (channel < 0 || channel >= MAX_CHANNELS) /* bogus channel # */
  925.    {
  926.       ervar.param = channel;
  927.       if (auto_er) error_exit(-3);
  928.       return(-3);
  929.    }
  930.    if (fd[channel].open != 1)                  /* channel not open */
  931.    {
  932.       ervar.param = channel;
  933.       if (auto_er) error_exit(-4);
  934.       return(-4);
  935.    }
  936.    strcpy(ervar.name, fd[channel].filename);
  937.    if (fd[channel].ch_type != 2)               /* not a "block" channel */
  938.    {
  939.       if (auto_er) error_exit(-8);
  940.       return(-8);
  941.    }
  942. /*
  943.  *    write the input vector:
  944.  */
  945.    for (i=0; i<fd[channel].format[1]; i++)
  946.    {
  947.       io_vector[i].iov_base = val_pntr[i];
  948.       io_vector[i].iov_length = fd[channel].bytes[i];
  949.    }
  950. /*
  951.  *    read the block in chunks of 16 variables at a time (readv limitation):
  952.  */
  953.    i = 0;
  954.    num_left = fd[channel].format[1];
  955.    while (num_left > 0)
  956.    {
  957.       num_to_read = 16;
  958.       if (num_left < 16) num_to_read = num_left;
  959.       err = readv(fd[channel].fd, &io_vector[i], num_to_read);
  960.       if (err == -1)         /* error during read */
  961.       {
  962.          perror("The system call error in disk read is");
  963.          if (auto_er) error_exit(-6);
  964.          return(-6);
  965.       }
  966.       if (err == 0)          /* EOF encountered */
  967.       {
  968.          if (auto_er) error_exit(-5);
  969.          return(-5);
  970.       }
  971.       i += num_to_read;
  972.       num_left -= num_to_read;
  973.    }
  974.    return(++fd[channel].next);
  975. }
  977. /*  -----------------------  CLOSE CHANNEL ROUTINE  ------------------------  */
  979. /*   DESCRIPTION:
  981.      status = close_channel ( chan_id )
  983.      This routine closes the specified channel.  Doing so makes the channel id
  984. available for re-assignment.
  986. Returned value:
  988.      The returned value indicates the error status of the routine.  If no error
  989. occurs, the returned value is 0.  If an error occurs, the value is < 0.
  991. The following errors are detected:
  993.      - channel number is outside valid range
  994.      - specified channel is not open
  995. */
  997. close_channel ( channel )
  999. int channel;
  1000. {
  1001.    strcpy(ervar.routine, "close_channel");
  1002.    strcpy(ervar.name, "UNKNOWN");  /* the first 2 errors have no f or v name */
  1004.    if (channel < 0 || channel >= MAX_CHANNELS) /* bogus channel # */
  1005.    {
  1006.       ervar.param = channel;
  1007.       if (auto_er) error_exit(-3);
  1008.       return(-3);
  1009.    }
  1010.    if (fd[channel].open != 1)                  /* channel not open */
  1011.    {
  1012.       ervar.param = channel;
  1013.       if (auto_er) error_exit(-4);
  1014.       return(-4);
  1015.    }
  1016.    fd[channel].open = 0;
  1017.    close (fd[channel].fd);
  1018.    return(0);
  1019. }
  1021. /*  -------------------  PRINT DISK READ ERROR ROUTINE  --------------------  */
  1023. /*   DESCRIPTION:
  1025.      print_disk_read_error ( err_num )
  1027.      This routine prints an error message which corresponds to "err_num".
  1028. It is printed on stderr.
  1029. */
  1031. print_disk_read_error ( err_num )
  1033. int err_num;
  1035. {
  1036.    char *disk_read_error ();
  1038.    if (err_num < 0)
  1039.    {
  1040.       fprintf(stderr, "Disk_IO error in routine '%s'.n", ervar.routine);
  1041.       fprintf(stderr, "The filename or variable name associated with the offending call is:n");
  1042.       fprintf(stderr, "%sn", ervar.name);
  1043.       fprintf(stderr, disk_read_error(err_num) );
  1044.       if (ervar.param != PARAM_OK)
  1045.       {
  1046.          fprintf(stderr, "Its value was: %dn", ervar.param);
  1047.          ervar.param = PARAM_OK;
  1048.       }
  1049.    }
  1050.    else fprintf(stderr, disk_read_error(err_num) );
  1052.    return;
  1053. }
  1055. /*  ----------------------  DISK READ ERROR ROUTINE  -----------------------  */
  1057. /*   DESCRIPTION:
  1059.      error_string = disk_read_error ( err_num )
  1061.      The disk_read_error routine returns a brief error message which
  1062. corresponds to "err_num".
  1063. */
  1065. char *disk_read_error ( err_num )
  1067. int err_num;
  1069. {
  1070.    static char err_string[70];
  1071.    static char *err_msg[] = {
  1072. "No error",                                                      /* 0 */
  1073. /*
  1074.  * COMMON ERRORS:
  1075.  */
  1076. "unassigned",                                                    /* 1 */
  1077. "Filename is too long",                                          /* 2 */
  1078. "Channel number is outside valid range",                         /* 3 */
  1079. "Specified channel is not open",                                 /* 4 */
  1080. "EOF encountered on the data file",                              /* 5 */
  1081. "Error during the file read operation",                          /* 6 */
  1082. "This routine is for use only with variable channel types",      /* 7 */
  1083. "This routine is for use only with block channel types",         /* 8 */
  1084. "The file connected to this channel prohibits positioning",      /* 9 */
  1085. "Invalid extension in filename",                                /* 10 */
  1086. "unassigned",                                                   /* 11 */
  1087. /*
  1088.  * OPEN CHANNEL ERRORS:
  1089.  */
  1090. "There is a format file problem",                               /* 12 */
  1091. "The data file could not be opened",                            /* 13 */
  1092. "All channels are open",                                        /* 14 */
  1093. "The specified variable was not found",                         /* 15 */
  1094. "No data file found",                                           /* 16 */
  1095. "unassigned",                                                   /* 17 */
  1096. "unassigned",                                                   /* 18 */
  1097. /*
  1098.  * READ FORMAT ERRORS:
  1099.  */
  1100. "The format file could not be opened",                          /* 19 */
  1101. "The format file is not complete",                              /* 20 */
  1102. "Invalid value read for file type",                             /* 21 */
  1103. "Invalid value read for variables/block",                       /* 22 */
  1104. "Invalid value read for data type",                             /* 23 */
  1105. "Invalid value read for values/block",                          /* 24 */
  1106. "No data file found, so can't determine format",                /* 25 */
  1107. /*
  1108.  * FILE LENGTH ERRORS:
  1109.  */
  1110. "unassigned",                                                   /* 26 */
  1111. /*
  1112.  * GOTO SAMPLE ERRORS:
  1113.  */
  1114. "Effective sample_num is < 1",                                  /* 27 */
  1115. "unassigned",                                                   /* 28 */
  1116. /*
  1117.  * READ VARIABLE ERRORS:
  1118.  */
  1119. "unassigned",                                                   /* 29 */
  1120. /*
  1121.  * GOTO BLOCK ERRORS:
  1122.  */
  1123. "Effective block_num is < 1",                                   /* 30 */
  1124. "unassigned",                                                   /* 31 */
  1125. /*
  1126.  * READ BLOCK ERRORS:
  1127.  */
  1128. "unassigned",                                                   /* 32 */
  1129. /*
  1130.  * CLOSE CHANNEL ERRORS:
  1131.  */
  1132. "unassigned",                                                   /* 33 */
  1133. /*
  1134.  * ALL OTHER ERRORS:
  1135.  */
  1136. "Bad value for error number"                                    /* 34 */
  1137. };
  1138. #define NUM 34
  1140.    if (err_num > 0) err_num = 0; /* force positive arguments to give no error */
  1141.    strcpy(err_string, (-err_num < NUM) ? err_msg[-err_num] : err_msg[NUM] );
  1142.    strcat(err_string, ".n");
  1143.    return(err_string);
  1144. }
  1146. /*  --------------------------  SUPPORT ROUTINES  --------------------------  */
  1148. /*  -----------------------  TEST FILENAME ROUTINE  ------------------------  */
  1150. /*   DESCRIPTION:
  1152.      This routine examines the filename "in_file" and returns in "out_file" the
  1153. data file or format file name which corresponds to "in_file".  "out_file_type"
  1154. specifies whether to return the name of a data file (if 1) or the format file
  1155. name (if 2).  This is the routine which implements the filename flexibility
  1156. which read_format and the open channel routines have.
  1158. The return value of the function indicates the following:
  1160.      -2 - invalid extension
  1161.      -1 - data file not found
  1162.       0 - in_file is .sg file type
  1163.       1 - in_file is .spd file type
  1164.     ( value increases by 1 for each added data file type )
  1165. */
  1167. static test_filename ( in_file, out_file, out_file_type )
  1169. char in_file[], out_file[];
  1170. int out_file_type;
  1172. {
  1173.    char extn[MAX_FILENAME_LENG];
  1175.    if (rindex(in_file, '.') == NULL) /* in_file does not have an extension */
  1176.    {
  1177.       strcpy(out_file, in_file);
  1178.       strcat(out_file, DFE);           /* out_file = in_file.DFE */
  1179.       if (access(out_file, 0) == 0)    /* out_file.DFE exists */
  1180.       {
  1181.          if (out_file_type == 2)       /* output the format file name instead */
  1182.          {
  1183.             strcpy(out_file, in_file);
  1184.             strcat(out_file, FFE);     /* out_file = in_file.FFE */
  1185.          }
  1186.          return(0);                    /* .sg file type */
  1187.       }
  1188.       strcpy(out_file, in_file);
  1189.       strcat(out_file, ".spd");        /* out_file = in_file.spd */
  1190.       if (access(out_file, 0) == 0) return(1);  /* .spd file type */
  1191.       return(-1);                      /* could not find a data file */
  1192.    }
  1193.    else                                /* in_file has an extension */
  1194.    {
  1195.       strcpy(extn, rindex(in_file, '.') );  /* extn = the extension */
  1196.       strcpy(out_file, "");            /* out_file = extensionless in_file */
  1197.       strncat(out_file, in_file, strlen(in_file)-strlen(extn) );
  1198.       if (strcmp(extn, DFE) == 0)      /* the extension is DFE */
  1199.       {
  1200.          if (out_file_type == 1) strcat(out_file, DFE);
  1201.          if (out_file_type == 2) strcat(out_file, FFE);
  1202.          return(0);                    /* .sg file type */
  1203.       }
  1204.       if (strcmp(extn, FFE) == 0)      /* the extension is FFE */
  1205.       {
  1206.          if (out_file_type == 1) return(-2);
  1207.          if (out_file_type == 2) strcat(out_file, FFE);
  1208.          return(0);                    /* .sg file type */
  1209.       }
  1210.       if (strcmp(extn, ".spd") == 0)   /* the extension is .spd */
  1211.       {
  1212.          strcpy(out_file, in_file);
  1213.          return(1);                    /* .spd file type */
  1214.       }
  1215.       return(-2);                      /* invalid extension */
  1216.    }
  1217. }
  1219. /*  -----------------------  READ SUNGRAPH DATA FILE  ----------------------  */
  1221. /*   DESCRIPTION:
  1223.      This routine is like "read" but instead reads data files which are in the
  1224. SUNGRAPH format.  It operates with channels opened for single variable access.
  1225. It fetches the next "samp" samples of the variable that "channel" was opened to
  1226. read.  The function value is the actual number of samples read, unless "read"
  1227. or "lseek" returns -1, in which case -1 is the function value.
  1228. */
  1230. static read_sg ( channel, values, samp )
  1232. char values[];
  1233. int channel, samp;
  1235. {
  1236.    register int bytes_per_samp, index, left;
  1237.    int n, bytes, total;
  1239.    total = 0;
  1240.    index = 0;
  1241.    left = samp;
  1242.    bytes_per_samp = bytes_in[fd[channel].format[2*fd[channel].v] -1];
  1244.    while (left > 0)
  1245.    {
  1246.       if (left >= fd[channel].samp_avail)  /* read to end of current block */
  1247.       {
  1248.          bytes = bytes_per_samp * fd[channel].samp_avail;
  1249.          n = read(fd[channel].fd, &values[index], bytes);
  1250.          if (n == -1) return(-1);  /* read error */
  1251.          if (n != bytes)          /* EOF reached */
  1252.          {
  1253.             fd[channel].samp_avail -= n / bytes_per_samp;
  1254.             return(total + n/bytes_per_samp);
  1255.          }
  1256.          total += fd[channel].samp_avail;
  1257.          left  -= fd[channel].samp_avail;
  1258.          index += bytes;
  1259.          lseek(fd[channel].fd, (long) fd[channel].gap_total, 1);
  1260.          fd[channel].samp_avail = fd[channel].format[2*fd[channel].v + 1];
  1261.       }
  1262.       else     /* read just the number of samples left to fetch for this call */
  1263.       {
  1264.          bytes = bytes_per_samp * left;
  1265.          n = read(fd[channel].fd, &values[index], bytes);
  1266.          if (n == -1) return(-1);  /* read error */
  1267.          if (n != bytes)           /* EOF reached */
  1268.          {
  1269.             fd[channel].samp_avail -= n / bytes_per_samp;
  1270.             return(total + n/bytes_per_samp);
  1271.          }
  1272.          total += left;
  1273.          fd[channel].samp_avail -= left;
  1274.          left = 0;
  1275.       }
  1276.    }
  1277.    return(total);
  1278. }
  1281. /*  -----------------------------  ERROR_EXIT  -----------------------------  */
  1283. static error_exit(err_num)
  1285. int err_num;
  1287. {
  1288.    print_disk_read_error(err_num);
  1289.    exit(-1);
  1290. }