void SingleItemTypeReferenceBox::parseBox(BitStream& bitstr)
{
parseBoxHeader(bitstr); // parent box
mFromItemId = bitstr.read16Bits();
const uint16_t referenceCount = bitstr.read16Bits();
for (unsigned int i = 0; i < referenceCount; ++i)
{
mToItemIds.push_back(bitstr.read16Bits());
}
}
void VideoMediaHeaderBox::parseBox(BitStream& bitstr)
{
BitStream subBitstr;
// First parse the box header
parseFullBoxHeader(bitstr);
bitstr.read16Bits(); // graphicsmode = 0
bitstr.read16Bits(); // opcolor = {0, 0, 0}
bitstr.read16Bits();
bitstr.read16Bits();
}
ImageOverlay parseImageOverlay(BitStream& input)
{
ImageOverlay iovl;
input.read8Bits(); // discard version
bool read32BitFields = input.read8Bits() & 1;
iovl.canvasFillValueR = input.read16Bits();
iovl.canvasFillValueG = input.read16Bits();
iovl.canvasFillValueB = input.read16Bits();
iovl.canvasFillValueA = input.read16Bits();
if (read32BitFields)
{
iovl.outputWidth = input.read32Bits();
iovl.outputHeight = input.read32Bits();
}
else
{
iovl.outputWidth = input.read16Bits();
iovl.outputHeight = input.read16Bits();
}
// Read as many offsets as there is. This should match to number of relevant 'dimg' references, but it is
// not feasible to verify it during reading.
while (input.getPos() < input.getSize())
{
ImageOverlay::Offset offsets;
if (read32BitFields)
{
offsets.horizontalOffset = static_cast<std::int32_t>(input.read32Bits());
offsets.verticalOffset = static_cast<std::int32_t>(input.read32Bits());
}
else
{
offsets.horizontalOffset = static_cast<std::int16_t>(input.read16Bits());
offsets.verticalOffset = static_cast<std::int16_t>(input.read16Bits());
}
iovl.offsets.push_back(offsets);
}
return iovl;
}
void PrimaryItemBox::parseBox(BitStream& bitstr)
{
parseFullBoxHeader(bitstr);
if (getVersion() == 0)
{
mItemId = bitstr.read16Bits();
}
else
{
mItemId = bitstr.read32Bits();
}
}
ImageGrid parseImageGrid(BitStream& input)
{
ImageGrid grid;
input.read8Bits(); // discard version
bool read32BitFields = input.read8Bits() & 1; // flags
grid.rowsMinusOne = input.read8Bits();
grid.columnsMinusOne = input.read8Bits();
if (read32BitFields)
{
grid.outputWidth = input.read32Bits();
grid.outputHeight = input.read32Bits();
}
else
{
grid.outputWidth = input.read16Bits();
grid.outputHeight = input.read16Bits();
}
return grid;
}
void ElementaryStreamDescriptorBox::parseBox(BitStream& bitstr)
{
parseFullBoxHeader(bitstr);
//////////////////////////////////////////////
// Fill in struct ES_Descriptor //
//////////////////////////////////////////////
mES_Descriptor.ES_DescrTag = bitstr.read8Bits();
if (mES_Descriptor.ES_DescrTag != 3) // ES_DescrTag
{
throw RuntimeError("ElementaryStreamDescritorBox ES_Descriptor.ES_DescrTag not valid");
}
/* Expandable class... need to find out size based on (from ISO/IEC 14496-1)
* int sizeOfInstance = 0;
* bit(1) nextByte;
* bit(7) sizeOfInstance;
* while(nextByte) {
* bit(1) nextByte;
* bit(7) sizeByte;
* sizeOfInstance = sizeOfInstance<<7 | sizeByte; }
*/
std::uint8_t readByte = 0;
std::uint32_t size = 0;
do
{
readByte = bitstr.read8Bits();
std::uint8_t sizeByte = (readByte & 0x7F);
size = (size << 7) | sizeByte;
} while (readByte & 0x80);
mES_Descriptor.size = size;
mES_Descriptor.ES_ID = bitstr.read16Bits();
mES_Descriptor.flags = bitstr.read8Bits();
if (mES_Descriptor.flags & 0x80) // streamDependenceFlag as defined in 7.2.6.5.1 of ISO/IEC 14486-1:2010(E)
{
mES_Descriptor.dependsOn_ES_ID = bitstr.read16Bits();
}
if (mES_Descriptor.flags & 0x40) // URL_Flag as defined in 7.2.6.5.1 of ISO/IEC 14486-1:2010(E)
{
mES_Descriptor.URLlength = bitstr.read8Bits();
if (mES_Descriptor.URLlength)
{
bitstr.readStringWithLen(mES_Descriptor.URLstring, mES_Descriptor.URLlength);
}
}
if (mES_Descriptor.flags & 0x20) // OCRstreamFlag as defined in 7.2.6.5.1 of ISO/IEC 14486-1:2010(E)
{
mES_Descriptor.OCR_ES_Id = bitstr.read16Bits();
}
//////////////////////////////////////////////////////////////////
// Fill in struct ES_Descriptor.DecoderConfigDescriptor //
//////////////////////////////////////////////////////////////////
mES_Descriptor.decConfigDescr.DecoderConfigDescrTag = bitstr.read8Bits();
if (mES_Descriptor.decConfigDescr.DecoderConfigDescrTag != 4) // DecoderConfigDescrTag
{
throw RuntimeError("ElementaryStreamDescritorBox DecoderConfigDescriptor.DecoderConfigDescrTag not valid");
}
readByte = 0;
size = 0;
do
{
readByte = bitstr.read8Bits();
std::uint8_t sizeByte = (readByte & 0x7f);
size = (size << 7) | sizeByte;
} while (readByte & 0x80);
mES_Descriptor.decConfigDescr.size = size;
mES_Descriptor.decConfigDescr.objectTypeIndication = bitstr.read8Bits();
mES_Descriptor.decConfigDescr.streamType = (bitstr.read8Bits() >> 2);
mES_Descriptor.decConfigDescr.bufferSizeDB = bitstr.read24Bits();
mES_Descriptor.decConfigDescr.maxBitrate = bitstr.read32Bits();
mES_Descriptor.decConfigDescr.avgBitrate = bitstr.read32Bits();
/////////////////////////////////////////////////////////////////////////////////////
// Fill in struct ES_Descriptor.DecoderConfigDescriptor.DecoderSpecificInfo //
/////////////////////////////////////////////////////////////////////////////////////
while (bitstr.numBytesLeft()) // DecoderSpecificInfo is optional.
{
std::uint8_t tag = bitstr.read8Bits();
readByte = 0;
size = 0;
do
{
readByte = bitstr.read8Bits();
std::uint8_t sizeByte = (readByte & 0x7f);
size = (size << 7) | sizeByte;
} while (readByte & 0x80);
DecoderSpecificInfo decSpecificInfo;
decSpecificInfo.DecSpecificInfoTag = tag;
decSpecificInfo.size = size;
bitstr.read8BitsArray(decSpecificInfo.DecSpecificInfo, decSpecificInfo.size);
if (tag == 5) // DecSpecificInfoTag
{
mES_Descriptor.decConfigDescr.decSpecificInfo = std::move(decSpecificInfo);
}
else
{
mOtherDecSpecificInfo.push_back(std::move(decSpecificInfo));
}
}
}