Ignore:
Timestamp:
4 May 2015, 18:38:08 (9 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/App/utils
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • branches/HTM-14.1-update-dev0/source/App/utils/BitrateTargeting/ExtractBitrates.cpp

    r872 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. 
    5  *
    6  * Copyright (c) 2010-2014, ITU/ISO/IEC
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4545  {
    4646    public:
    47      
     47
    4848      /// Contructs a new zeroed tally
    4949      Tally( ): m_sum( 0.0 ), m_numSlices( 0 ) { }
    50      
     50
    5151      /// Adds to the sum and increments the sample-count
    5252      void add( double in ) { ++m_numSlices; m_sum += in; }
    53      
     53
    5454      /// \return The calculated average
    5555      double average( ) const { return m_sum / ( double )m_numSlices; }
    56    
     56
    5757    private:
    5858      double m_sum;
    5959      unsigned long m_numSlices;
    6060  };
    61  
     61
    6262  /// Ignores all of the the characters up to and including a given character
    6363  /// \param line The line being read from
     
    6969    while( iLine.good( ) && character != iLine.get( ) )
    7070      ;
    71     if( !iLine.good( ) ) throw POCParseException( line );
     71    if( !iLine.good( ) )
     72    {
     73      throw POCParseException( line );
     74    }
    7275  }
    73  
     76
    7477  /// Extracts the average bitrates for each of the temporal layers from the given log
    7578  /// \param i The input stream that represents the log
     
    7982  {
    8083    std::map< unsigned char, Tally > tallyMap;
    81    
     84
    8285    while( i.good( ) )
    8386    {
     
    8689      std::getline( i, line );
    8790      std::istringstream iLine( line );
    88       if( !iLine.good( ) ) continue;
    89      
     91      if( !iLine.good( ) )
     92      {
     93        continue;
     94      }
     95
    9096      // Ignore the "POC"
    91       if( iLine.get( ) != 'P' ) continue;
    92       if( !iLine.good( ) ) continue;
    93       if( iLine.get( ) != 'O' ) continue;
    94       if( !iLine.good( ) ) continue;
    95       if( iLine.get( ) != 'C' ) continue;
    96       if( !iLine.good( ) ) throw POCParseException( line );
    97      
     97      if( iLine.get( ) != 'P' )
     98      {
     99        continue;
     100      }
     101      if( !iLine.good( ) )
     102      {
     103        continue;
     104      }
     105      if( iLine.get( ) != 'O' )
     106      {
     107        continue;
     108      }
     109      if( !iLine.good( ) )
     110      {
     111        continue;
     112      }
     113      if( iLine.get( ) != 'C' )
     114      {
     115        continue;
     116      }
     117      if( !iLine.good( ) )
     118      {
     119        throw POCParseException( line );
     120      }
     121
    98122      ignoreUpTo( line, iLine, '(' );
    99      
    100       if( iLine.get( ) != ' ' ) throw POCParseException( line );
    101       if( !iLine.good( ) ) throw POCParseException( line );
    102      
    103       if( 'I' == iLine.get( ) ) continue;
    104       if( !iLine.good( ) ) throw POCParseException( line );
    105      
     123
     124      if( iLine.get( ) != ' ' )
     125      {
     126        throw POCParseException( line );
     127      }
     128      if( !iLine.good( ) )
     129      {
     130        throw POCParseException( line );
     131      }
     132
     133      if( 'I' == iLine.get( ) )
     134      {
     135        continue;
     136      }
     137      if( !iLine.good( ) )
     138      {
     139        throw POCParseException( line );
     140      }
     141
    106142      ignoreUpTo( line, iLine, ' ' );
    107143      ignoreUpTo( line, iLine, ' ' );
    108      
     144
    109145      // Parse the qpIndex
    110146      long qpIndexLong;
    111147      iLine >> qpIndexLong;
    112       if( ( long )std::numeric_limits< unsigned char >::max( ) < qpIndexLong ) throw POCParseException( line );
     148      if( ( long )std::numeric_limits< unsigned char >::max( ) < qpIndexLong )
     149      {
     150        throw POCParseException( line );
     151      }
    113152      unsigned char qpIndex( ( unsigned char )qpIndexLong );
    114       if( !iLine.good( ) ) throw POCParseException( line );
    115      
     153      if( !iLine.good( ) )
     154      {
     155        throw POCParseException( line );
     156      }
     157
    116158      ignoreUpTo( line, iLine, ')' );
    117159      ignoreUpTo( line, iLine, ' ' );
    118      
     160
    119161      // Parse the number of bits
    120162      unsigned long bitsULong;
    121163      iLine >> bitsULong;
    122       if( !iLine.good( ) ) throw POCParseException( line );
    123      
     164      if( !iLine.good( ) )
     165      {
     166        throw POCParseException( line );
     167      }
     168
    124169      // Find the tally that corresponds to our QP.  If there is no such tally yet, then add a new one to the map.
    125170      std::map< unsigned char, Tally >::iterator iter( tallyMap.find( qpIndex ) );
     
    130175      }
    131176      assert( iter != tallyMap.end( ) );
    132      
     177
    133178      iter->second.add( ( double )bitsULong );
    134179    }
    135    
     180
    136181    // Populate and return the result based on all of the tallies
    137182    std::map< unsigned char, double > result;
     
    147192{
    148193  std::vector< double > result;
    149  
     194
    150195  std::map< unsigned char, double > bitratesForQPsMap( extractBitratesForQPs( i ) );
    151196  if( !bitratesForQPsMap.empty( ) )
    152197  {
    153198    unsigned char expectedNextQPIndex( bitratesForQPsMap.begin( )->first );
    154    
     199
    155200    for( std::map< unsigned char, double >::const_iterator i( bitratesForQPsMap.begin( ) ); i != bitratesForQPsMap.end( ); ++i )
    156201    {
    157       if( i->first != expectedNextQPIndex ) throw NonContiguousQPSetException( );
     202      if( i->first != expectedNextQPIndex )
     203      {
     204        throw NonContiguousQPSetException( );
     205      }
    158206      ++expectedNextQPIndex;
    159207      result.push_back( i->second );
    160208    }
    161209  }
    162  
     210
    163211  return result;
    164212}
  • branches/HTM-14.1-update-dev0/source/App/utils/BitrateTargeting/ExtractBitrates.h

    r872 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-2014, ITU/ISO/IEC
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    3232 */
    3333
    34 #ifndef EXTRACT_BITRATES_H
    35 #define EXTRACT_BITRATES_H
     34#ifndef __EXTRACTBITRATES__
     35#define __EXTRACTBITRATES__
    3636
    3737#include "RuntimeError.h"
     
    4444    POCParseException( const std::string& pocLine ): m_pocLine( pocLine ) { }
    4545    virtual ~POCParseException( ) throw ( ) { }
    46  
     46
    4747  protected:
    4848    void outputWhat( std::ostream& o ) const { o << "POC parse exception: " << m_pocLine; }
    49  
     49
    5050  private:
    5151    std::string m_pocLine;
     
    5757  public:
    5858    virtual ~NonContiguousQPSetException( ) throw( ) { }
    59  
     59
    6060  protected:
    6161    void outputWhat( std::ostream& o ) const { o << "Non-contiguous QP set exception"; }
  • branches/HTM-14.1-update-dev0/source/App/utils/BitrateTargeting/ExtractBitratesMain.cpp

    r872 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-2014, ITU/ISO/IEC
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4444  assert( 2 == toFind.size( ) );
    4545  assert( 'e' == toFind[ 0 ] );
    46  
     46
    4747  std::string::size_type pos( out.find( toFind ) );
    4848  assert( pos != std::string::npos );
     
    5757  oss << std::scientific << right;
    5858  std::string s( oss.str( ) );
    59  
     59
    6060  replaceWithE( s, "e+" );
    6161  replaceWithE( s, "e0" );
    62  
     62
    6363  left << s;
    6464}
     
    6969  {
    7070    std::vector< double > result( extractBitratesForTemporalLayers( std::cin ) );  // Extract the bitrate vector
    71    
     71
    7272    // Output the bitrate vector
    7373    if( 0 < result.size( ) )
     
    8989      }
    9090    }
    91    
     91
    9292    return 0;
    9393  }
  • branches/HTM-14.1-update-dev0/source/App/utils/BitrateTargeting/GuessLambdaModifiers.cpp

    r872 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-2014, ITU/ISO/IEC
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4646  {
    4747    assert( right.empty( ) );
    48    
     48
    4949    for( ; ; )
    5050    {
    5151      assert( left.good( ) );
    52      
     52
    5353      double bitrate;
    5454      left >> bitrate;
    55       if( left.fail( ) ) break;
     55      if( left.fail( ) )
     56      {
     57        break;
     58      }
    5659      if( bitrate <= ( double )0.0 )
    5760      {
     
    6265        right.push_back( bitrate );
    6366      }
    64       if( !left.good( ) ) break;
    65      
     67      if( !left.good( ) )
     68      {
     69        break;
     70      }
     71
    6672      if( left.peek( ) == ' ' )
    6773      {
     
    7480    }
    7581  }
    76  
     82
    7783  /// Makes a next guess for a single Lambda-modifier based on only one previous guess
    7884  /// \param initialAdjustmentParameter The proportionality to use between the target bitrate and the previous guess
     
    8894    assert( ( double )0.0 < previousPoint.lambdaModifier );
    8995    assert( ( double )0.0 < previousPoint.bitrate );
    90    
     96
    9197    double extrapolated( previousPoint.lambdaModifier * targetBitrate / previousPoint.bitrate );
    9298    return previousPoint.lambdaModifier + initialAdjustmentParameter * ( extrapolated - previousPoint.lambdaModifier );
     
    102108  assert( point1.lambdaModifier != point2.lambdaModifier );
    103109  assert( point1.bitrate != point2.bitrate );
    104  
     110
    105111  // Calculate and return the result
    106112  double denominator( point1.bitrate - point2.bitrate );
     
    119125  assert( interDampeningFactor <= ( double )1.0 );
    120126  assert( !pointList.empty( ) );
    121  
     127
    122128  double preliminaryResult;
    123  
     129
    124130  if( 1 == pointList.size( ) )  // If there is only one prevous point, then we cannot interpolate, so we call incrementLambdaModifier
    125131  {
     
    132138    ++i;
    133139    Point point2 = *i;
    134    
     140
    135141    // If the slope is either horizontal or vertical, we cannot interpolate
    136142    if( point1.lambdaModifier == point2.lambdaModifier || point1.bitrate == point2.bitrate )
     
    143149    }
    144150  }
    145  
     151
    146152  double previousResult( pointList.back( ).lambdaModifier );
    147  
     153
    148154  // Apply "intra dampening"
    149155  {
     
    159165    }
    160166  }
    161  
     167
    162168  // Apply "inter dampening factor".  If necessary, reduce the factor until a positive result is acheived.
    163169  double result;
     
    180186    return result;
    181187  }
    182  
     188
    183189  /// Calculates the inter dampening factor based
    184190  /// \param parameter The inter dampening parameter which determines how severely the inter dampening factor is affected by Lambda-modifier changes at previous temporal layers
     
    202208  assert( !targetBitrateVector.empty( ) );
    203209  assert( !metaLogEntryList.empty( ) );
    204  
     210
    205211  double cumulativeDelta( 0.0 );
    206212  std::vector< double > resultVector;
     
    212218    pointList.push_front( pointFromFullMetaLogEntry( i, *j ) );
    213219    ++j;
    214     if( j != metaLogEntryList.rend( ) ) pointList.push_front( pointFromFullMetaLogEntry( i, *j ) );
    215    
     220    if( j != metaLogEntryList.rend( ) )
     221    {
     222      pointList.push_front( pointFromFullMetaLogEntry( i, *j ) );
     223    }
     224
    216225    // Calculate the new Lambda-modifier guess and add it to the result vector
    217226    const double newLambdaModifier( guessLambdaModifier(
     
    221230        interDampeningFactor( 50.0, cumulativeDelta ) ) );
    222231    resultVector.push_back( newLambdaModifier );
    223    
     232
    224233    // Increment the cumulativeDelta
    225234    const double oldLambdaModifier( pointList.back( ).lambdaModifier );
    226235    cumulativeDelta += std::abs( newLambdaModifier - oldLambdaModifier ) / oldLambdaModifier;
    227236  }
    228  
     237
    229238  return resultVector;
    230239}
     
    240249    while( i.good( ) && character != i.get( ) )
    241250      ;
    242     if( !i.good( ) ) throw MetaLogParseException( );
    243   }
    244  
     251    if( !i.good( ) )
     252    {
     253      throw MetaLogParseException( );
     254    }
     255  }
     256
    245257  /// Parses a Lambda-modifier map
    246258  /// \param right The map to write the output to
     
    250262    {
    251263      assert( left.good( ) );
    252      
     264
    253265      // Ignore the "-LM"
    254       if( '-' != left.get( ) ) left.setstate( std::istream::failbit );
    255       if( !left.good( ) ) break;
    256       if( 'L' != left.get( ) ) left.setstate( std::istream::failbit );
    257       if( !left.good( ) ) break;
    258       if( 'M' != left.get( ) ) left.setstate( std::istream::failbit );
    259       if( !left.good( ) ) break;
    260      
     266      if( '-' != left.get( ) )
     267      {
     268        left.setstate( std::istream::failbit );
     269      }
     270      if( !left.good( ) )
     271      {
     272        break;
     273      }
     274      if( 'L' != left.get( ) )
     275      {
     276        left.setstate( std::istream::failbit );
     277      }
     278      if( !left.good( ) )
     279      {
     280        break;
     281      }
     282      if( 'M' != left.get( ) )
     283      {
     284        left.setstate( std::istream::failbit );
     285      }
     286      if( !left.good( ) )
     287      {
     288        break;
     289      }
     290
    261291      // Parse the index
    262292      long indexLong;
    263293      left >> indexLong;
    264       if( !left.good( ) ) break;
    265       if( indexLong < std::numeric_limits< unsigned char >::min( ) ) left.setstate( std::istream::failbit );
    266       if( std::numeric_limits< unsigned char >::max( ) < indexLong ) left.setstate( std::istream::failbit );
    267       if( !left.good( ) ) break;
     294      if( !left.good( ) )
     295      {
     296        break;
     297      }
     298      if( indexLong < std::numeric_limits< unsigned char >::min( ) )
     299      {
     300        left.setstate( std::istream::failbit );
     301      }
     302      if( std::numeric_limits< unsigned char >::max( ) < indexLong )
     303      {
     304        left.setstate( std::istream::failbit );
     305      }
     306      if( !left.good( ) )
     307      {
     308        break;
     309      }
    268310      unsigned char index( ( unsigned char )indexLong );
    269      
    270       if( ' ' != left.get( ) ) left.setstate( std::istream::failbit );
    271       if( !left.good( ) ) break;
    272      
     311
     312      if( ' ' != left.get( ) )
     313      {
     314        left.setstate( std::istream::failbit );
     315      }
     316      if( !left.good( ) )
     317      {
     318        break;
     319      }
     320
    273321      // Parse the Lambda-modifier
    274322      double lambdaModifier;
     
    282330        right[ index ] = lambdaModifier;
    283331      }
    284       if( !left.good( ) ) break;
    285      
     332      if( !left.good( ) )
     333      {
     334        break;
     335      }
     336
    286337      // If we peek and see a space, then there should be more Lambda-modifiers to parse.  Otherwise, we are finished.
    287338      if( left.peek( ) == ' ' )
     
    295346    }
    296347  }
    297  
     348
    298349  /// Extracts the indexes from the given maps
    299350  /// \return The set of indexes
     
    322373    throw InitialAdjustmentParameterParseException( );
    323374  }
    324  
     375
    325376  // Parse the targets
    326377  std::vector< double > targetVector;
    327378  parseBitrateVector( targetsIstream, targetVector );
    328   if( targetVector.empty( ) || targetsIstream.fail( ) || targetsIstream.good( ) ) throw TargetsParseException( );
    329  
     379  if( targetVector.empty( ) || targetsIstream.fail( ) || targetsIstream.good( ) )
     380  {
     381    throw TargetsParseException( );
     382  }
     383
    330384  // Parse the metalog
    331385  std::list< MetaLogEntry< std::map< unsigned char, double > > > metaLogEntryList;
     
    335389    MetaLogEntry< std::map< unsigned char, double > > entry;
    336390    parseLambdaModifierMap( metaLogIstream, entry.lambdaModifiers );
    337     if( !metaLogIstream.good( ) ) throw MetaLogParseException( );
    338    
     391    if( !metaLogIstream.good( ) )
     392    {
     393      throw MetaLogParseException( );
     394    }
     395
    339396    // Skip the ';'
    340     if( ';' != metaLogIstream.get( ) ) throw MetaLogParseException( );
    341     if( !metaLogIstream.good( ) ) throw MetaLogParseException( );
    342    
     397    if( ';' != metaLogIstream.get( ) )
     398    {
     399      throw MetaLogParseException( );
     400    }
     401    if( !metaLogIstream.good( ) )
     402    {
     403      throw MetaLogParseException( );
     404    }
     405
    343406    // Parse the bitrates
    344407    parseBitrateVector( metaLogIstream, entry.bitrateVector );
    345     if( metaLogIstream.fail( ) ) throw MetaLogParseException( );
     408    if( metaLogIstream.fail( ) )
     409    {
     410      throw MetaLogParseException( );
     411    }
    346412    metaLogEntryList.push_back( entry );
    347    
    348     if( !metaLogIstream.good( ) ) break;
    349     if( metaLogIstream.get( ) != '\n' ) throw MetaLogParseException( );
     413
     414    if( !metaLogIstream.good( ) )
     415    {
     416      break;
     417    }
     418    if( metaLogIstream.get( ) != '\n' )
     419    {
     420      throw MetaLogParseException( );
     421    }
    350422    metaLogIstream.peek( );
    351423  } while( metaLogIstream.good( ) );
    352   if( metaLogEntryList.empty( ) ) throw MetaLogParseException( );  // The meta-log should not be empty
    353  
     424  if( metaLogEntryList.empty( ) )
     425  {
     426    throw MetaLogParseException( );  // The meta-log should not be empty
     427  }
     428
    354429  // Initialize firstIndexVector and check that the sizes and indexes match
    355430  std::set< unsigned char > firstIndexSet( indexSetFromMap( metaLogEntryList.front( ).lambdaModifiers ) );
    356   if( firstIndexSet.size( ) != targetVector.size( ) ) throw MismatchedIndexesException( );
     431  if( firstIndexSet.size( ) != targetVector.size( ) )
     432  {
     433    throw MismatchedIndexesException( );
     434  }
    357435  for( std::list< MetaLogEntry< std::map< unsigned char, double > > >::const_iterator i( metaLogEntryList.begin( ) );
    358436      i != metaLogEntryList.end( );
    359437      ++i )
    360438  {
    361     if( indexSetFromMap( i->lambdaModifiers ) != firstIndexSet ) throw MismatchedIndexesException( );
    362     if( i->bitrateVector.size( ) != targetVector.size( ) ) throw MismatchedIndexesException( );
    363   }
    364  
     439    if( indexSetFromMap( i->lambdaModifiers ) != firstIndexSet )
     440    {
     441      throw MismatchedIndexesException( );
     442    }
     443    if( i->bitrateVector.size( ) != targetVector.size( ) )
     444    {
     445      throw MismatchedIndexesException( );
     446    }
     447  }
     448
    365449  // Initialize simplifiedMetaLogEntryList
    366450  std::list< MetaLogEntry< std::vector< double > > > simplifiedMetaLogEntryList;
     
    376460    simplifiedMetaLogEntryList.back( ).bitrateVector = i->bitrateVector;
    377461  }
    378  
     462
    379463  // Run the calculations
    380464  std::vector< double > resultVector( guessLambdaModifiers( initialAdjustmentParameter, targetVector, simplifiedMetaLogEntryList ) );
    381  
     465
    382466  // Output the results
    383467  std::set< unsigned char >::const_iterator indexIter( firstIndexSet.begin( ) );
     
    385469  do
    386470  {
    387     if( indexIter != firstIndexSet.begin( ) ) o << " ";
     471    if( indexIter != firstIndexSet.begin( ) )
     472    {
     473      o << " ";
     474    }
    388475    o << "-LM" << ( long )( *indexIter ) << " ";
    389476    o.setf( std::ostream::fixed, std::ostream::floatfield );
    390477    o.precision( 7 );
    391478    o << ( *resultIter );
    392    
     479
    393480    ++indexIter;
    394481    ++resultIter;
  • branches/HTM-14.1-update-dev0/source/App/utils/BitrateTargeting/GuessLambdaModifiers.h

    r872 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-2014, ITU/ISO/IEC
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    3232 */
    3333
    34 #ifndef CALCULATE_LAMBDA_MODIFIER_H
    35 #define CALCULATE_LAMBDA_MODIFIER_H
     34#ifndef __GUESSLAMBDAMODIFIERS__
     35#define __GUESSLAMBDAMODIFIERS__
    3636
    3737#include "RuntimeError.h"
     
    9494
    9595/// Performs interpolation/extrapolation to guess a single Lambda-modifier
    96 /// \param target The target bitrate value that this Lambda-modifier is trying to reach
     96/// \param targetBitrate The target bitrate value that this Lambda-modifier is trying to reach
    9797/// \param point1 One of the two previously tried points where first is the Lambda-modifier and second is the obtained bitrate
    9898/// \param point2 One of the two previously tried points where first is the Lambda-modifier and second is the obtained bitrate
     
    134134/// \param o The output stream to write the guessed Lambda-modifiers to
    135135/// \param initialAdjustmentParameterIstream The input stream that contains the initial adjustment parameter
    136 /// \param targetIstream The input stream that contains the target bitrates
     136/// \param targetsIstream The input stream that contains the target bitrates
    137137/// \param metaLogIstream The input stream that contains the meta-log
    138138/// \throw InitialAdjustmentParameterParseException if there is an error parsing the initial adjustment parameter
  • branches/HTM-14.1-update-dev0/source/App/utils/BitrateTargeting/GuessLambdaModifiersMain.cpp

    r872 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-2014, ITU/ISO/IEC
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4949  try
    5050  {
    51     if( argc != 3 ) throw WrongNumberOfArgumentsException( );
    52    
     51    if( argc != 3 )
     52    {
     53      throw WrongNumberOfArgumentsException( );
     54    }
     55
    5356    std::string initialAdjustmentParameterString( ppArgv[ 1 ] );
    5457    std::istringstream initialAdjustmentParameterIstream( initialAdjustmentParameterString );
    55    
     58
    5659    std::string targetBitratesString( ppArgv[ 2 ] );
    5760    std::istringstream targetBitratesIstream( targetBitratesString );
    58    
     61
    5962    guessLambdaModifiers( std::cout, initialAdjustmentParameterIstream, targetBitratesIstream, std::cin );
    6063    return 0;
    61  
     64
    6265  }
    6366  catch( std::exception& e )
  • branches/HTM-14.1-update-dev0/source/App/utils/BitrateTargeting/RuntimeError.h

    r872 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-2014, ITU/ISO/IEC
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    3232 */
    3333
    34 #ifndef DIRECTORY_LIB_RUNTIME_ERROR_H
    35 #define DIRECTORY_LIB_RUNTIME_ERROR_H
     34#ifndef __RUNTIMEERROR__
     35#define __RUNTIMEERROR__
    3636
    3737#include <sstream>
     
    4444    RuntimeError( ): std::runtime_error( "" ), m_firstWhat( true ) { }
    4545    virtual ~RuntimeError( ) throw ( ) { }
    46    
     46
    4747    /// Implementation of the std::exception::what method
    4848    const char * what( ) const throw( )
     
    5757      return m_what.c_str( );
    5858    }
    59    
     59
    6060  protected:
    6161    /// The implementing class implements this method to customize the what output
    6262    /// \param o The what stream is outputted to this parameter
    6363    virtual void outputWhat( std::ostream & o ) const =0;
    64  
     64
    6565  private:
    6666    mutable bool m_firstWhat;  ///< True i.f.f. the what method has not yet been called
  • branches/HTM-14.1-update-dev0/source/App/utils/annexBbytecount.cpp

    r872 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. 
    5  *
    6  * Copyright (c) 2010-2014, ITU/ISO/IEC
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4343using namespace std;
    4444
    45 static struct {
     45static const struct {
    4646  AnnexBStats expected;
    4747  unsigned data_len;
     
    8686      cout << hex << (unsigned int)tests[i].data[j] << dec;
    8787      if (j < tests[i].data_len-1)
     88      {
    8889        cout << ",";
     90      }
    8991    }
    9092    cout << "} ";
     
    103105#undef VERIFY
    104106    if (ok)
     107    {
    105108      cout << "OK";
     109    }
    106110    cout << endl;
    107111  }
     
    113117
    114118  if (argc != 2)
     119  {
    115120    return 0;
     121  }
    116122
    117123  ifstream in(argv[1], ifstream::in | ifstream::binary);
     
    150156
    151157    if (!annexBStatsSingle.m_numBytesInNALUnit)
     158    {
    152159      continue;
     160    }
    153161
    154162    /* identify the NAL unit type and add stats to the correct
  • branches/HTM-14.1-update-dev0/source/App/utils/convert_NtoMbit_YCbCr.cpp

    r872 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-2014, ITU/ISO/IEC
     6 * Copyright (c) 2010-2015, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4141namespace po = df::program_options_lite;
    4242
    43 int main(int argc, const char** argv)
     43Int main(Int argc, const char** argv)
    4444{
    45   bool do_help;
     45  Bool do_help;
    4646  string filename_in, filename_out;
    47   unsigned int width, height;
    48   unsigned int bitdepth_in, bitdepth_out;
    49   unsigned int num_frames;
    50   unsigned int num_frames_skip;
     47  UInt width, height;
     48  UInt bitdepth_in, bitdepth_out, chromaFormatRaw;
     49  UInt num_frames;
     50  UInt num_frames_skip;
    5151
    5252  po::Options opts;
     
    5959  ("InputBitDepth", bitdepth_in, 8u, "bit-depth of input file")
    6060  ("OutputBitDepth", bitdepth_out, 8u, "bit-depth of output file")
     61  ("ChromaFormat", chromaFormatRaw, 420u, "chroma format. 400, 420, 422 or 444 only")
    6162  ("NumFrames", num_frames, 0xffffffffu, "number of frames to process")
    6263  ("FrameSkip,-fs", num_frames_skip, 0u, "Number of frames to skip at start of input YUV")
     
    6566  po::setDefaults(opts);
    6667  po::scanArgv(opts, argc, argv);
     68
    6769
    6870  if (argc == 1 || do_help)
     
    7375  }
    7476
     77  ChromaFormat chromaFormatIDC=CHROMA_420;
     78  switch (chromaFormatRaw)
     79  {
     80    case 400: chromaFormatIDC=CHROMA_400; break;
     81    case 420: chromaFormatIDC=CHROMA_420; break;
     82    case 422: chromaFormatIDC=CHROMA_422; break;
     83    case 444: chromaFormatIDC=CHROMA_444; break;
     84    default:
     85      fprintf(stderr, "Bad chroma format string\n");
     86      return EXIT_FAILURE;
     87  }
     88
    7589  TVideoIOYuv input;
    7690  TVideoIOYuv output;
    7791
    78   input.open((char*)filename_in.c_str(), false, bitdepth_in, bitdepth_in, bitdepth_out, bitdepth_out);
    79   output.open((char*)filename_out.c_str(), true, bitdepth_out, bitdepth_out, bitdepth_out, bitdepth_out);
     92  Int inputBitDepths [MAX_NUM_CHANNEL_TYPE];
     93  Int outputBitDepths[MAX_NUM_CHANNEL_TYPE];
    8094
    81   input.skipFrames(num_frames_skip, width, height);
     95  for (UInt channelTypeIndex = 0; channelTypeIndex < MAX_NUM_CHANNEL_TYPE; channelTypeIndex++)
     96  {
     97    inputBitDepths [channelTypeIndex] = bitdepth_in;
     98    outputBitDepths[channelTypeIndex] = bitdepth_out;
     99  }
     100
     101  input.open((char*)filename_in.c_str(), false, inputBitDepths, inputBitDepths, outputBitDepths);
     102  output.open((char*)filename_out.c_str(), true, outputBitDepths, outputBitDepths, outputBitDepths);
     103
     104  input.skipFrames(num_frames_skip, width, height, chromaFormatIDC);
    82105
    83106  TComPicYuv frame;
    84   frame.create( width, height, 1, 1, 0 );
     107  frame.create( width, height, chromaFormatIDC, width, height, 0, false);
    85108
    86   int pad[2] = {0, 0};
     109  Int pad[2] = {0, 0};
    87110
    88   unsigned int num_frames_processed = 0;
    89   while (!input.isEof())
     111  TComPicYuv cPicYuvTrueOrg;
     112  cPicYuvTrueOrg.create( width, height, chromaFormatIDC, width, height, 0, false );
     113
     114  UInt num_frames_processed = 0;
     115  while (!input.isEof())
    90116  {
    91     if (! input.read(&frame, pad))
     117    if (! input.read(&frame, &cPicYuvTrueOrg, IPCOLOURSPACE_UNCHANGED, pad))
    92118    {
    93119      break;
    94120    }
    95121#if 0
    96     Pel* img = frame.getLumaAddr();
    97     for (int y = 0; y < height; y++)
     122    Pel* img = frame.getAddr(COMPONENT_Y);
     123    for (Int y = 0; y < height; y++)
    98124    {
    99       for (int x = 0; x < height; x++)
     125      for (Int x = 0; x < height; x++)
     126      {
    100127        img[x] = 0;
     128      }
    101129      img += frame.getStride();
    102130    }
    103     img = frame.getLumaAddr();
     131    img = frame.getAddr(COMPONENT_Y);
    104132    img[0] = 1;
    105133#endif
    106134
    107     output.write(&frame);
     135    output.write(&frame, IPCOLOURSPACE_UNCHANGED);
    108136    num_frames_processed++;
    109137    if (num_frames_processed == num_frames)
     138    {
    110139      break;
     140    }
    111141  }
    112142
    113143  input.close();
    114144  output.close();
     145  cPicYuvTrueOrg.destroy();
    115146
    116147  return EXIT_SUCCESS;
Note: See TracChangeset for help on using the changeset viewer.