Ignore:
Timestamp:
4 May 2015, 18:38:08 (10 years ago)
Author:
tech
Message:

Update to HM-16.5.
Starting point for further re-activation of 3D-tools.

Includes:

active:

  • MV-HEVC
  • 3D-HLS (apart from DLT)
  • VSO

inactive:

  • remaining 3D-HEVC tools.
Location:
branches/HTM-14.1-update-dev0/source/Lib/TAppCommon
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • branches/HTM-14.1-update-dev0/source/Lib/TAppCommon/TAppComCamPara.cpp

    r1196 r1200  
    4949#include <functional>
    5050#include <string>
    51 #if H_3D
     51#if NH_3D
    5252
    5353
    … …  
    13661366}
    13671367
    1368 #if H_3D_VSO
     1368#if NH_3D_VSO
    13691369Void
    13701370TAppComCamPara::setDispCoeff( UInt uiFrameId, Int iViewIdx )

  • branches/HTM-14.1-update-dev0/source/Lib/TAppCommon/TAppComCamPara.h

    r1196 r1200  
    188188#endif
    189189
    190 #if H_3D_VSO
     190#if NH_3D_VSO
    191191  // SAIT_VSO_EST_A033
    192192  Void                setDispCoeff              ( UInt uiStartFrameId, Int iViewIdx );

  • branches/HTM-14.1-update-dev0/source/Lib/TAppCommon/program_options_lite.cpp

    r1179 r1200  
    22 * License, included below. This software may be subject to other third party
    33 * and contributor rights, including patent rights, and no such rights are
    4  * granted under this license. 
     4 * granted under this license.
    55 *
    6 * Copyright (c) 2010-2015, ITU/ISO/IEC
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
    … …  
    4040#include <algorithm>
    4141#include "program_options_lite.h"
    42 #include  "../TLibCommon/TypeDef.h"
     42#include  "../TLibCommon/CommonDef.h"
    4343using namespace std;
    4444
    … …  
    5050  namespace program_options_lite
    5151  {
    52    
     52    ErrorReporter default_error_reporter;
     53
     54    ostream& ErrorReporter::error(const string& where)
     55    {
     56      is_errored = 1;
     57      cerr << where << " error: ";
     58      return cerr;
     59    }
     60
     61    ostream& ErrorReporter::warn(const string& where)
     62    {
     63      cerr << where << " warning: ";
     64      return cerr;
     65    }
     66
    5367    Options::~Options()
    5468    {
    … …  
    5872      }
    5973    }
    60    
     74
    6175    void Options::addOption(OptionBase *opt)
    6276    {
    … …  
    6478      names->opt = opt;
    6579      string& opt_string = opt->opt_string;
    66      
     80
    6781      size_t opt_start = 0;
    6882      for (size_t opt_end = 0; opt_end != string::npos;)
    … …  
    96110      return OptionSpecific(*this);
    97111    }
    98    
    99     static void setOptions(Options::NamesPtrList& opt_list, const string& value)
     112
     113    static void setOptions(Options::NamesPtrList& opt_list, const string& value, ErrorReporter& error_reporter)
    100114    {
    101115      /* multiple options may be registered for the same name:
    … …  
    103117      for (Options::NamesPtrList::iterator it = opt_list.begin(); it != opt_list.end(); ++it)
    104118      {
    105         (*it)->opt->parse(value);
     119        (*it)->opt->parse(value, error_reporter);
    106120      }
    107121    }
    108122
    109123    static const char spaces[41] = "                                        ";
    110    
     124
    111125    /* format help text for a single option:
    112126     * using the formatting: "-x, --long",
    … …  
    138152      }
    139153    }
    140    
     154
    141155    /* format the help text */
    142156    void doHelp(ostream& out, Options& opts, unsigned columns)
    … …  
    147161      for(Options::NamesPtrList::iterator it = opts.opt_list.begin(); it != opts.opt_list.end(); it++)
    148162      {
    149 #if H_MV
     163#if NH_MV
    150164        if  ( (*it)->opt->opt_duplicate ) continue;
    151165#endif
    … …  
    157171      unsigned opt_width = min(max_width+2, 28u + pad_short) + 2;
    158172      unsigned desc_width = columns - opt_width;
    159      
     173
    160174      /* second pass: write out formatted option and help text.
    161175       *  - align start of help text to start at opt_width
    … …  
    165179      for(Options::NamesPtrList::iterator it = opts.opt_list.begin(); it != opts.opt_list.end(); it++)
    166180      {
    167 #if H_MV
     181#if NH_MV
    168182        if  ( (*it)->opt->opt_duplicate ) continue;
    169183#endif
    … …  
    215229            split_pos = opt_desc.find_last_not_of(' ', split_pos) + 1;
    216230          }
    217          
     231
    218232          /* bad split if no suitable space to split at.  fall back to width */
    219233          bool bad_split = split_pos == string::npos || split_pos <= cur_pos;
    … …  
    223237          }
    224238          line << opt_desc.substr(cur_pos, split_pos - cur_pos);
    225          
     239
    226240          /* eat up any space for the start of the next line */
    227241          if (!bad_split)
    … …  
    230244          }
    231245          cur_pos = newline_pos = split_pos;
    232          
     246
    233247          if (cur_pos >= opt_desc.size())
    234248          {
    … …  
    241255      }
    242256    }
    243    
    244     bool storePair(Options& opts, bool allow_long, bool allow_short, const string& name, const string& value)
     257
     258    struct OptionWriter
     259    {
     260      OptionWriter(Options& rOpts, ErrorReporter& err)
     261      : opts(rOpts), error_reporter(err)
     262      {}
     263      virtual ~OptionWriter() {}
     264
     265      virtual const string where() = 0;
     266
     267      bool storePair(bool allow_long, bool allow_short, const string& name, const string& value);
     268      bool storePair(const string& name, const string& value)
     269      {
     270        return storePair(true, true, name, value);
     271      }
     272
     273      Options& opts;
     274      ErrorReporter& error_reporter;
     275    };
     276
     277    bool OptionWriter::storePair(bool allow_long, bool allow_short, const string& name, const string& value)
    245278    {
    246279      bool found = false;
    … …  
    254287        }
    255288      }
    256      
     289
    257290      /* check for the short list */
    258291      if (allow_short && !(found && allow_long))
    … …  
    267300      if (!found)
    268301      {
    269         /* not found */
    270         cerr << "Unknown option: `" << name << "' (value:`" << value << "')" << endl;
     302        error_reporter.error(where())
     303          << "Unknown option `" << name << "' (value:`" << value << "')\n";
    271304        return false;
    272305      }
    273306
    274       setOptions((*opt_it).second, value);
     307      setOptions((*opt_it).second, value, error_reporter);
    275308      return true;
    276309    }
    277    
    278     bool storePair(Options& opts, const string& name, const string& value)
    279     {
    280       return storePair(opts, true, true, name, value);
    281     }
    282    
     310
     311    struct ArgvParser : public OptionWriter
     312    {
     313      ArgvParser(Options& rOpts, ErrorReporter& rError_reporter)
     314      : OptionWriter(rOpts, rError_reporter)
     315      {}
     316
     317      const string where() { return "command line"; }
     318
     319      unsigned parseGNU(unsigned argc, const char* argv[]);
     320      unsigned parseSHORT(unsigned argc, const char* argv[]);
     321    };
     322
    283323    /**
    284324     * returns number of extra arguments consumed
    285325     */
    286     unsigned parseGNU(Options& opts, unsigned argc, const char* argv[])
     326    unsigned ArgvParser::parseGNU(unsigned argc, const char* argv[])
    287327    {
    288328      /* gnu style long options can take the forms:
    … …  
    294334      size_t arg_opt_sep = arg.find_first_of('=');
    295335      string option = arg.substr(arg_opt_start, arg_opt_sep - arg_opt_start);
    296      
     336
    297337      unsigned extra_argc_consumed = 0;
    298338      if (arg_opt_sep == string::npos)
    … …  
    305345        * booleans */
    306346        if (argc == 1)
     347        {
    307348          return 0; /* run out of argv for argument */
     349        }
    308350        extra_argc_consumed = 1;
    309351#endif
    310         if(!storePair(opts, true, false, option, "1"))
     352        if(!storePair(true, false, option, "1"))
    311353        {
    312354          return 0;
    … …  
    317359        /* argument occurs after option_sep */
    318360        string val = arg.substr(arg_opt_sep + 1);
    319         storePair(opts, true, false, option, val);
     361        storePair(true, false, option, val);
    320362      }
    321363
    … …  
    323365    }
    324366
    325     unsigned parseSHORT(Options& opts, unsigned argc, const char* argv[])
     367    unsigned ArgvParser::parseSHORT(unsigned argc, const char* argv[])
    326368    {
    327369      /* short options can take the forms:
    … …  
    338380      if (argc == 1)
    339381      {
    340         cerr << "Not processing option without argument `" << option << "'" << endl;
     382        error_reporter.error(where())
     383          << "Not processing option `" << option << "' without argument\n";
    341384        return 0; /* run out of argv for argument */
    342385      }
    343       storePair(opts, false, true, option, string(argv[1]));
     386      storePair(false, true, option, string(argv[1]));
    344387
    345388      return 1;
    346389    }
    347    
     390
    348391    list<const char*>
    349     scanArgv(Options& opts, unsigned argc, const char* argv[])
    350     {
     392    scanArgv(Options& opts, unsigned argc, const char* argv[], ErrorReporter& error_reporter)
     393    {
     394      ArgvParser avp(opts, error_reporter);
     395
    351396      /* a list for anything that didn't get handled as an option */
    352397      list<const char*> non_option_arguments;
    … …  
    370415        {
    371416          /* handle short (single dash) options */
    372 #if 0
    373           i += parsePOSIX(opts, argc - i, &argv[i]);
    374 #else
    375           i += parseSHORT(opts, argc - i, &argv[i]);
    376 #endif
     417          i += avp.parseSHORT(argc - i, &argv[i]);
    377418          continue;
    378419        }
    … …  
    382423          /* a lone double dash ends option processing */
    383424          while (++i < argc)
     425          {
    384426            non_option_arguments.push_back(argv[i]);
     427          }
    385428          break;
    386429        }
    387430
    388431        /* handle long (double dash) options */
    389         i += parseGNU(opts, argc - i, &argv[i]);
     432        i += avp.parseGNU(argc - i, &argv[i]);
    390433      }
    391434
    392435      return non_option_arguments;
    393436    }
    394    
    395     void scanLine(Options& opts, string& line)
     437
     438    struct CfgStreamParser : public OptionWriter
     439    {
     440      CfgStreamParser(const string& rName, Options& rOpts, ErrorReporter& rError_reporter)
     441      : OptionWriter(rOpts, rError_reporter)
     442      , name(rName)
     443      , linenum(0)
     444      {}
     445
     446      const string name;
     447      int linenum;
     448      const string where()
     449      {
     450        ostringstream os;
     451        os << name << ":" << linenum;
     452        return os.str();
     453      }
     454
     455      void scanLine(string& line);
     456      void scanStream(istream& in);
     457    };
     458
     459    void CfgStreamParser::scanLine(string& line)
    396460    {
    397461      /* strip any leading whitespace */
    … …  
    416480      {
    417481        /* error: badly formatted line */
     482        error_reporter.warn(where()) << "line formatting error\n";
    418483        return;
    419484      }
    … …  
    421486      {
    422487        /* error: badly formatted line */
     488        error_reporter.warn(where()) << "line formatting error\n";
    423489        return;
    424490      }
    … …  
    429495      {
    430496        /* error: badly formatted line */
     497#if !NH_MV
     498        error_reporter.warn(where()) << "line formatting error\n";
     499#else
     500        // HTM also allows empty parameters.
     501#endif
    431502        return;
    432503      }
    … …  
    447518         * any trailing whitespace will be removed shortly */
    448519        value_end = line.find_first_not_of(" \t\n\r", value_end);
    449       }
    450       while (value_end != string::npos);
     520      } while (value_end != string::npos);
    451521      /* strip any trailing space from value*/
    452522      value_end = line.find_last_not_of(" \t\n\r", value_end);
    … …  
    460530      {
    461531        /* error: no value */
     532#if !NH_MV
     533        error_reporter.warn(where()) << "no value found\n";
     534#else
     535        // This is ok for HTM.
     536#endif
    462537        return;
    463538      }
    464539
    465540      /* store the value in option */
    466       storePair(opts, true, false, option, value);
    467     }
    468 
    469     void scanFile(Options& opts, istream& in)
     541      storePair(true, false, option, value);
     542    }
     543
     544    void CfgStreamParser::scanStream(istream& in)
    470545    {
    471546      do
    472547      {
     548        linenum++;
    473549        string line;
    474550        getline(in, line);
    475         scanLine(opts, line);
    476       }
    477       while(!!in);
     551        scanLine(line);
     552      } while(!!in);
    478553    }
    479554
    … …  
    488563    }
    489564
    490     void parseConfigFile(Options& opts, const string& filename)
     565    void parseConfigFile(Options& opts, const string& filename, ErrorReporter& error_reporter)
    491566    {
    492567      ifstream cfgstream(filename.c_str(), ifstream::in);
    493568      if (!cfgstream)
    494569      {
    495         cerr << "Failed to open config file: `" << filename << "'" << endl;
    496         exit(EXIT_FAILURE);
    497       }
    498       scanFile(opts, cfgstream);
    499     }
    500 
    501   };
    502 };
     570        error_reporter.error(filename) << "Failed to open config file\n";
     571        return;
     572      }
     573      CfgStreamParser csp(filename, opts, error_reporter);
     574      csp.scanStream(cfgstream);
     575    }
     576
     577  }
     578}
    503579
    504580//! \}

  • branches/HTM-14.1-update-dev0/source/Lib/TAppCommon/program_options_lite.h

    r1179 r1200  
    22 * License, included below. This software may be subject to other third party
    33 * and contributor rights, including patent rights, and no such rights are
    4  * granted under this license. 
     4 * granted under this license.
    55 *
    6 * Copyright (c) 2010-2015, ITU/ISO/IEC
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
    … …  
    3636#include <list>
    3737#include <map>
    38 #include  "../TLibCommon/TypeDef.h"
    39 
    40 #if H_MV
     38#include  "../TLibCommon/CommonDef.h"
     39
     40#if NH_MV
    4141#include <vector>
    4242#include <errno.h>
    … …  
    4747#endif
    4848#endif
     49
     50
     51#ifndef __PROGRAM_OPTIONS_LITE__
     52#define __PROGRAM_OPTIONS_LITE__
     53
    4954//! \ingroup TAppCommon
    5055//! \{
    … …  
    5661  {
    5762    struct Options;
    58    
     63
    5964    struct ParseFailure : public std::exception
    6065    {
    … …  
    7176    };
    7277
     78    struct ErrorReporter
     79    {
     80      ErrorReporter() : is_errored(0) {}
     81      virtual ~ErrorReporter() {}
     82      virtual std::ostream& error(const std::string& where);
     83      virtual std::ostream& warn(const std::string& where);
     84      bool is_errored;
     85    };
     86
     87    extern ErrorReporter default_error_reporter;
     88
    7389    void doHelp(std::ostream& out, Options& opts, unsigned columns = 80);
    74     unsigned parseGNU(Options& opts, unsigned argc, const char* argv[]);
    75     unsigned parseSHORT(Options& opts, unsigned argc, const char* argv[]);
    76     std::list<const char*> scanArgv(Options& opts, unsigned argc, const char* argv[]);
    77     void scanLine(Options& opts, std::string& line);
    78     void scanFile(Options& opts, std::istream& in);
     90    std::list<const char*> scanArgv(Options& opts, unsigned argc, const char* argv[], ErrorReporter& error_reporter = default_error_reporter);
    7991    void setDefaults(Options& opts);
    80     void parseConfigFile(Options& opts, const std::string& filename);
    81     bool storePair(Options& opts, const std::string& name, const std::string& value);
    82    
     92    void parseConfigFile(Options& opts, const std::string& filename, ErrorReporter& error_reporter = default_error_reporter);
     93
    8394    /** OptionBase: Virtual base class for storing information relating to a
    8495     * specific option This base class describes common elements.  Type specific
    … …  
    8697    struct OptionBase
    8798    {
    88 #if H_MV     
     99#if NH_MV     
    89100      OptionBase(const std::string& name, const std::string& desc, bool duplicate = false)
    90101        : opt_string(name), opt_desc(desc), opt_duplicate(duplicate)
    … …  
    94105#endif
    95106      {};
    96      
     107
    97108      virtual ~OptionBase() {}
    98      
     109
    99110      /* parse argument arg, to obtain a value for the option */
    100       virtual void parse(const std::string& arg) = 0;
     111      virtual void parse(const std::string& arg, ErrorReporter&) = 0;
    101112      /* set the argument to the default value */
    102113      virtual void setDefault() = 0;
    103      
     114
    104115      std::string opt_string;
    105116      std::string opt_desc;
    106 #if H_MV
     117#if NH_MV
    107118      bool        opt_duplicate;
    108119#endif
    109120    };
    110    
     121
    111122    /** Type specific option storage */
    112123    template<typename T>
    113124    struct Option : public OptionBase
    114125    {
    115 #if H_MV
     126#if NH_MV
    116127      Option(const std::string& name, T& storage, T default_val, const std::string& desc, bool duplicate = false)
    117128        : OptionBase(name, desc, duplicate), opt_storage(storage), opt_default_val(default_val)
    … …  
    121132#endif
    122133      {}
    123      
    124       void parse(const std::string& arg);
    125      
     134
     135      void parse(const std::string& arg, ErrorReporter&);
     136
    126137      void setDefault()
    127138      {
    128139        opt_storage = opt_default_val;
    129140      }
    130      
     141
    131142      T& opt_storage;
    132143      T opt_default_val;
    133144    };
    134    
     145
    135146    /* Generic parsing */
    136147    template<typename T>
    137148    inline void
    138     Option<T>::parse(const std::string& arg)
     149    Option<T>::parse(const std::string& arg, ErrorReporter&)
    139150    {
    140151      std::istringstream arg_ss (arg,std::istringstream::in);
    … …  
    149160      }
    150161    }
    151    
     162
    152163    /* string parsing is specialized -- copy the whole string, not just the
    153164     * first word */
    154165    template<>
    155166    inline void
    156     Option<std::string>::parse(const std::string& arg)
     167    Option<std::string>::parse(const std::string& arg, ErrorReporter&)
    157168    {
    158169      opt_storage = arg;
    159170    }
    160171
    161 #if H_MV   
     172#if NH_MV   
    162173    template<>
    163174    inline void
    164       Option<char*>::parse(const std::string& arg)
     175      Option<char*>::parse(const std::string& arg, ErrorReporter&)
    165176    {
    166177      opt_storage = arg.empty() ? NULL : strdup(arg.c_str()) ;
    … …  
    169180    template<>
    170181    inline void
    171       Option< std::vector<char*> >::parse(const std::string& arg)
     182      Option< std::vector<char*> >::parse(const std::string& arg, ErrorReporter&)
    172183    {
    173184      opt_storage.clear();
    … …  
    191202    template<>   
    192203    inline void
    193       Option< std::vector<double> >::parse(const std::string& arg)
     204      Option< std::vector<double> >::parse(const std::string& arg, ErrorReporter&)
    194205    {
    195206      char* pcNextStart = (char*) arg.data();
    … …  
    227238    template<>
    228239    inline void
    229       Option< std::vector<int> >::parse(const std::string& arg)
     240      Option< std::vector<int> >::parse(const std::string& arg, ErrorReporter&)
    230241    {
    231242      opt_storage.clear();
    … …  
    265276    template<>
    266277    inline void
    267       Option< std::vector<bool> >::parse(const std::string& arg)
     278      Option< std::vector<bool> >::parse(const std::string& arg, ErrorReporter&)
    268279    {
    269280      char* pcNextStart = (char*) arg.data();
    … …  
    299310    struct OptionFunc : public OptionBase
    300311    {
    301       typedef void (Func)(Options&, const std::string&);
    302      
     312      typedef void (Func)(Options&, const std::string&, ErrorReporter&);
     313
    303314      OptionFunc(const std::string& name, Options& parent_, Func *func_, const std::string& desc)
    304315      : OptionBase(name, desc), parent(parent_), func(func_)
    305316      {}
    306      
    307       void parse(const std::string& arg)
    308       {
    309         func(parent, arg);
    310       }
    311      
     317
     318      void parse(const std::string& arg, ErrorReporter& error_reporter)
     319      {
     320        func(parent, arg, error_reporter);
     321      }
     322
    312323      void setDefault()
    313324      {
    314325        return;
    315326      }
    316      
     327
    317328    private:
    318329      Options& parent;
    319       void (*func)(Options&, const std::string&);
    320     };
    321    
     330      Func* func;
     331    };
     332
    322333    class OptionSpecific;
    323334    struct Options
    324335    {
    325336      ~Options();
    326      
     337
    327338      OptionSpecific addOptions();
    328      
     339
    329340      struct Names
    330341      {
    … …  
    333344        {
    334345          if (opt)
     346          {
    335347            delete opt;
     348          }
    336349        }
    337350        std::list<std::string> opt_long;
    … …  
    341354
    342355      void addOption(OptionBase *opt);
    343      
     356
    344357      typedef std::list<Names*> NamesPtrList;
    345358      NamesPtrList opt_list;
    346      
     359
    347360      typedef std::map<std::string, NamesPtrList> NamesMap;
    348361      NamesMap opt_long_map;
    349362      NamesMap opt_short_map;
    350363    };
    351    
     364
    352365    /* Class with templated overloaded operator(), for use by Options::addOptions() */
    353366    class OptionSpecific
    … …  
    355368    public:
    356369      OptionSpecific(Options& parent_) : parent(parent_) {}
    357      
     370
    358371      /**
    359372       * Add option described by name to the parent Options list,
    … …  
    369382        return *this;
    370383      }
    371      
    372 #if H_MV
     384
     385#if NH_MV
    373386      template<typename T>
    374387      OptionSpecific&
    … …  
    419432      Options& parent;
    420433    };
    421    
    422   }; /* namespace: program_options_lite */
    423 }; /* namespace: df */
     434
     435  } /* namespace: program_options_lite */
     436} /* namespace: df */
    424437
    425438//! \}
     439
     440#endif
Note: See TracChangeset for help on using the changeset viewer.