Changeset 56 in 3DVCSoftware for trunk/source/Lib/TLibCommon/TComBitStream.h

Timestamp:

11 May 2012, 21:20:17 (13 years ago)

Author:

hschwarz

Message:

updated trunk (move to HM6.1)

File:

• trunk/source/Lib/TLibCommon/TComBitStream.h (modified) (6 diffs)

trunk/source/Lib/TLibCommon/TComBitStream.h

@@ -2 +2 @@
  * License, included below. This software may be subject to other third party
  * and contributor rights, including patent rights, and no such rights are
- * granted under this license.
- *
- * Copyright (c) 2010-2011, ISO/IEC
+ * granted under this license.  
+ *
+ * Copyright (c) 2010-2012, ITU/ISO/IEC
  * All rights reserved.
  *
@@ -15 +15 @@
  *    this list of conditions and the following disclaimer in the documentation
  *    and/or other materials provided with the distribution.
- *  * Neither the name of the ISO/IEC nor the names of its contributors may
+ *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
  *    be used to endorse or promote products derived from this software without
  *    specific prior written permission.
@@ -32 +32 @@
  */
 
-
-
 /** \file     TComBitStream.h
     \brief    class for handling bitstream (header)
@@ -45 +43 @@
 #endif // _MSC_VER > 1000
 
+#include <stdint.h>
+#include <vector>
 #include <stdio.h>
 #include <assert.h>
 #include "CommonDef.h"
+
+//! \ingroup TLibCommon
+//! \{
 
 // ====================================================================================================================
@@ -58 +61 @@
 public:
   virtual Void        writeAlignOne         () {};
+  virtual Void        writeAlignZero        () {};
   virtual Void        write                 ( UInt uiBits, UInt uiNumberOfBits )  = 0;
   virtual Void        resetBits             ()                                    = 0;
@@ -64 +68 @@
 };
 
-/// class for handling bitstream
-class TComBitstream : public TComBitIf
+/**
+ * Model of a writable bitstream that accumulates bits to produce a
+ * bytestream.
+ */
+class TComOutputBitstream : public TComBitIf
 {
+  /**
+   * FIFO for storage of bytes.  Use:
+   *  - fifo.push_back(x) to append words
+   *  - fifo.clear() to empty the FIFO
+   *  - &fifo.front() to get a pointer to the data array.
+   *    NB, this pointer is only valid until the next push_back()/clear()
+   */
+  std::vector<uint8_t> *m_fifo;
+
+  unsigned int m_num_held_bits; /// number of bits not flushed to bytestream.
+  unsigned char m_held_bits; /// the bits held and not flushed to bytestream.
+                             /// this value is always msb-aligned, bigendian.
+  UInt m_uiTileMarkerLocationCount;
+  UInt *m_puiTileMarkerLocation;
+
+public:
+  // create / destroy
+  TComOutputBitstream();
+  ~TComOutputBitstream();
+
+  // interface for encoding
+  /**
+   * append uiNumberOfBits least significant bits of uiBits to
+   * the current bitstream
+   */
+  Void        write           ( UInt uiBits, UInt uiNumberOfBits );
+
+  /** insert one bits until the bitstream is byte-aligned */
+  Void        writeAlignOne   ();
+
+  /** insert zero bits until the bitstream is byte-aligned */
+  Void        writeAlignZero  ();
+
+  /** this function should never be called */
+  void resetBits() { assert(0); }
+
+  // utility functions
+
+  /**
+   * Return a pointer to the start of the byte-stream buffer.
+   * Pointer is valid until the next write/flush/reset call.
+   * NB, data is arranged such that subsequent bytes in the
+   * bytestream are stored in ascending addresses.
+   */
+  char* getByteStream() const;
+
+  /**
+   * Return the number of valid bytes available from  getByteStream()
+   */
+  unsigned int getByteStreamLength();
+
+  /**
+   * Reset all internal state.
+   */
+  Void clear();
+
+  /**
+   * returns the number of bits that need to be written to
+   * achieve byte alignment.
+   */
+  Int getNumBitsUntilByteAligned() { return (8 - m_num_held_bits) & 0x7; }
+
+  /**
+   * Return the number of bits that have been written since the last clear()
+   */
+  unsigned getNumberOfWrittenBits() const { return unsigned(m_fifo->size()) * 8 + m_num_held_bits; }
+
+  void insertAt(const TComOutputBitstream& src, unsigned pos);
+
+  /**
+   * Return a reference to the internal fifo
+   */
+  std::vector<uint8_t>& getFIFO() { return *m_fifo; }
+
+  UChar getHeldBits  ()          { return m_held_bits;          }
+
+  TComOutputBitstream& operator= (const TComOutputBitstream& src);
+  UInt  getTileMarkerLocationCount   ( )                     { return m_uiTileMarkerLocationCount   ; }
+  Void  setTileMarkerLocationCount   ( UInt i )              { m_uiTileMarkerLocationCount = i      ; }  
+  UInt  getTileMarkerLocation        ( UInt i)               { return m_puiTileMarkerLocation[i]    ; }
+  Void  setTileMarkerLocation        ( UInt i, UInt uiLOC )  { m_puiTileMarkerLocation[i] = uiLOC   ; }
+  /** Return a reference to the internal fifo */
+  std::vector<uint8_t>& getFIFO() const { return *m_fifo; }
+
+  Void          addSubstream    ( TComOutputBitstream* pcSubstream );
+};
+
+/**
+ * Model of an input bitstream that extracts bits from a predefined
+ * bytestream.
+ */
+class TComInputBitstream
+{
+  std::vector<uint8_t> *m_fifo; /// FIFO for storage of complete bytes
+
 protected:
-  UInt*       m_apulStreamPacketBegin;
-  UInt*       m_pulStreamPacket;
-  UInt        m_uiBufSize;
-  
-  UInt        m_uiBitSize;
-  Int         m_iValidBits;
-  
-  UInt        m_ulCurrentBits;
-  UInt        m_uiBitsWritten;
-  
-  UInt        m_uiDWordsLeft;
-  UInt        m_uiBitsLeft;
-  UInt        m_uiNextBits;
-  
-  UInt        *m_auiSliceByteLocation, m_uiSliceCount;  // used to skip over slice start codes in initParsingConvertPayloadToRBSP()
-  UInt        m_uiSliceProcessed;
-
-#if BITSTREAM_EXTRACTION
-  UInt*       m_apulPacketPayloadBuffer;
-  UInt        m_uiPacketPayloadSize;
-#endif  
-
-  UInt xSwap ( UInt ui )
+  unsigned int m_fifo_idx; /// Read index into m_fifo
+
+  unsigned int m_num_held_bits;
+  unsigned char m_held_bits;
+  UInt m_uiTileMarkerLocationCount;
+  UInt *m_puiTileMarkerLocation;
+#if TILES_WPP_ENTRY_POINT_SIGNALLING
+  UInt  m_numBitsRead;
+#endif
+
+public:
+  /**
+   * Create a new bitstream reader object that reads from #buf#.  Ownership
+   * of #buf# remains with the callee, although the constructed object
+   * will hold a reference to #buf#
+   */
+  TComInputBitstream(std::vector<uint8_t>* buf);
+  ~TComInputBitstream();
+
+  // interface for decoding
+  Void        pseudoRead      ( UInt uiNumberOfBits, UInt& ruiBits );
+  Void        read            ( UInt uiNumberOfBits, UInt& ruiBits );
+#if OL_FLUSH && !OL_FLUSH_ALIGN
+  Void        readByte        ( UInt &ruiBits )
   {
-    // heiko.schwarz@hhi.fhg.de: support for BSD systems as proposed by Steffen Kamp [kamp@ient.rwth-aachen.de]
-#ifdef MSYS_BIG_ENDIAN
-    return ui;
+    // More expensive, but reads "bytes" that are not aligned.
+    read(8, ruiBits);
+  }
 #else
-    UInt ul2;
-    
-    ul2  = ui>>24;
-    ul2 |= (ui>>8) & 0x0000ff00;
-    ul2 |= (ui<<8) & 0x00ff0000;
-    ul2 |= ui<<24;
-    
-    return ul2;
-#endif
+  Void        readByte        ( UInt &ruiBits )
+  {
+    assert(m_fifo_idx < m_fifo->size());
+    ruiBits = (*m_fifo)[m_fifo_idx++];
   }
-  
-  // read one word
-  __inline Void xReadNextWord ();
-  
-public:
-  TComBitstream()             {}
-  virtual ~TComBitstream()    {}
-  
-  // create / destroy
-  Void        create          ( UInt uiSizeInBytes );
-  Void        destroy         ();
-  
-  // interface for encoding
-  Void        write           ( UInt uiBits, UInt uiNumberOfBits );
-  Void        writeAlignOne   ();
-  Void        writeAlignZero  ();
-  Void        convertRBSPToPayload( UInt uiStartPos = 0);
-  // interface for decoding
-  Void        initParsingConvertPayloadToRBSP( const UInt uiBytesRead );
-  Void        initParsing     ( UInt uiNumBytes );
-#if LCEC_INTRA_MODE || QC_LCEC_INTER_MODE
-  Void        pseudoRead      ( UInt uiNumberOfBits, UInt& ruiBits );
-#endif
-  Void        read            ( UInt uiNumberOfBits, UInt& ruiBits );
-  Void        readAlignOne    ();
-  UInt        getSliceProcessed                ()       { return m_uiSliceProcessed;                }
-  Void        setSliceProcessed                (UInt u) { m_uiSliceProcessed                = u;    }
-  
-  // interface for slice start-code positioning at encoder
-  UInt        getSliceCount                    ()                            { return m_uiSliceCount;                     }
-  UInt        getSliceByteLocation             ( UInt uiIdx )                { return m_auiSliceByteLocation[ uiIdx ];    }
-  Void        setSliceCount                    ( UInt uiCount )              { m_uiSliceCount = uiCount;                  }
-  Void        setSliceByteLocation             ( UInt uiIdx, UInt uiCount )  { m_auiSliceByteLocation[ uiIdx ] = uiCount; }
-
-  // memory allocation / deallocation interface for "slice location" bookkeeping
-  Void        allocateMemoryForSliceLocations       ( UInt uiMaxNumOfSlices );
-  Void        freeMemoryAllocatedForSliceLocations  ();
+#endif // OL_FLUSH && !OL_FLUSH_ALIGN
+
+  Void        readOutTrailingBits ();
+  UChar getHeldBits  ()          { return m_held_bits;          }
+  TComOutputBitstream& operator= (const TComOutputBitstream& src);
+  UInt  getTileMarkerLocationCount   ( )                     { return m_uiTileMarkerLocationCount   ; }
+  Void  setTileMarkerLocationCount   ( UInt i )              { m_uiTileMarkerLocationCount = i      ; }  
+  UInt  getTileMarkerLocation        ( UInt i)               { return m_puiTileMarkerLocation[i]    ; }
+  Void  setTileMarkerLocation        ( UInt i, UInt uiLOC )  { m_puiTileMarkerLocation[i] = uiLOC   ; }
+  UInt  getByteLocation              ( )                     { return m_fifo_idx                    ; }
 
   // Peek at bits in word-storage. Used in determining if we have completed reading of current bitstream and therefore slice in LCEC.
-  UInt        peekBits (UInt uiBits) { return( m_ulCurrentBits >> (32 - uiBits));  }
-
-  // reset internal status
-  Void        resetBits       ()
-  {
-    m_uiBitSize = 0;
-    m_iValidBits = 32;
-    m_ulCurrentBits = 0;
-    m_uiBitsWritten = 0;
-  }
-  
+  UInt        peekBits (UInt uiBits) { unsigned tmp; pseudoRead(uiBits, tmp); return tmp; }
+
   // utility functions
   unsigned read(unsigned numberOfBits) { UInt tmp; read(numberOfBits, tmp); return tmp; }
-  UInt* getStartStream() const { return m_apulStreamPacketBegin; }
-  UInt*       getBuffer()               { return  m_pulStreamPacket;                    }
-  Int         getBitsUntilByteAligned() { return m_iValidBits & (0x7);                  }
-  Void        setModeSbac()             { m_uiBitsLeft = 8*((m_uiBitsLeft+7)/8);        } // stop bit + trailing stuffing bits
-  Bool        isWordAligned()           { return  (0 == (m_iValidBits & (0x1f)));       }
-  UInt getNumberOfWrittenBits() const { return  m_uiBitsWritten; }
-  Void        flushBuffer();
-  Void        rewindStreamPacket()      { m_pulStreamPacket = m_apulStreamPacketBegin;  }
-  UInt        getBitsLeft()             { return  m_uiBitsLeft;                         }
-
-  void insertAt(const TComBitstream& src, unsigned pos);
-
-#if BITSTREAM_EXTRACTION
-  UInt        reinitParsing();
-#endif  
+  UInt     readByte() { UInt tmp; readByte( tmp ); return tmp; }
+  unsigned getNumBitsUntilByteAligned() { return m_num_held_bits & (0x7); }
+  unsigned getNumBitsLeft() { return 8*((unsigned)m_fifo->size() - m_fifo_idx) + m_num_held_bits; }
+  TComInputBitstream *extractSubstream( UInt uiNumBits ); // Read the nominated number of bits, and return as a bitstream.
+  Void                deleteFifo(); // Delete internal fifo of bitstream.
+#if !OL_FLUSH_ALIGN
+  Void                backupByte() { m_fifo_idx--; }
+#endif
+#if TILES_WPP_ENTRY_POINT_SIGNALLING
+  UInt  getNumBitsRead() { return m_numBitsRead; }
+#endif
 };
 
-#endif
-
+//! \}
+
+#endif