Add new option in calypTools to process video with negative values

lib/CalypFrame.cpp

@@ -102,6 +102,7 @@ public:
   int m_iPixelFormat;             //!< Pixel format number (it follows the list of supported pixel formats)
   unsigned int m_uiBitsPel;       //!< Bits per pixel/channel
   unsigned int m_uiHalfPelValue;  //!< Bits per pixel/channel
+  bool m_bHasNegativeValues;      //!< Half of the scale correspond to negative values
 
   ClpPel*** m_pppcInputPel;
 
@@ -118,15 +119,12 @@ public:
   /** Numbers of histogram segments depending of image bytes depth*/
   unsigned int m_uiHistoSegments;
 
-  /**
-     * Common constructor function of a frame
-     *
-     * @param width width of the frame
-     * @param height height of the frame
-     * @param pel_format pixel format index (always use PixelFormats enum)
-     *
-     */
   void init( unsigned int width, unsigned int height, int pel_format, unsigned bitsPixel )
+  {
+    init( width, height, pel_format, bitsPixel, false );
+  }
+
+  void init( unsigned int width, unsigned int height, int pel_format, unsigned bitsPixel, bool has_negative_values )
   {
     m_bInit = false;
     m_bHasRGBPel = false;
@@ -137,6 +135,7 @@ public:
     m_iPixelFormat = pel_format;
     m_uiBitsPel = bitsPixel < 8 ? 8 : bitsPixel;
     m_uiHalfPelValue = 1 << ( m_uiBitsPel - 1 );
+    m_bHasNegativeValues = has_negative_values;
 
     if( m_uiWidth == 0 || m_uiHeight == 0 || m_iPixelFormat == -1 || bitsPixel > 16 )
     {
@@ -265,10 +264,16 @@ CalypFrame::CalypFrame( unsigned int width, unsigned int height, int pelFormat,
   d->init( width, height, pelFormat, bitsPixel );
 }
 
+CalypFrame::CalypFrame( unsigned int width, unsigned int height, int pelFormat, unsigned bitsPixel, bool has_negative_values )
+    : d( new CalypFramePrivate )
+{
+  d->init( width, height, pelFormat, bitsPixel, has_negative_values );
+}
+
 CalypFrame::CalypFrame( const CalypFrame& other )
     : d( new CalypFramePrivate )
 {
-  d->init( other.getWidth(), other.getHeight(), other.getPelFormat(), other.getBitsPel() );
+  d->init( other.getWidth(), other.getHeight(), other.getPelFormat(), other.getBitsPel(), other.getHasNegativeValues() );
   copyFrom( &other );
 }
 
@@ -277,7 +282,7 @@ CalypFrame::CalypFrame( const CalypFrame* other )
 {
   if( other )
   {
-    d->init( other->getWidth(), other->getHeight(), other->getPelFormat(), other->getBitsPel() );
+    d->init( other->getWidth(), other->getHeight(), other->getPelFormat(), other->getBitsPel(), other->getHasNegativeValues() );
     copyFrom( other );
   }
 }
@@ -397,6 +402,11 @@ unsigned CalypFrame::getHeight( unsigned channel ) const
   return CHROMASHIFT( d->m_uiHeight, channel > 0 ? d->m_pcPelFormat->log2ChromaHeight : 0 );
 }
 
+bool CalypFrame::getHasNegativeValues() const
+{
+  return d->m_bHasNegativeValues;
+}
+
 ClpULong CalypFrame::getPixels( unsigned channel ) const
 {
   return getWidth( channel ) * getHeight( channel );
@@ -490,19 +500,24 @@ unsigned char* CalypFrame::getRGBBuffer() const
   return NULL;
 }
 
-ClpPel CalypFrame::operator()( unsigned int ch, unsigned int xPos, unsigned int yPos )
+ClpPel CalypFrame::operator()( unsigned int ch, unsigned int xPos, unsigned int yPos, bool absolute ) const
 {
+  int retValue = 0;
   if( ch < d->m_pcPelFormat->numberChannels )
-    return d->m_pppcInputPel[ch][yPos][xPos];
-  return 0;
+  {
+    retValue = d->m_pppcInputPel[ch][yPos][xPos];
+    if( !absolute && d->m_bHasNegativeValues )
+      retValue = retValue - int(d->m_uiHalfPelValue);
+  }
+  return ClpPel( retValue );
 }
 
-CalypPixel CalypFrame::operator()( unsigned int xPos, unsigned int yPos )
+CalypPixel CalypFrame::operator()( unsigned int xPos, unsigned int yPos ) const
 {
   return getPixel( xPos, yPos );
 }
 
-CalypPixel CalypFrame::getPixel( unsigned int xPos, unsigned int yPos )
+CalypPixel CalypFrame::getPixel( unsigned int xPos, unsigned int yPos ) const
 {
   CalypPixel PixelValue( d->m_pcPelFormat->colorSpace );
   for( unsigned int ch = 0; ch < d->m_pcPelFormat->numberChannels; ch++ )

lib/CalypFrame.h

@@ -113,6 +113,17 @@ public:
 	 */
   CalypFrame( unsigned int width, unsigned int height, int pelFormat, unsigned bitsPixel = 8 );
 
+  /**
+   * Creates a new frame using the following configuration
+   *
+   * @param width width of the frame
+   * @param height height of the frame
+   * @param pel_format pixel format index (always use PixelFormats enum)
+   *
+   * @note this function might misbehave if the pixel format enum is not correct
+   */
+  CalypFrame( unsigned int width, unsigned int height, int pelFormat, unsigned bitsPixel, bool has_negative_values );
+
   /**
 	 * Copy contructor
 	 *
@@ -197,6 +208,12 @@ public:
 	 */
   unsigned int getHeight( unsigned channel = 0 ) const;
 
+  /**
+   * Check if frame has negative values
+   * @return Boolean with the flag value
+   */
+  bool getHasNegativeValues() const;
+
   /**
 	 * Get number of pixels of the frame
 	 * @param channel/component
@@ -261,9 +278,10 @@ public:
 	 * @param ch frame channel
 	 * @param xPos position in X axis
 	 * @param yPos position in Y axis
+   * @param absolute whether it should return positive/negative values
 	 * @return pixel value
 	 */
-  ClpPel operator()( unsigned int ch, unsigned int xPos, unsigned int yPos );
+  ClpPel operator()( unsigned int ch, unsigned int xPos, unsigned int yPos, bool absolute = true ) const;
 
   /**
 	 * Get pixel value at coordinates
@@ -271,7 +289,7 @@ public:
 	 * @param yPos position in Y axis
 	 * @return pixel value
 	 */
-  CalypPixel operator()( unsigned int xPos, unsigned int yPos );
+  CalypPixel operator()( unsigned int xPos, unsigned int yPos ) const;
 
   /**
 	 * Get pixel value at coordinates
@@ -279,7 +297,8 @@ public:
 	 * @param yPos position in Y axis
 	 * @return pixel value
 	 */
-  CalypPixel getPixel( unsigned int xPos, unsigned int yPos );
+  CalypPixel getPixel( unsigned int xPos, unsigned int yPos ) const;
+
 
   /**
 	 * Get pixel value at coordinates

lib/CalypStream.cpp

@@ -103,11 +103,11 @@ private:
   unsigned int m_uiIndex;
 
 public:
-  CalypStreamBufferPrivate( unsigned int size, unsigned int width, unsigned int height, int pelFormat, int bitsPixel )
+  CalypStreamBufferPrivate( unsigned int size, unsigned int width, unsigned int height, int pelFormat, int bitsPixel, bool hasNegative )
   {
     for( unsigned int i = 0; i < size; i++ )
     {
-      CalypFrame* pFrame = new CalypFrame( width, height, pelFormat, bitsPixel );
+      CalypFrame* pFrame = new CalypFrame( width, height, pelFormat, bitsPixel, hasNegative );
       m_apcFrameBuffer.push_back( pFrame );
     }
     m_uiIndex = 0;
@@ -238,7 +238,7 @@ ClpString CalypStream::getCodecName() const
   return !d->handler ? "" : d->handler->getCodecName();
 }
 
-bool CalypStream::open( ClpString filename, ClpString resolution, ClpString input_format_name, unsigned int bitsPel, int endianness,
+bool CalypStream::open( ClpString filename, ClpString resolution, ClpString input_format_name, unsigned int bitsPel, int endianness, bool hasNegative,
                         unsigned int frame_rate, bool bInput )
 {
   unsigned int width = 0;
@@ -261,11 +261,17 @@ bool CalypStream::open( ClpString filename, ClpString resolution, ClpString inpu
       break;
     }
   }
-  return open( filename, width, height, input_format, bitsPel, endianness, frame_rate, bInput );
+  return open( filename, width, height, input_format, bitsPel, endianness, hasNegative, frame_rate, bInput );
 }
 
 bool CalypStream::open( ClpString filename, unsigned int width, unsigned int height, int input_format, unsigned int bitsPel, int endianness,
                         unsigned int frame_rate, bool bInput )
+{
+  return open( filename, width, height, input_format, bitsPel, endianness, false, frame_rate, bInput );
+}
+
+bool CalypStream::open( ClpString filename, unsigned int width, unsigned int height, int input_format, unsigned int bitsPel, int endianness, bool hasNegative,
+                        unsigned int frame_rate, bool bInput )
 {
   if( d->isInit )
   {
@@ -314,7 +320,7 @@ bool CalypStream::open( ClpString filename, unsigned int width, unsigned int hei
   try
   {
     d->frameBuffer = new CalypStreamBufferPrivate( d->isInput ? 3 : 1, d->handler->m_uiWidth, d->handler->m_uiHeight,
-                                                   d->handler->m_iPixelFormat, d->handler->m_uiBitsPerPixel );
+                                                   d->handler->m_iPixelFormat, d->handler->m_uiBitsPerPixel, hasNegative );
   }
   catch( CalypFailure& e )
   {

lib/CalypStream.h

@@ -72,10 +72,13 @@ public:
   ClpString getCodecName() const;
   ;
 
-  bool open( ClpString filename, ClpString resolution, ClpString input_format, unsigned int bitsPel, int endianness, unsigned int frame_rate,
+  bool open( ClpString filename, ClpString resolution, ClpString input_format, unsigned int bitsPel, int endianness, bool hasNegative, unsigned int frame_rate,
              bool bInput );
   bool open( ClpString filename, unsigned int width, unsigned int height, int input_format, unsigned int bitsPel, int endianness, unsigned int frame_rate,
              bool bInput );
+  bool open( ClpString filename, unsigned int width, unsigned int height, int input_format, unsigned int bitsPel, int endianness, bool hasNegative, unsigned int frame_rate,
+             bool bInput );
+
   bool reload();
   void close();
 

modules/EightBitsSampling.cpp

@@ -31,7 +31,7 @@ EightBitsSampling::EightBitsSampling()
   m_iModuleType = CLP_FRAME_PROCESSING_MODULE;
   m_pchModuleCategory = "Conversions";
   m_pchModuleName = "BitsResampling";
-  m_pchModuleLongName = "Re-sampling frame";
+  m_pchModuleLongName = "Re-sampling frame (bpp)";
   m_pchModuleTooltip = "Re-sampling frame to a different value of bits per pixel";
   m_uiNumberOfFrames = 1;
   m_uiModuleRequirements = CLP_MODULE_REQUIRES_OPTIONS;

modules/FrameDifference.cpp

@@ -38,9 +38,12 @@ FrameDifference::FrameDifference()
   m_uiNumberOfFrames = 2;
 
   m_cModuleOptions.addOptions() /**/
-      ( "Bits per pixel", m_uiBitsPixel, "Bits per pixel (use zero to avoid scaling) [0]" );
+      ( "BitsPerpixel", m_uiBitsPixel, "Bits per pixel (use zero to avoid scaling) [0]" ) /**/
+      ( "SumOperation", m_uiSumOperation, "Sum instead of difference [0]" );
 
   m_uiBitsPixel = 0;
+  m_uiSumOperation = 0;
+  m_iOperation = 1;
 
   m_pcFrameDifference = NULL;
 }
@@ -49,6 +52,8 @@ bool FrameDifference::create( std::vector<CalypFrame*> apcFrameList )
 {
   _BASIC_MODULE_API_2_CHECK_
 
+  m_uiSumOperation = m_uiSumOperation > 1 ? 0 : m_uiSumOperation;
+
   unsigned int uiMaxBitsPixel = 0;
   for( unsigned int i = 0; i < apcFrameList.size(); i++ )
   {
@@ -57,42 +62,46 @@ bool FrameDifference::create( std::vector<CalypFrame*> apcFrameList )
     if( apcFrameList[i]->getBitsPel() > uiMaxBitsPixel )
     {
       uiMaxBitsPixel = apcFrameList[i]->getBitsPel();
+      if( apcFrameList[i]->getHasNegativeValues() )
+        uiMaxBitsPixel -= 1;
     }
   }
 
-  if( !m_uiBitsPixel )
-  {
-    m_uiBitsPixel = ( uiMaxBitsPixel + 1 ) & 0x0F;
-  }
+  uiMaxBitsPixel = m_uiSumOperation ? uiMaxBitsPixel : uiMaxBitsPixel + 1;
+  m_uiBitsPixel =  !m_uiBitsPixel ? uiMaxBitsPixel & 0x0F : m_uiBitsPixel;
 
-  m_iDiffBitShift = ( uiMaxBitsPixel + 1 ) - m_uiBitsPixel;
-  m_iMaxDiffValue = ( 1 << ( m_uiBitsPixel - 1 ) );
+  m_iDiffBitShift = uiMaxBitsPixel - m_uiBitsPixel;
+  m_iMaxDiffValue = ( 1 << ( m_uiSumOperation ? m_uiBitsPixel : m_uiBitsPixel - 1 ) );
 
   m_pcFrameDifference = new CalypFrame( apcFrameList[0]->getWidth(), apcFrameList[0]->getHeight(),
-                                        apcFrameList[0]->getPelFormat(), m_uiBitsPixel );
+                                        apcFrameList[0]->getPelFormat(), m_uiBitsPixel, m_uiSumOperation == 1 ? false : true );
+
+  m_iOperation = m_uiSumOperation == 0 ? -1 : 1 ;
   return true;
 }
 
 CalypFrame* FrameDifference::process( std::vector<CalypFrame*> apcFrameList )
 {
-  ClpPel* pInput1PelYUV = apcFrameList[0]->getPelBufferYUV()[0][0];
-  ClpPel* pInput2PelYUV = apcFrameList[1]->getPelBufferYUV()[0][0];
+  const CalypFrame& frame1 = apcFrameList[0];
+  const CalypFrame& frame2 = apcFrameList[1];
   ClpPel* pOutputPelYUV = m_pcFrameDifference->getPelBufferYUV()[0][0];
-  int aux_pel_1, aux_pel_2;
-  int diff = 0;
+  short aux_pel_1, aux_pel_2;
+  short diff = 0;
 
   for( unsigned int ch = 0; ch < m_pcFrameDifference->getNumberChannels(); ch++ )
-    for( unsigned int y = 0; y < m_pcFrameDifference->getHeight(); y++ )
-      for( unsigned int x = 0; x < m_pcFrameDifference->getWidth(); x++ )
+    for( unsigned int y = 0; y < m_pcFrameDifference->getHeight( ch ); y++ )
+      for( unsigned int x = 0; x < m_pcFrameDifference->getWidth( ch ); x++ )
       {
-        aux_pel_1 = *pInput1PelYUV++;
-        aux_pel_2 = *pInput2PelYUV++;
-        diff = aux_pel_1 - aux_pel_2;
-        diff = m_iDiffBitShift > 0 ? diff >> m_iDiffBitShift : diff << m_iDiffBitShift;
-        diff = std::min( diff, m_iMaxDiffValue - 1 );
-        diff = std::max( diff, -m_iMaxDiffValue );
-
+        aux_pel_1 = frame1(ch, x, y, false );
+        aux_pel_2 = frame2(ch, x, y, false );
+        diff = aux_pel_1 + m_iOperation * aux_pel_2;
+        diff = m_iDiffBitShift > 0 ? diff >> m_iDiffBitShift : diff << -m_iDiffBitShift;
+        diff = std::min<short>( diff, m_iMaxDiffValue - 1 );
+        if( m_uiSumOperation == 0 )
+        {
+          diff = std::max<short>( diff, -m_iMaxDiffValue );
           diff += m_iMaxDiffValue;
+        }
         *pOutputPelYUV++ = diff;
       }
   return m_pcFrameDifference;

modules/FrameDifference.h

@@ -34,8 +34,10 @@ class FrameDifference : public CalypModuleIf
 
 private:
   unsigned int m_uiBitsPixel;
+  unsigned int m_uiSumOperation;
+  int m_iOperation;
   int m_iDiffBitShift;
-  int m_iMaxDiffValue;
+  short m_iMaxDiffValue;
   CalypFrame* m_pcFrameDifference;
 
 public:

modules/FrameResampling.cpp

@@ -40,7 +40,7 @@ FrameResampling::FrameResampling()
   m_iModuleType = CLP_FRAME_PROCESSING_MODULE;
   m_pchModuleCategory = "Utilities";
   m_pchModuleName = "FrameResampling";
-  m_pchModuleLongName = "Frame Resampling";
+  m_pchModuleLongName = "Frame Resampling (Spatial)";
   m_pchModuleTooltip = "Resampling frame to an abritary resolution";
   m_uiNumberOfFrames = 1;
   m_uiModuleRequirements = CLP_MODULE_REQUIRES_OPTIONS;

tools/CalypTools.cpp

@@ -23,12 +23,12 @@
  */
 
 #include "CalypTools.h"
-#include "config.h"
 
 #include <climits>
 #include <cstring>
 #include <iostream>
 
+#include "config.h"
 #include "lib/CalypFrame.h"
 #include "lib/CalypModuleIf.h"
 #include "lib/CalypStream.h"
@@ -79,13 +79,14 @@ int CalypTools::openInputs()
     ClpString fmtString( "yuv420p" );
     unsigned int uiBitsPerPixel = 8;
     unsigned int uiEndianness = 0;
+    bool hasNegativeValues = false;
 
     CalypStream* pcStream;
     for( unsigned int i = 0; i < inputFileNames.size() && i < MAX_NUMBER_INPUTS; i++ )
     {
       if( Opts().hasOpt( "size" ) )
       {
-        resolutionString = GET_PARAM( m_strResolution, 0 );
+        resolutionString = GET_PARAM( m_strResolution, i );
       }
       if( Opts().hasOpt( "pel_fmt" ) )
       {
@@ -106,10 +107,14 @@ int CalypTools::openInputs()
           uiEndianness = 1;
         }
       }
+      if( Opts().hasOpt( "has_negative" ) )
+      {
+        hasNegativeValues = std::stoi( GET_PARAM( m_strHasNegativeValues, i ).c_str() ) == 0 ? false : true;
+      }
       pcStream = new CalypStream;
       try
       {
-        if( !pcStream->open( inputFileNames[i], resolutionString, fmtString, uiBitsPerPixel, uiEndianness, 1, true ) )
+        if( !pcStream->open( inputFileNames[i], resolutionString, fmtString, uiBitsPerPixel, uiEndianness, hasNegativeValues, 1, true ) )
         {
           log( CLP_LOG_ERROR, "Cannot open input stream %s! ", inputFileNames[i].c_str() );
           return -1;
@@ -172,11 +177,11 @@ int CalypTools::Open( int argc, char* argv[] )
   m_uiOutEndianness = 0;
   if( Opts().hasOpt( "endianness" ) )
   {
-    if( m_strEndianness[0] == "big" )
+    if( GET_PARAM( m_strEndianness, 9999 ) == "big" )
     {
       m_uiOutEndianness = 0;
     }
-    else if( m_strEndianness[0] == "little" )
+    else if( GET_PARAM( m_strEndianness, 9999 ) == "little" )
     {
       m_uiOutEndianness = 1;
     }

tools/CalypToolsCmdParser.cpp

@@ -24,15 +24,15 @@
 
 #include "CalypToolsCmdParser.h"
 
+#include <cstdarg>
+#include <cstring>
+#include <iostream>
+
 #include "lib/CalypFrame.h"
 #include "lib/CalypModuleIf.h"
 #include "lib/CalypStream.h"
 #include "modules/CalypModulesFactory.h"
 
-#include <cstdarg>
-#include <cstring>
-#include <iostream>
-
 CalypToolsCmdParser::CalypToolsCmdParser()
 {
   m_uiLogLevel = 0;
@@ -66,6 +66,7 @@ int CalypToolsCmdParser::parseToolsArgs( int argc, char* argv[] )
       ( "pel_fmt,p", m_strPelFmt, "pixel format" )                                       /**/
       ( "bits_pel", m_strBitsPerPixel, "bits per pixel" )                                /**/
       ( "endianness", m_strEndianness, "File endianness (big, little)" )                 /**/
+      ( "has_negative", m_strHasNegativeValues, "Flag for files with negatie values" )   /**/
       ( "frames,f", m_iFrames, "number of frames to parse" )                             /**/
       ( "quality", m_strQualityMetric, "select a quality metric" )                       /**/
       ( "module", m_strModule, "select a module (use internal name)" )                   /**/

tools/CalypToolsCmdParser.h

@@ -69,6 +69,7 @@ protected:
   std::vector<ClpString> m_strPelFmt;
   std::vector<ClpString> m_strBitsPerPixel;
   std::vector<ClpString> m_strEndianness;
+  std::vector<ClpString> m_strHasNegativeValues;
   ClpString m_strOutput;
   long m_iFrames;
   unsigned m_uiOutEndianness;