configfile.c

JM 11.0 KTA 2.1 Source Code

/*!
***********************************************************************
* \file
*    configfile.c
* \brief
*    Configuration handling.
* \author
*  Main contributors (see contributors.h for copyright, address and affiliation details)
*    - Stephan Wenger           <[e-mail]>
* \note
*    In the future this module should hide the Parameters and offer only
*    Functions for their access.  Modules which make frequent use of some parameters
*    (e.g. picture size in macroblocks) are free to buffer them on local variables.
*    This will not only avoid global variable and make the code more readable, but also
*    speed it up.  It will also greatly facilitate future enhancements such as the
*    handling of different picture sizes in the same sequence.                         \n
*                                                                                      \n
*    For now, everything is just copied to the inp_par structure (gulp)
*
**************************************************************************************
* \par Configuration File Format
**************************************************************************************
* Format is line oriented, maximum of one parameter per line                           \n
*                                                                                      \n
* Lines have the following format:                                                     \n
* \<ParameterName\> = \<ParameterValue\> # Comments \\n                                    \n
* Whitespace is space and \\t
* \par
* \<ParameterName\> are the predefined names for Parameters and are case sensitive.
*   See configfile.h for the definition of those names and their mapping to
*   configinput->values.
* \par
* \<ParameterValue\> are either integers [0..9]* or strings.
*   Integers must fit into the wordlengths, signed values are generally assumed.
*   Strings containing no whitespace characters can be used directly.  Strings containing
*   whitespace characters are to be inclosed in double quotes ("string with whitespace")
*   The double quote character is forbidden (may want to implement something smarter here).
* \par
* Any Parameters whose ParameterName is undefined lead to the termination of the program
* with an error message.
*
* \par Known bug/Shortcoming:
*    zero-length strings (i.e. to signal an non-existing file
*    have to be coded as "".
*
* \par Rules for using command files
*                                                                                      \n
* All Parameters are initially taken from DEFAULTCONFIGFILENAME, defined in configfile.h.
* If an -f \<config\> parameter is present in the command line then this file is used to
* update the defaults of DEFAULTCONFIGFILENAME.  There can be more than one -f parameters
* present.  If -p <ParameterName = ParameterValue> parameters are present then these
* override the default and the additional config file's settings, and are themselves
* overridden by future -p parameters.  There must be whitespace between -f and -p commands
* and their respective parameters
***********************************************************************
*/

#define INCLUDED_BY_CONFIGFILE_C

#include <stdlib.h>
#include <string.h>
#include <assert.h>

#if defined WIN32
#include <io.h>
#define strcasecmp strcmpi
#else
#include <unistd.h>
#endif
#include <fcntl.h>
#include <sys/stat.h>

#include "global.h"
#include "configfile.h"

#include "fmo.h"

#ifdef WIN32
#pragma warning(disable : 4996)
#endif

char *GetConfigFileContent (char *Filename);
static void ParseContent (char *buf, int bufsize);
static int ParameterNameToMapIndex (char *s);
static int InitEncoderParams(void);
static int TestEncoderParams(int bitdepth_qp_scale);
static int DisplayEncoderParams(void);
static void PatchInp (void);
static void ProfileCheck(void);
static void LevelCheck(void);

#ifdef SWITCHED_FILTERS
#include "switched_filters.h"
#endif  // SWITCHED_FILTERS

#define MAX_ITEMS_TO_PARSE  10000


/*!
***********************************************************************
* \brief
*   print help message and exit
***********************************************************************
*/
void JMHelpExit (void)
{
  fprintf( stderr, "\n   lencod [-h] [-d defenc.cfg] {[-f curenc1.cfg]...[-f curencN.cfg]}"
    " {[-p EncParam1=EncValue1]..[-p EncParamM=EncValueM]}\n\n"    
    "## Parameters\n\n"
    
    "## Options\n"
    "   -h :  prints function usage\n"
    "   -d :  use <defenc.cfg> as default file for parameter initializations.\n"
    "         If not used then file defaults to encoder.cfg in local directory.\n"
    "   -f :  read <curencM.cfg> for reseting selected encoder parameters.\n"
    "         Multiple files could be used that set different parameters\n"
    "   -p :  Set parameter <EncParamM> to <EncValueM>.\n"
    "         See default encoder.cfg file for description of all parameters.\n\n"
    
    "## Supported video file formats\n"
    "   RAW:  .yuv -> YUV 4:2:0\n\n"
    
    "## Examples of usage:\n"
    "   lencod\n"
    "   lencod  -h\n"
    "   lencod  -d default.cfg\n"
    "   lencod  -f curenc1.cfg\n"
    "   lencod  -f curenc1.cfg -p InputFile=\"e:\\data\\container_qcif_30.yuv\" -p SourceWidth=176 -p SourceHeight=144\n"  
    "   lencod  -f curenc1.cfg -p FramesToBeEncoded=30 -p QPISlice=28 -p QPPSlice=28 -p QPBSlice=30\n");
  
  exit(-1);
}

/*!
***********************************************************************
* \brief
*    Parse the command line parameters and read the config files.
* \param ac
*    number of command line parameters
* \param av
*    command line parameters
***********************************************************************
*/
void Configure (int ac, char *av[])
{
  char *content;
  int CLcount, ContentLen, NumberParams;
  char *filename=DEFAULTCONFIGFILENAME;
  
  memset (&configinput, 0, sizeof (InputParameters));
  //Set default parameters.
  printf ("Setting Default Parameters...\n");
  InitEncoderParams();
  
  // Process default config file
  CLcount = 1;
  
  if (ac==2)
  {
    if (0 == strncmp (av[1], "-h", 2))
    {
      JMHelpExit();
    }
  }
  
  if (ac>=3)
  {
    if (0 == strncmp (av[1], "-d", 2))
    {
      filename=av[2];
      CLcount = 3;
    }
    if (0 == strncmp (av[1], "-h", 2))
    {
      JMHelpExit();
    }
  }
  printf ("Parsing Configfile %s", filename);
  content = GetConfigFileContent (filename);
  if (NULL==content)
    error (errortext, 300);
  ParseContent (content, strlen(content));
  printf ("\n");
  free (content);
  
  // Parse the command line
  
  while (CLcount < ac)
  {
    if (0 == strncmp (av[CLcount], "-h", 2))
    {
      JMHelpExit();
    }
    
    if (0 == strncmp (av[CLcount], "-f", 2))  // A file parameter?
    {
      content = GetConfigFileContent (av[CLcount+1]);
      if (NULL==content)
        error (errortext, 300);
      printf ("Parsing Configfile %s", av[CLcount+1]);
      ParseContent (content, strlen (content));
      printf ("\n");
      free (content);
      CLcount += 2;
    } else
    {
      if (0 == strncmp (av[CLcount], "-p", 2))  // A config change?
      {
        // Collect all data until next parameter (starting with -<x> (x is any character)),
        // put it into content, and parse content.
        
        CLcount++;
        ContentLen = 0;
        NumberParams = CLcount;
        
        // determine the necessary size for content
        while (NumberParams < ac && av[NumberParams][0] != '-')
          ContentLen += strlen (av[NumberParams++]);        // Space for all the strings
        ContentLen += 1000;                     // Additional 1000 bytes for spaces and \0s
        
        
        if ((content = malloc (ContentLen))==NULL) no_mem_exit("Configure: content");;
        content[0] = '\0';
        
        // concatenate all parameters identified before
        
        while (CLcount < NumberParams)
        {
          char *source = &av[CLcount][0];
          char *destin = &content[strlen (content)];
          
          while (*source != '\0')
          {
            if (*source == '=')  // The Parser expects whitespace before and after '='
            {
              *destin++=' '; *destin++='='; *destin++=' ';  // Hence make sure we add it
            } else
              *destin++=*source;
            source++;
          }
          *destin = '\0';
          CLcount++;
        }
        printf ("Parsing command line string '%s'", content);
        ParseContent (content, strlen(content));
        free (content);
        printf ("\n");
      }
      else
      {
        snprintf (errortext, ET_SIZE, "Error in command line, ac %d, around string '%s', missing -f or -p parameters?", CLcount, av[CLcount]);
        error (errortext, 300);
      }
    }
  }
  printf ("\n");
  PatchInp();
  if (input->DisplayEncParams)
    DisplayEncoderParams();
}

/*!
***********************************************************************
* \brief
*    allocates memory buf, opens file Filename in f, reads contents into
*    buf and returns buf
* \param Filename
*    name of config file
* \return
*    if successfull, content of config file
*    NULL in case of error. Error message will be set in errortext
***********************************************************************
*/
char *GetConfigFileContent (char *Filename)
{
  long FileSize;
  FILE *f;
  char *buf;
  
  if (NULL == (f = fopen (Filename, "r")))
  {
    snprintf (errortext, ET_SIZE, "Cannot open configuration file %s.", Filename);
    return NULL;
  }
  
  if (0 != fseek (f, 0, SEEK_END))
  {
    snprintf (errortext, ET_SIZE, "Cannot fseek in configuration file %s.", Filename);
    return NULL;
  }
  
  FileSize = ftell (f);
  if (FileSize < 0 || FileSize > 60000)
  {
    snprintf (errortext, ET_SIZE, "Unreasonable Filesize %ld reported by ftell for configuration file %s.", FileSize, Filename);
    return NULL;
  }
  if (0 != fseek (f, 0, SEEK_SET))
  {
    snprintf (errortext, ET_SIZE, "Cannot fseek in configuration file %s.", Filename);
    return NULL;
  }
  
  if ((buf = malloc (FileSize + 1))==NULL) no_mem_exit("GetConfigFileContent: buf");
  
  // Note that ftell() gives us the file size as the file system sees it.  The actual file size,
  // as reported by fread() below will be often smaller due to CR/LF to CR conversion and/or
  // control characters after the dos EOF marker in the file.
  
  FileSize = fread (buf, 1, FileSize, f);
  buf[FileSize] = '\0';
  
  
  fclose (f);
  return buf;
}


/*!
***********************************************************************
* \brief
*    Parses the character array buf and writes global variable input, which is defined in
*    configfile.h.  This hack will continue to be necessary to facilitate the addition of
*    new parameters through the Map[] mechanism (Need compiler-generated addresses in map[]).
* \param buf
*    buffer to be parsed
* \param bufsize
*    buffer size of buffer
***********************************************************************
*/
void ParseContent (char *buf, int bufsize)
{
  
  char *items[MAX_ITEMS_TO_PARSE];
  int MapIdx;
  int item = 0;
  int InString = 0, InItem = 0;
  char *p = buf;
  char *bufend = &buf[bufsize];
  int IntContent;
  double DoubleContent;
  int i;
  
  // Stage one: Generate an argc/argv-type list in items[], without comments and whitespace.
  // This is context insensitive and could be done most easily with lex(1).
  
  while (p < bufend)
  {
    switch (*p)
    {
    case 13:
      p++;
      break;
    case '#':                 // Found comment
      *p = '\0';              // Replace '#' with '\0' in case of comment immediately following integer or string
      while (*p != '\n' && p < bufend)  // Skip till EOL or EOF, whichever comes first
        p++;
      InString = 0;
      InItem = 0;
      break;
    case '\n':
      InItem = 0;
      InString = 0;
      *p++='\0';
      break;
    case ' ':
    case '\t':              // Skip whitespace, leave state unchanged
      if (InString)
        p++;
      else
      {                     // Terminate non-strings once whitespace is found
        *p++ = '\0';
        InItem = 0;
      }
      break;
      
    case '"':               // Begin/End of String
      *p++ = '\0';
      if (!InString)
      {
        items[item++] = p;
        InItem = ~InItem;
      }
      else
        InItem = 0;
      InString = ~InString; // Toggle
      break;
      
    default:
      if (!InItem)
      {
        items[item++] = p;
        InItem = ~InItem;
      }
      p++;
    }
  }
  
  item--;
  
  for (i=0; i<item; i+= 3)
  {
    if (0 > (MapIdx = ParameterNameToMapIndex (items[i])))
    {
      snprintf (errortext, ET_SIZE, " Parsing error in config file: Parameter Name '%s' not recognized.", items[i]);
      error (errortext, 300);
    }
    if (strcasecmp ("=", items[i+1]))
    {
      snprintf (errortext, ET_SIZE, " Parsing error in config file: '=' expected as the second token in each line.");
      error (errortext, 300);
    }
    
    // Now interpret the Value, context sensitive...
    
    switch (Map[MapIdx].Type)
    {
    case 0:           // Numerical
      if (1 != sscanf (items[i+2], "%d", &IntContent))
      {
        snprintf (errortext, ET_SIZE, " Parsing error: Expected numerical value for Parameter of %s, found '%s'.", items[i], items[i+2]);
        error (errortext, 300);
      }
      * (int *) (Map[MapIdx].Place) = IntContent;
      printf (".");
      break;
    case 1:
      strncpy ((char *) Map[MapIdx].Place, items [i+2], FILE_NAME_SIZE);
      printf (".");
      break;
    case 2:           // Numerical double
      if (1 != sscanf (items[i+2], "%lf", &DoubleContent))
      {
        snprintf (errortext, ET_SIZE, " Parsing error: Expected numerical value for Parameter of %s, found '%s'.", items[i], items[i+2]);
        error (errortext, 300);
      }
      * (double *) (Map[MapIdx].Place) = DoubleContent;
      printf (".");
      break;
    default:
      {
        snprintf (errortext, ET_SIZE, " Unknown value type in the map definition of configfile.h");
        error (errortext, 300);
      }
    }
  }
  memcpy (input, &configinput, sizeof (InputParameters));
}

/*!