Ticket #994: entry_point_offset_wpp_hm-9.1.patch

Lib/TLibCommon/TComBitStream.h

@@ -162 +162 @@
 class TComInputBitstream
 {
   std::vector<uint8_t> *m_fifo; /// FIFO for storage of complete bytes
+  std::vector<UInt> m_emulationPreventionByteLocation;
 
 protected:
   UInt m_fifo_idx; /// Read index into m_fifo
@@ -205 +206 @@
   Void                deleteFifo(); // Delete internal fifo of bitstream.
   UInt  getNumBitsRead() { return m_numBitsRead; }
   Void readByteAlignment();
+
+  Void      pushEmulationPreventionByteLocation ( UInt pos )                  { m_emulationPreventionByteLocation.push_back( pos ); }
+  UInt      numEmulationPreventionBytesRead     ()                            { return m_emulationPreventionByteLocation.size();    }
+  std::vector<UInt>  getEmulationPreventionByteLocation  ()                   { return m_emulationPreventionByteLocation;           }
+  UInt      getEmulationPreventionByteLocation  ( UInt idx )                  { return m_emulationPreventionByteLocation[ idx ];    }
+  Void      clearEmulationPreventionByteLocation()                            { m_emulationPreventionByteLocation.clear();          }
+  Void      setEmulationPreventionByteLocation  ( std::vector<UInt> vec )     { m_emulationPreventionByteLocation = vec;            }
 };
 
 //! \}

Lib/TLibDecoder/NALread.cpp

@@ -58 +58 @@
   UInt zeroCount = 0;
   vector<uint8_t>::iterator it_read, it_write;
 
-  for (it_read = it_write = nalUnitBuf.begin(); it_read != nalUnitBuf.end(); it_read++, it_write++)
+  UInt pos = 0;
+  pcBitstream->clearEmulationPreventionByteLocation();
+  for (it_read = it_write = nalUnitBuf.begin(); it_read != nalUnitBuf.end(); it_read++, it_write++, pos++)
   {
     assert(zeroCount < 2 || *it_read >= 0x03);
     if (zeroCount == 2 && *it_read == 0x03)
     {
+      pcBitstream->pushEmulationPreventionByteLocation( pos );
+      pos++;
       it_read++;
       zeroCount = 0;
       if (it_read == nalUnitBuf.end())
@@ -144 +148 @@
 #endif
   
   nalu.m_Bitstream = new TComInputBitstream(&nalUnitBuf);
+  nalu.m_Bitstream->setEmulationPreventionByteLocation(pcBitstream->getEmulationPreventionByteLocation());
   delete pcBitstream;
   readNalUnitHeader(nalu);
 }

Lib/TLibDecoder/TDecCAVLC.cpp

@@ -1337 +1337 @@
     rpcSlice->setLFCrossSliceBoundaryFlag( (uiCode==1)?true:false);
 
   }
-    if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() )
+
+  UInt *entryPointOffset          = NULL;
+  UInt numEntryPointOffsets, offsetLenMinus1;
+  if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() )
+  {
+    READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets );
+    if (numEntryPointOffsets>0)
     {
-      UInt *entryPointOffset          = NULL;
-      UInt numEntryPointOffsets, offsetLenMinus1;
+      READ_UVLC(offsetLenMinus1, "offset_len_minus1");
+    }
+    entryPointOffset = new UInt[numEntryPointOffsets];
+    for (UInt idx=0; idx<numEntryPointOffsets; idx++)
+    {
+      READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset");
+      entryPointOffset[ idx ] = uiCode;
+    }
+  }
+  else
+  {
+    rpcSlice->setNumEntryPointOffsets ( 0 );
+  }
 
-      READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets );
-      if (numEntryPointOffsets>0)
-      {
-        READ_UVLC(offsetLenMinus1, "offset_len_minus1");
-      }
-      entryPointOffset = new UInt[numEntryPointOffsets];
-      for (UInt idx=0; idx<numEntryPointOffsets; idx++)
-      {
-        READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset");
-        entryPointOffset[ idx ] = uiCode;
-      }
+  if(pps->getSliceHeaderExtensionPresentFlag())
+  {
+    READ_UVLC(uiCode,"slice_header_extension_length");
+    for(Int i=0; i<uiCode; i++)
+    {
+      UInt ignore;
+      READ_CODE(8,ignore,"slice_header_extension_data_byte");
+    }
+  }
+  m_pcBitstream->readByteAlignment();
 
-      if ( pps->getTilesEnabledFlag() )
-      {
-        rpcSlice->setTileLocationCount( numEntryPointOffsets );
+  if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() )
+  {
+    Int endOfSliceHeaderLocation = m_pcBitstream->getByteLocation();
+    Int  curEntryPointOffset     = 0;
+    Int  prevEntryPointOffset    = 0;
+    for (UInt idx=0; idx<numEntryPointOffsets; idx++)
+    {
+      curEntryPointOffset += entryPointOffset[ idx ];
 
-        UInt prevPos = 0;
-        for (Int idx=0; idx<rpcSlice->getTileLocationCount(); idx++)
-        {
-          rpcSlice->setTileLocation( idx, prevPos + entryPointOffset [ idx ] );
-          prevPos += entryPointOffset[ idx ];
-        }
-      }
-      else if ( pps->getEntropyCodingSyncEnabledFlag() )
+      Int emulationPreventionByteCount = 0;
+      for ( UInt curByteIdx  = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
       {
-      Int numSubstreams = rpcSlice->getNumEntryPointOffsets()+1;
-        rpcSlice->allocSubstreamSizes(numSubstreams);
-        UInt *pSubstreamSizes       = rpcSlice->getSubstreamSizes();
-        for (Int idx=0; idx<numSubstreams-1; idx++)
+        if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) >= ( prevEntryPointOffset + endOfSliceHeaderLocation ) && 
+             m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) <  ( curEntryPointOffset  + endOfSliceHeaderLocation ) )
         {
-          if ( idx < numEntryPointOffsets )
-          {
-            pSubstreamSizes[ idx ] = ( entryPointOffset[ idx ] << 3 ) ;
-          }
-          else
-          {
-            pSubstreamSizes[ idx ] = 0;
-          }
+          emulationPreventionByteCount++;
         }
       }
 
-      if (entryPointOffset)
+      entryPointOffset[ idx ] -= emulationPreventionByteCount;
+      prevEntryPointOffset = curEntryPointOffset;
+    }
+
+    if ( pps->getTilesEnabledFlag() )
+    {
+      rpcSlice->setTileLocationCount( numEntryPointOffsets );
+
+      UInt prevPos = 0;
+      for (Int idx=0; idx<rpcSlice->getTileLocationCount(); idx++)
       {
-        delete [] entryPointOffset;
+        rpcSlice->setTileLocation( idx, prevPos + entryPointOffset [ idx ] );
+        prevPos += entryPointOffset[ idx ];
       }
     }
-    else
+    else if ( pps->getEntropyCodingSyncEnabledFlag() )
     {
-      rpcSlice->setNumEntryPointOffsets ( 0 );
+      Int numSubstreams = rpcSlice->getNumEntryPointOffsets()+1;
+      rpcSlice->allocSubstreamSizes(numSubstreams);
+      UInt *pSubstreamSizes       = rpcSlice->getSubstreamSizes();
+      for (Int idx=0; idx<numSubstreams-1; idx++)
+      {
+        if ( idx < numEntryPointOffsets )
+        {
+          pSubstreamSizes[ idx ] = ( entryPointOffset[ idx ] << 3 ) ;
+        }
+        else
+        {
+          pSubstreamSizes[ idx ] = 0;
+        }
+      }
     }
 
-  if(pps->getSliceHeaderExtensionPresentFlag())
-  {
-    READ_UVLC(uiCode,"slice_header_extension_length");
-    for(Int i=0; i<uiCode; i++)
+    if (entryPointOffset)
     {
-      UInt ignore;
-      READ_CODE(8,ignore,"slice_header_extension_data_byte");
+      delete [] entryPointOffset;
     }
   }
-  m_pcBitstream->readByteAlignment();
+
   return;
 }
   

Lib/TLibEncoder/TEncGOP.cpp

@@ -1158 +1158 @@
               }
               if (ui+1 < pcSlice->getPPS()->getNumSubstreams())
               {
-                puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits();
+
+                UInt uiCounter = 0;
+                vector<uint8_t>& rbsp   = pcSubstreamsOut[ui].getFIFO();
+                for (vector<uint8_t>::iterator it = rbsp.begin(); it != rbsp.end();)
+                {
+                  /* 1) find the next emulated 00 00 {00,01,02,03}
+                   * 2a) if not found, write all remaining bytes out, stop.
+                   * 2b) otherwise, write all non-emulated bytes out
+                   * 3) insert emulation_prevention_three_byte
+                   */
+                  vector<uint8_t>::iterator found = it;
+                  do
+                  {
+                    /* NB, end()-1, prevents finding a trailing two byte sequence */
+                    found = search_n(found, rbsp.end()-1, 2, 0);
+                    found++;
+                    /* if not found, found == end, otherwise found = second zero byte */
+                    if (found == rbsp.end())
+                    {
+                      break;
+                    }
+                    if (*(++found) <= 3)
+                    {
+                      break;
+                    }
+                  } while (true);
+                  it = found;
+                  if (found != rbsp.end())
+                  {
+                    it++;
+                    uiCounter++;
+                  }
+                }
+                puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits() + (uiCounter<<3);
               }
             }