diff --git a/source/App/BitstreamExtractorApp/BitstreamExtractorApp.cpp b/source/App/BitstreamExtractorApp/BitstreamExtractorApp.cpp
index bf0ba9d37357dd0170061b69ca7624a26b3cd97a..22591bd24018ff8a9e6b985db7f32882f91fead6 100644
--- a/source/App/BitstreamExtractorApp/BitstreamExtractorApp.cpp
+++ b/source/App/BitstreamExtractorApp/BitstreamExtractorApp.cpp
@@ -902,7 +902,7 @@ uint32_t BitstreamExtractorApp::decode()
// create output NAL unit
OutputNALUnit out (nalu.m_nalUnitType, nalu.m_nuhLayerId, nalu.m_temporalId);
- out.m_bitstream.getFIFO() = nalu.getBitstream().getFifo();
+ out.m_bitstream.getFifo() = nalu.getBitstream().getFifo();
// write with start code emulation prevention
writeNaluContent (bitstreamFileOut, out);
}
diff --git a/source/App/StreamMergeApp/StreamMergeApp.cpp b/source/App/StreamMergeApp/StreamMergeApp.cpp
index 1f6811a7e6b4ab0f56963fa560e51a6f3e8b39cb..1c02691f06ed09ce6e92656861f50cd19eca88c8 100644
--- a/source/App/StreamMergeApp/StreamMergeApp.cpp
+++ b/source/App/StreamMergeApp/StreamMergeApp.cpp
@@ -523,7 +523,7 @@ void StreamMergeApp::decodeAndRewriteNalu(MergeLayer &layer, InputNALUnit &inNal
msg(INFO, " with index %i", inNalu.m_nalUnitType);
// Copy payload from input nalu to output nalu. Code copied from SubpicMergeApp::copyInputNaluToOutputNalu().
vector<uint8_t> &inFifo = inNalu.getBitstream().getFifo();
- vector<uint8_t> &outFifo = outNalu.m_bitstream.getFIFO();
+ vector<uint8_t> &outFifo = outNalu.m_bitstream.getFifo();
outFifo = vector<uint8_t>(inFifo.begin() + 2, inFifo.end());
break;
}
diff --git a/source/App/SubpicMergeApp/SubpicMergeApp.cpp b/source/App/SubpicMergeApp/SubpicMergeApp.cpp
index fc6864f7cad69c8977c73db2d36f96c8c8cb0bdc..a738eaae7092209185b861bdd2dfe84e13fc1d28 100644
--- a/source/App/SubpicMergeApp/SubpicMergeApp.cpp
+++ b/source/App/SubpicMergeApp/SubpicMergeApp.cpp
@@ -812,7 +812,7 @@ void SubpicMergeApp::copyInputNaluToOutputNalu(OutputNALUnit &outNalu, InputNALU
// Copy payload
std::vector<uint8_t> &inFifo = inNalu.getBitstream().getFifo();
- std::vector<uint8_t> &outFifo = outNalu.m_bitstream.getFIFO();
+ std::vector<uint8_t> &outFifo = outNalu.m_bitstream.getFifo();
outFifo = std::vector<uint8_t>(inFifo.begin() + 2, inFifo.end());
}
@@ -941,7 +941,7 @@ void SubpicMergeApp::generateMergedPic(ParameterSetManager &psManager, bool mixe
OutputNALUnit nalu(NAL_UNIT_VPS);
hlsWriter.setBitstream(&nalu.m_bitstream);
hlsWriter.codeVPS(vps);
- psManager.storeVPS(vps, nalu.m_bitstream.getFIFO());
+ psManager.storeVPS(vps, nalu.m_bitstream.getFifo());
accessUnit.push_back(new NALUnitEBSP(nalu));
}
@@ -953,7 +953,7 @@ void SubpicMergeApp::generateMergedPic(ParameterSetManager &psManager, bool mixe
OutputNALUnit nalu(NAL_UNIT_SPS);
hlsWriter.setBitstream(&nalu.m_bitstream);
hlsWriter.codeSPS(sps);
- psManager.storeSPS(sps, nalu.m_bitstream.getFIFO());
+ psManager.storeSPS(sps, nalu.m_bitstream.getFifo());
accessUnit.push_back(new NALUnitEBSP(nalu));
}
@@ -975,7 +975,7 @@ void SubpicMergeApp::generateMergedPic(ParameterSetManager &psManager, bool mixe
OutputNALUnit nalu(NAL_UNIT_PPS);
hlsWriter.setBitstream(&nalu.m_bitstream);
hlsWriter.codePPS(pps);
- psManager.storePPS(pps, nalu.m_bitstream.getFIFO());
+ psManager.storePPS(pps, nalu.m_bitstream.getFifo());
accessUnit.push_back(new NALUnitEBSP(nalu));
if (mixedNaluFlag)
@@ -985,7 +985,7 @@ void SubpicMergeApp::generateMergedPic(ParameterSetManager &psManager, bool mixe
ppsMixed->setPPSId(ppsMixed->getPPSId() + MIXED_NALU_PPS_OFFSET);
ppsMixed->setMixedNaluTypesInPicFlag(true);
hlsWriter.codePPS(ppsMixed);
- psManager.storePPS(ppsMixed, naluMixed.m_bitstream.getFIFO());
+ psManager.storePPS(ppsMixed, naluMixed.m_bitstream.getFifo());
accessUnit.push_back(new NALUnitEBSP(naluMixed));
}
}
diff --git a/source/Lib/CommonLib/BitStream.cpp b/source/Lib/CommonLib/BitStream.cpp
index 1df93d32a0717152d3e99585ad9ffdb31ed472f1..1bbcf5d6bbcb997992bf9ea18af5ec48fd0be743 100644
--- a/source/Lib/CommonLib/BitStream.cpp
+++ b/source/Lib/CommonLib/BitStream.cpp
@@ -59,23 +59,17 @@ OutputBitstream::~OutputBitstream()
{
}
-
InputBitstream::InputBitstream()
-: m_fifo()
-, m_emulationPreventionByteLocation()
-, m_fifo_idx(0)
-, m_num_held_bits(0)
-, m_held_bits(0)
-, m_numBitsRead(0)
+ : m_fifo(), m_emulationPreventionByteLocation(), m_fifoIdx(0), m_numHeldBits(0), m_heldBits(0), m_numBitsRead(0)
{ }
InputBitstream::InputBitstream(const InputBitstream &src)
-: m_fifo(src.m_fifo)
-, m_emulationPreventionByteLocation(src.m_emulationPreventionByteLocation)
-, m_fifo_idx(src.m_fifo_idx)
-, m_num_held_bits(src.m_num_held_bits)
-, m_held_bits(src.m_held_bits)
-, m_numBitsRead(src.m_numBitsRead)
+ : m_fifo(src.m_fifo)
+ , m_emulationPreventionByteLocation(src.m_emulationPreventionByteLocation)
+ , m_fifoIdx(src.m_fifoIdx)
+ , m_numHeldBits(src.m_numHeldBits)
+ , m_heldBits(src.m_heldBits)
+ , m_numBitsRead(src.m_numBitsRead)
{ }
// ====================================================================================================================
@@ -84,16 +78,13 @@ InputBitstream::InputBitstream(const InputBitstream &src)
void InputBitstream::resetToStart()
{
- m_fifo_idx=0;
- m_num_held_bits=0;
- m_held_bits=0;
- m_numBitsRead=0;
+ m_fifoIdx = 0;
+ m_numHeldBits = 0;
+ m_heldBits = 0;
+ m_numBitsRead = 0;
}
-uint8_t* OutputBitstream::getByteStream() const
-{
- return (uint8_t*) &m_fifo.front();
-}
+const uint8_t *OutputBitstream::getByteStream() const { return m_fifo.data(); }
uint32_t OutputBitstream::getByteStreamLength()
{
@@ -103,70 +94,74 @@ uint32_t OutputBitstream::getByteStreamLength()
void OutputBitstream::clear()
{
m_fifo.clear();
- m_held_bits = 0;
- m_num_held_bits = 0;
+ m_heldBits = 0;
+ m_numHeldBits = 0;
}
void OutputBitstream::write(uint32_t bits, uint32_t numberOfBits)
{
- CHECK(numberOfBits > 32, "Number of bits is exceeds '32'");
- CHECK(numberOfBits != 32 && (bits & (~0u << numberOfBits)) != 0, "Unsupported parameters");
+ CHECK(numberOfBits > BITS_PER_WORD, "Number of bits is exceeds '32'");
+ CHECK(numberOfBits != BITS_PER_WORD && (bits & (~0u << numberOfBits)) != 0, "Unsupported parameters");
- /* any modulo 8 remainder of num_total_bits cannot be written this time,
+ /* any modulo 8 remainder of numTotalBits cannot be written this time,
* and will be held until next time. */
- uint32_t num_total_bits = numberOfBits + m_num_held_bits;
- uint32_t next_num_held_bits = num_total_bits % 8;
-
- /* form a byte aligned word (write_bits), by concatenating any held bits
- * with the new bits, discarding the bits that will form the next_held_bits.
- * eg: H = held bits, V = n new bits /---- next_held_bits
- * len(H)=7, len(V)=1: ... ---- HHHH HHHV . 0000 0000, next_num_held_bits=0
- * len(H)=7, len(V)=2: ... ---- HHHH HHHV . V000 0000, next_num_held_bits=1
+ uint32_t numTotalBits = numberOfBits + m_numHeldBits;
+ uint32_t nextNumHeldBits = numTotalBits % BITS_PER_BYTE;
+
+ /* form a byte aligned word (writeBits), by concatenating any held bits
+ * with the new bits, discarding the bits that will form the nextHeldBits.
+ * eg: H = held bits, V = n new bits /---- nextHeldBits
+ * len(H)=7, len(V)=1: ... ---- HHHH HHHV . 0000 0000, nextNumHeldBits=0
+ * len(H)=7, len(V)=2: ... ---- HHHH HHHV . V000 0000, nextNumHeldBits=1
* if total_bits < 8, the value of v_ is not used */
- uint8_t next_held_bits = bits << (8 - next_num_held_bits);
+ uint8_t nextHeldBits = bits << (BITS_PER_BYTE - nextNumHeldBits);
- if (!(num_total_bits >> 3))
+ if (numTotalBits < BITS_PER_BYTE)
{
/* insufficient bits accumulated to write out, append new_held_bits to
* current held_bits */
/* NB, this requires that v only contains 0 in bit positions {31..n} */
- m_held_bits |= next_held_bits;
- m_num_held_bits = next_num_held_bits;
+ m_heldBits |= nextHeldBits;
+ m_numHeldBits = nextNumHeldBits;
return;
}
/* topword serves to justify held_bits to align with the msb of bits */
- uint32_t topword = (numberOfBits - next_num_held_bits) & ~((1 << 3) - 1);
- uint32_t write_bits = (m_held_bits << topword) | (bits >> next_num_held_bits);
+ uint32_t topword = (numberOfBits - nextNumHeldBits) & ~BITS_PER_BYTE_MASK;
+ uint32_t writeBits = (m_heldBits << topword) | (bits >> nextNumHeldBits);
- switch (num_total_bits >> 3)
+ switch (numTotalBits >> BITS_PER_BYTE_LOG2)
{
- case 4: m_fifo.push_back(write_bits >> 24);
- case 3: m_fifo.push_back(write_bits >> 16);
- case 2: m_fifo.push_back(write_bits >> 8);
- case 1: m_fifo.push_back(write_bits);
+ case 4:
+ m_fifo.push_back(writeBits >> 3 * BITS_PER_BYTE);
+ case 3:
+ m_fifo.push_back(writeBits >> 2 * BITS_PER_BYTE);
+ case 2:
+ m_fifo.push_back(writeBits >> BITS_PER_BYTE);
+ case 1:
+ m_fifo.push_back(writeBits);
}
- m_held_bits = next_held_bits;
- m_num_held_bits = next_num_held_bits;
+ m_heldBits = nextHeldBits;
+ m_numHeldBits = nextNumHeldBits;
}
void OutputBitstream::writeAlignOne()
{
- uint32_t num_bits = getNumBitsUntilByteAligned();
- write((1 << num_bits) - 1, num_bits);
+ const uint32_t numBits = getNumBitsUntilByteAligned();
+ write((1 << numBits) - 1, numBits);
return;
}
void OutputBitstream::writeAlignZero()
{
- if (0 == m_num_held_bits)
+ if (0 == m_numHeldBits)
{
return;
}
- m_fifo.push_back(m_held_bits);
- m_held_bits = 0;
- m_num_held_bits = 0;
+ m_fifo.push_back(m_heldBits);
+ m_heldBits = 0;
+ m_numHeldBits = 0;
}
/**
@@ -176,29 +171,32 @@ void OutputBitstream::writeAlignZero()
*/
void OutputBitstream::addSubstream( OutputBitstream* pcSubstream )
{
- uint32_t uiNumBits = pcSubstream->getNumberOfWrittenBits();
+ uint32_t numBits = pcSubstream->getNumberOfWrittenBits();
- const vector<uint8_t>& rbsp = pcSubstream->getFIFO();
- for (vector<uint8_t>::const_iterator it = rbsp.begin(); it != rbsp.end();)
+ const vector<uint8_t> &rbsp = pcSubstream->getFifo();
+ for (const uint8_t byte: rbsp)
{
- write(*it++, 8);
+ write(byte, BITS_PER_BYTE);
}
- if (uiNumBits&0x7)
+
+ const uint32_t numTrailingBits = numBits & BITS_PER_BYTE_MASK;
+
+ if (numTrailingBits != 0)
{
- write(pcSubstream->getHeldBits()>>(8-(uiNumBits&0x7)), uiNumBits&0x7);
+ write(pcSubstream->getHeldBits() >> (BITS_PER_BYTE - numTrailingBits), numTrailingBits);
}
}
void OutputBitstream::writeByteAlignment()
{
- write( 1, 1);
+ write(1, 1);
writeAlignZero();
}
int OutputBitstream::countStartCodeEmulations()
{
uint32_t cnt = 0;
- vector<uint8_t>& rbsp = getFIFO();
+ vector<uint8_t> &rbsp = getFifo();
for (vector<uint8_t>::iterator it = rbsp.begin(); it != rbsp.end();)
{
vector<uint8_t>::iterator found = it;
@@ -229,43 +227,43 @@ int OutputBitstream::countStartCodeEmulations()
/**
* read numberOfBits from bitstream without updating the bitstream
- * state, storing the result in ruiBits.
+ * state, storing the result in bits.
*
* If reading numberOfBits would overrun the bitstream buffer,
* the bitstream is effectively padded with sufficient zero-bits to
* avoid the overrun.
*/
-void InputBitstream::pseudoRead(uint32_t numberOfBits, uint32_t &ruiBits)
+void InputBitstream::pseudoRead(uint32_t numberOfBits, uint32_t &bits)
{
- uint32_t saved_num_held_bits = m_num_held_bits;
- uint8_t saved_held_bits = m_held_bits;
- uint32_t saved_fifo_idx = m_fifo_idx;
+ uint32_t savedNumHeldBits = m_numHeldBits;
+ uint8_t savedHeldBits = m_heldBits;
+ uint32_t savedFifoIdx = m_fifoIdx;
- uint32_t num_bits_to_read = min(numberOfBits, getNumBitsLeft());
- read(num_bits_to_read, ruiBits);
- ruiBits <<= (numberOfBits - num_bits_to_read);
+ uint32_t numBitsToRead = min(numberOfBits, getNumBitsLeft());
+ read(numBitsToRead, bits);
+ bits <<= (numberOfBits - numBitsToRead);
- m_fifo_idx = saved_fifo_idx;
- m_held_bits = saved_held_bits;
- m_num_held_bits = saved_num_held_bits;
+ m_fifoIdx = savedFifoIdx;
+ m_heldBits = savedHeldBits;
+ m_numHeldBits = savedNumHeldBits;
}
void InputBitstream::read(uint32_t numberOfBits, uint32_t &ruiBits)
{
- CHECK(numberOfBits > 32, "Too many bits read");
+ CHECK(numberOfBits > BITS_PER_WORD, "Too many bits read");
m_numBitsRead += numberOfBits;
/* NB, bits are extracted from the MSB of each byte. */
uint32_t retval = 0;
- if (numberOfBits <= m_num_held_bits)
+ if (numberOfBits <= m_numHeldBits)
{
/* n=1, len(H)=7: -VHH HHHH, shift_down=6, mask=0xfe
* n=3, len(H)=7: -VVV HHHH, shift_down=4, mask=0xf8
*/
- retval = m_held_bits >> (m_num_held_bits - numberOfBits);
- retval &= ~(0xff << numberOfBits);
- m_num_held_bits -= numberOfBits;
+ retval = m_heldBits >> (m_numHeldBits - numberOfBits);
+ retval &= ~(BYTE_MASK << numberOfBits);
+ m_numHeldBits -= numberOfBits;
ruiBits = retval;
return;
}
@@ -275,8 +273,8 @@ void InputBitstream::read(uint32_t numberOfBits, uint32_t &ruiBits)
* => align retval with top of extracted word */
/* n=5, len(H)=3: ---- -VVV, mask=0x07, shift_up=5-3=2,
* n=9, len(H)=3: ---- -VVV, mask=0x07, shift_up=9-3=6 */
- numberOfBits -= m_num_held_bits;
- retval = m_held_bits & ~(0xff << m_num_held_bits);
+ numberOfBits -= m_numHeldBits;
+ retval = m_heldBits & ~(BYTE_MASK << m_numHeldBits);
retval <<= numberOfBits;
/* number of whole bytes that need to be loaded to form retval */
@@ -287,27 +285,31 @@ void InputBitstream::read(uint32_t numberOfBits, uint32_t &ruiBits)
* n=8, len(H)=3, load 1byte, shift_down=3
* n=5, len(H)=1, load 1byte, shift_down=1+3
*/
- uint32_t aligned_word = 0;
- uint32_t num_bytes_to_load = (numberOfBits - 1) >> 3;
- CHECK(m_fifo_idx + num_bytes_to_load >= m_fifo.size(), "Exceeded FIFO size");
+ uint32_t alignedWord = 0;
+ uint32_t num_bytes_to_load = (numberOfBits - 1) >> BITS_PER_BYTE_LOG2;
+ CHECK(m_fifoIdx + num_bytes_to_load >= m_fifo.size(), "Exceeded FIFO size");
switch (num_bytes_to_load)
{
- case 3: aligned_word = m_fifo[m_fifo_idx++] << 24;
- case 2: aligned_word |= m_fifo[m_fifo_idx++] << 16;
- case 1: aligned_word |= m_fifo[m_fifo_idx++] << 8;
- case 0: aligned_word |= m_fifo[m_fifo_idx++];
+ case 3:
+ alignedWord = m_fifo[m_fifoIdx++] << 3 * BITS_PER_BYTE;
+ case 2:
+ alignedWord |= m_fifo[m_fifoIdx++] << 2 * BITS_PER_BYTE;
+ case 1:
+ alignedWord |= m_fifo[m_fifoIdx++] << BITS_PER_BYTE;
+ case 0:
+ alignedWord |= m_fifo[m_fifoIdx++];
}
/* resolve remainder bits */
- uint32_t next_num_held_bits = (32 - numberOfBits) % 8;
+ uint32_t nextNumHeldBits = (BITS_PER_WORD - numberOfBits) % BITS_PER_BYTE;
- /* copy required part of aligned_word into retval */
- retval |= aligned_word >> next_num_held_bits;
+ /* copy required part of alignedWord into retval */
+ retval |= alignedWord >> nextNumHeldBits;
/* store held bits */
- m_num_held_bits = next_num_held_bits;
- m_held_bits = aligned_word;
+ m_numHeldBits = nextNumHeldBits;
+ m_heldBits = alignedWord;
ruiBits = retval;
}
@@ -318,80 +320,72 @@ void InputBitstream::read(uint32_t numberOfBits, uint32_t &ruiBits)
*/
void OutputBitstream::insertAt(const OutputBitstream& src, uint32_t pos)
{
- CHECK(0 != src.getNumberOfWrittenBits() % 8, "Number of written bits is not a multiple of 8");
+ CHECK(0 != src.getNumberOfWrittenBits() % BITS_PER_BYTE, "Number of written bits is not a multiple of 8");
- vector<uint8_t>::iterator at = m_fifo.begin() + pos;
- m_fifo.insert(at, src.m_fifo.begin(), src.m_fifo.end());
+ m_fifo.insert(m_fifo.begin() + pos, src.m_fifo.begin(), src.m_fifo.end());
}
uint32_t InputBitstream::readOutTrailingBits ()
{
- uint32_t count=0;
- uint32_t bits = 0;
+ uint32_t count = 0;
+ uint32_t bits = 0;
- while ( ( getNumBitsLeft() > 0 ) && (getNumBitsUntilByteAligned()!=0) )
+ while (getNumBitsLeft() > 0 && getNumBitsUntilByteAligned() != 0)
{
count++;
read(1, bits);
}
return count;
}
-//
-//OutputBitstream& OutputBitstream::operator= (const OutputBitstream& src)
-//{
-// vector<uint8_t>::iterator at = m_fifo.begin();
-// m_fifo.insert(at, src.m_fifo.begin(), src.m_fifo.end());
-//
-// m_num_held_bits = src.m_num_held_bits;
-// m_held_bits = src.m_held_bits;
-//
-// return *this;
-//}
/**
Extract substream from the current bitstream.
- \param uiNumBits number of bits to transfer
+ \param numBits number of bits to transfer
*/
-InputBitstream *InputBitstream::extractSubstream( uint32_t uiNumBits )
+InputBitstream *InputBitstream::extractSubstream(uint32_t numBits)
{
- uint32_t uiNumBytes = uiNumBits/8;
+ uint32_t numBytes = numBits / BITS_PER_BYTE;
InputBitstream *pResult = new InputBitstream;
std::vector<uint8_t> &buf = pResult->getFifo();
- buf.reserve((uiNumBits+7)>>3);
+ buf.reserve((numBits + BITS_PER_BYTE_MASK) >> BITS_PER_BYTE_LOG2);
- if (m_num_held_bits == 0)
+ if (m_numHeldBits == 0)
{
- std::size_t currentOutputBufferSize=buf.size();
- const uint32_t uiNumBytesToReadFromFifo = std::min<uint32_t>(uiNumBytes, (uint32_t)m_fifo.size() - m_fifo_idx);
- buf.resize(currentOutputBufferSize+uiNumBytes);
+ const size_t currentOutputBufferSize = buf.size();
+ const uint32_t numBytesToReadFromFifo = std::min<uint32_t>(numBytes, (uint32_t) m_fifo.size() - m_fifoIdx);
+ buf.resize(currentOutputBufferSize + numBytes);
if (!buf.empty())
{
- memcpy(&(buf[currentOutputBufferSize]), &(m_fifo[m_fifo_idx]), uiNumBytesToReadFromFifo);
- m_fifo_idx += uiNumBytesToReadFromFifo;
+ std::copy_n(&m_fifo[m_fifoIdx], numBytesToReadFromFifo, &buf[currentOutputBufferSize]);
+ m_fifoIdx += numBytesToReadFromFifo;
}
- if (uiNumBytesToReadFromFifo != uiNumBytes)
+ if (numBytesToReadFromFifo != numBytes)
{
- memset(&(buf[currentOutputBufferSize+uiNumBytesToReadFromFifo]), 0, uiNumBytes - uiNumBytesToReadFromFifo);
+ std::fill_n(&buf[currentOutputBufferSize + numBytesToReadFromFifo], numBytes - numBytesToReadFromFifo, 0);
}
}
else
{
- for (uint32_t ui = 0; ui < uiNumBytes; ui++)
+ for (uint32_t i = 0; i < numBytes; i++)
{
- uint32_t uiByte;
- read(8, uiByte);
- buf.push_back(uiByte);
+ uint32_t byte;
+ read(BITS_PER_BYTE, byte);
+ buf.push_back(byte);
}
}
- if (uiNumBits&0x7)
+
+ const uint32_t numTrailingBits = numBits & BITS_PER_BYTE_MASK;
+
+ if (numTrailingBits != 0)
{
- uint32_t uiByte = 0;
- read(uiNumBits&0x7, uiByte);
- uiByte <<= 8-(uiNumBits&0x7);
- buf.push_back(uiByte);
+ uint32_t byte = 0;
+ read(numTrailingBits, byte);
+ byte <<= BITS_PER_BYTE - numTrailingBits;
+ buf.push_back(byte);
}
+
return pResult;
}
@@ -401,14 +395,14 @@ uint32_t InputBitstream::readByteAlignment()
read( 1, code );
CHECK(code != 1, "Code is not '1'");
- uint32_t numBits = getNumBitsUntilByteAligned();
- if(numBits)
+ const uint32_t numBits = getNumBitsUntilByteAligned();
+ if (numBits > 0)
{
CHECK(numBits > getNumBitsLeft(), "More bits available than left");
read( numBits, code );
CHECK(code != 0, "Code not '0'");
}
- return numBits+1;
+ return numBits + 1;
}
//! \}
diff --git a/source/Lib/CommonLib/BitStream.h b/source/Lib/CommonLib/BitStream.h
index f17cee742e7e1776f25fafb375a2df46f53ce133..cd91ab4f7ec41b345073eb329f1c3674cbcbc954 100644
--- a/source/Lib/CommonLib/BitStream.h
+++ b/source/Lib/CommonLib/BitStream.h
@@ -50,6 +50,12 @@
//! \ingroup CommonLib
//! \{
+static constexpr int BITS_PER_BYTE_LOG2 = 3;
+static constexpr int BITS_PER_BYTE = 1 << BITS_PER_BYTE_LOG2;
+static constexpr int BITS_PER_BYTE_MASK = BITS_PER_BYTE - 1;
+static constexpr int BITS_PER_WORD = BITS_PER_BYTE * sizeof(uint32_t);
+static constexpr uint32_t BYTE_MASK = (1 << BITS_PER_BYTE) - 1;
+
// ====================================================================================================================
// Class definition
// ====================================================================================================================
@@ -68,9 +74,9 @@ class OutputBitstream
*/
std::vector<uint8_t> m_fifo;
- uint32_t m_num_held_bits; /// number of bits not flushed to bytestream.
- uint8_t m_held_bits; /// the bits held and not flushed to bytestream.
- /// this value is always msb-aligned, bigendian.
+ uint32_t m_numHeldBits; /// number of bits not flushed to bytestream.
+ uint8_t m_heldBits; /// the bits held and not flushed to bytestream.
+ /// this value is always msb-aligned, bigendian.
public:
// create / destroy
OutputBitstream();
@@ -97,7 +103,7 @@ public:
* NB, data is arranged such that subsequent bytes in the
* bytestream are stored in ascending addresses.
*/
- uint8_t* getByteStream() const;
+ const uint8_t *getByteStream() const;
/**
* Return the number of valid bytes available from getByteStream()
@@ -113,25 +119,24 @@ public:
* returns the number of bits that need to be written to
* achieve byte alignment.
*/
- int getNumBitsUntilByteAligned() const { return (8 - m_num_held_bits) & 0x7; }
+ int getNumBitsUntilByteAligned() const { return (8 - m_numHeldBits) & 0x7; }
/**
* Return the number of bits that have been written since the last clear()
*/
- uint32_t getNumberOfWrittenBits() const { return uint32_t(m_fifo.size()) * 8 + m_num_held_bits; }
+ uint32_t getNumberOfWrittenBits() const { return uint32_t(m_fifo.size()) * 8 + m_numHeldBits; }
void insertAt(const OutputBitstream& src, uint32_t pos);
/**
* Return a reference to the internal fifo
*/
- std::vector<uint8_t>& getFIFO() { return m_fifo; }
+ std::vector<uint8_t> &getFifo() { return m_fifo; }
- uint8_t getHeldBits () { return m_held_bits; }
+ uint8_t getHeldBits() { return m_heldBits; }
- //OutputBitstream& operator= (const OutputBitstream& src);
/** Return a reference to the internal fifo */
- const std::vector<uint8_t>& getFIFO() const { return m_fifo; }
+ const std::vector<uint8_t> &getFifo() const { return m_fifo; }
void addSubstream ( OutputBitstream* pcSubstream );
void writeByteAlignment();
@@ -150,10 +155,10 @@ protected:
std::vector<uint8_t> m_fifo; /// FIFO for storage of complete bytes
std::vector<uint32_t> m_emulationPreventionByteLocation;
- uint32_t m_fifo_idx; /// Read index into m_fifo
+ uint32_t m_fifoIdx; /// Read index into m_fifo
- uint32_t m_num_held_bits;
- uint8_t m_held_bits;
+ uint32_t m_numHeldBits;
+ uint8_t m_heldBits;
uint32_t m_numBitsRead;
public:
@@ -167,12 +172,12 @@ public:
void resetToStart();
// interface for decoding
- void pseudoRead(uint32_t numberOfBits, uint32_t &ruiBits);
+ void pseudoRead(uint32_t numberOfBits, uint32_t &bits);
void read(uint32_t numberOfBits, uint32_t &ruiBits);
void readByte ( uint32_t &ruiBits )
{
- CHECK( m_fifo_idx >= m_fifo.size(), "FIFO exceeded" );
- ruiBits = m_fifo[m_fifo_idx++];
+ CHECK(m_fifoIdx >= m_fifo.size(), "FIFO exceeded");
+ ruiBits = m_fifo[m_fifoIdx++];
#if ENABLE_TRACING
m_numBitsRead += 8;
#endif
@@ -180,14 +185,14 @@ public:
void peekPreviousByte( uint32_t &byte )
{
- CHECK( m_fifo_idx == 0, "FIFO empty" );
- byte = m_fifo[m_fifo_idx - 1];
+ CHECK(m_fifoIdx == 0, "FIFO empty");
+ byte = m_fifo[m_fifoIdx - 1];
}
uint32_t readOutTrailingBits ();
- uint8_t getHeldBits () { return m_held_bits; }
+ uint8_t getHeldBits() { return m_heldBits; }
OutputBitstream& operator= (const OutputBitstream& src);
- uint32_t getByteLocation ( ) { return m_fifo_idx ; }
+ uint32_t getByteLocation() { return m_fifoIdx; }
// Peek at bits in word-storage. Used in determining if we have completed reading of current bitstream and therefore slice in LCEC.
uint32_t peekBits(uint32_t bits)
@@ -200,9 +205,9 @@ public:
// utility functions
uint32_t read(uint32_t numberOfBits) { uint32_t tmp; read(numberOfBits, tmp); return tmp; }
uint32_t readByte() { uint32_t tmp; readByte( tmp ); return tmp; }
- uint32_t getNumBitsUntilByteAligned() { return m_num_held_bits & (0x7); }
- uint32_t getNumBitsLeft() { return 8*((uint32_t)m_fifo.size() - m_fifo_idx) + m_num_held_bits; }
- InputBitstream *extractSubstream( uint32_t uiNumBits ); // Read the nominated number of bits, and return as a bitstream.
+ uint32_t getNumBitsUntilByteAligned() { return m_numHeldBits & (0x7); }
+ uint32_t getNumBitsLeft() { return 8 * ((uint32_t) m_fifo.size() - m_fifoIdx) + m_numHeldBits; }
+ InputBitstream *extractSubstream(uint32_t numBits); // Read the nominated number of bits, and return as a bitstream.
uint32_t getNumBitsRead() { return m_numBitsRead; }
uint32_t readByteAlignment();
diff --git a/source/Lib/EncoderLib/NALwrite.cpp b/source/Lib/EncoderLib/NALwrite.cpp
index 3e4887ef24df25fb8daf43935bf8974df0299828..17ea8573691a690274807360ebe95ce190561ba0 100644
--- a/source/Lib/EncoderLib/NALwrite.cpp
+++ b/source/Lib/EncoderLib/NALwrite.cpp
@@ -87,7 +87,7 @@ void writeNaluContent(ostream& out, OutputNALUnit& nalu)
* - 0x00000302
* - 0x00000303
*/
- vector<uint8_t> &rbsp = nalu.m_bitstream.getFIFO();
+ vector<uint8_t> &rbsp = nalu.m_bitstream.getFifo();
vector<uint8_t> outputBuffer;
outputBuffer.resize(rbsp.size()*2+1); //there can never be enough emulation_prevention_three_bytes to require this much space