void CompositionOffsetBox::writeBox(BitStream& bitstr)
{
// Write box headers
writeFullBoxHeader(bitstr);
if (mEntryVersion0.empty() == false)
{
bitstr.write32Bits(mEntryVersion0.size());
for (const auto& entry : mEntryVersion0)
{
bitstr.write32Bits(entry.mSampleCount);
bitstr.write32Bits(entry.mSampleOffset);
}
}
else if (mEntryVersion1.empty() == false)
{
bitstr.write32Bits(mEntryVersion1.size());
for (const auto& entry : mEntryVersion1)
{
bitstr.write32Bits(entry.mSampleCount);
bitstr.write32Bits(static_cast<std::uint32_t>(entry.mSampleOffset));
}
}
else
{
throw std::runtime_error("Can not write an empty CompositionOffsetBox.");
}
// Update the size of the movie box
updateSize(bitstr);
}
void ImageSpatialExtentsProperty::writeBox(BitStream& output)
{
writeFullBoxHeader(output);
output.write32Bits(mImageWidth);
output.write32Bits(mImageHeight);
updateSize(output);
}
void CodingConstraintsBox::writeBox(BitStream& bitstr)
{
writeFullBoxHeader(bitstr);
bitstr.writeBits(mAllRefPicsIntra, 1);
bitstr.writeBits(mIntraPredUsed, 1);
bitstr.writeBits(mMaxRefPicUsed, 4);
bitstr.writeBits(0, 26); // reserved int(26)
updateSize(bitstr);
}
void ItemReferenceBox::writeBox(BitStream& bitstr)
{
writeFullBoxHeader(bitstr); // parent box
for (auto& i : mReferenceList)
{
i.writeBox(bitstr);
}
updateSize(bitstr);
}
void PrimaryItemBox::writeBox(BitStream& bitstr)
{
writeFullBoxHeader(bitstr);
if (getVersion() == 0)
{
bitstr.write16Bits(mItemId);
}
else
{
bitstr.write32Bits(mItemId);
}
updateSize(bitstr);
}
void VideoMediaHeaderBox::writeBox(BitStream& bitstr)
{
// Write box headers
writeFullBoxHeader(bitstr);
bitstr.write16Bits(0); // graphicsmode = 0
bitstr.write16Bits(0); // opcolor = {0, 0, 0}
bitstr.write16Bits(0);
bitstr.write16Bits(0);
// Update the size of the movie box
updateSize(bitstr);
}
void TrackHeaderBox::writeBox(ISOBMFF::BitStream& bitstr) const
{
// Write box headers
writeFullBoxHeader(bitstr);
if (getVersion() == 0)
{
bitstr.write32Bits(static_cast<uint32_t>(mCreationTime));
bitstr.write32Bits(static_cast<uint32_t>(mModificationTime));
bitstr.write32Bits(mTrackID);
bitstr.write32Bits(0);
bitstr.write32Bits(static_cast<uint32_t>(mDuration));
}
else if (getVersion() == 1)
{
bitstr.write64Bits(mCreationTime);
bitstr.write64Bits(mModificationTime);
bitstr.write32Bits(mTrackID);
bitstr.write32Bits(0);
bitstr.write64Bits(mDuration);
}
else
{
throw RuntimeError("TrackHeaderBox::writeBox() supports only 'tkhd' version 0 and version 1");
}
bitstr.write32Bits(0); // Reserved
bitstr.write32Bits(0);
bitstr.write16Bits(0); // Layer
bitstr.write16Bits(mAlternateGroup); // Alternate Group
bitstr.write16Bits(mVolume); // Volume
bitstr.write16Bits(0); // Reserved
for (auto value : mMatrix)
{
bitstr.write32Bits(static_cast<uint32_t>(value));
}
bitstr.write32Bits(mWidth);
bitstr.write32Bits(mHeight);
updateSize(bitstr);
}
void MetaBox::writeBox(ISOBMFF::BitStream& bitstr) const
{
writeFullBoxHeader(bitstr);
mHandlerBox.writeBox(bitstr);
mPrimaryItemBox.writeBox(bitstr);
// The optional 'dinf' is currently not used, so it is not written:
// mDataInformationBox.writeBox(bitstr);
mItemLocationBox.writeBox(bitstr);
mItemProtectionBox.writeBox(bitstr);
mItemInfoBox.writeBox(bitstr);
// Not writing optional box IPMPControlBox
mItemReferenceBox.writeBox(bitstr);
mItemDataBox.writeBox(bitstr);
mItemPropertiesBox.writeBox(bitstr);
mGroupsListBox.writeBox(bitstr);
updateSize(bitstr);
}
void ElementaryStreamDescriptorBox::writeBox(BitStream& bitstr) const
{
writeFullBoxHeader(bitstr);
bitstr.write8Bits(mES_Descriptor.ES_DescrTag);
bool esSizeConverged = false;
std::uint64_t esSizeSize;
std::uint32_t esDescriptorSize = mES_Descriptor.size;
BitStream esBitstr;
/* Write the whole stuff, then figure out if we wrote the correct
* size for it (we allos mES_Descriptor to be incorrect); rewrite
* everything with the correct size. However, this may increase
* the size due to bigger size having been written and thus moving
* the remaining of the data forward, so we may need to loop even
* thrice. */
while (!esSizeConverged)
{
esBitstr.clear();
esSizeSize = writeSize(esBitstr, esDescriptorSize);
esBitstr.write16Bits(mES_Descriptor.ES_ID);
esBitstr.write8Bits(mES_Descriptor.flags);
if (mES_Descriptor.flags & 0x80) // streamDependenceFlag as defined in 7.2.6.5.1 of ISO/IEC 14486-1:2010(E)
{
esBitstr.write16Bits(mES_Descriptor.dependsOn_ES_ID);
}
if (mES_Descriptor.flags & 0x40) // URL_Flag as defined in 7.2.6.5.1 of ISO/IEC 14486-1:2010(E)
{
esBitstr.write8Bits(mES_Descriptor.URLlength);
if (mES_Descriptor.URLlength)
{
esBitstr.writeString(mES_Descriptor.URLstring);
}
}
if (mES_Descriptor.flags & 0x20) // OCRstreamFlag as defined in 7.2.6.5.1 of ISO/IEC 14486-1:2010(E)
{
esBitstr.write16Bits(mES_Descriptor.OCR_ES_Id);
}
esBitstr.write8Bits(mES_Descriptor.decConfigDescr.DecoderConfigDescrTag);
BitStream decConfigBitstr;
std::uint64_t decConfigSize = mES_Descriptor.decConfigDescr.size;
std::uint64_t decConfigSizeSize;
bool decConfigSizeConverged = false;
while (!decConfigSizeConverged)
{
decConfigBitstr.clear();
decConfigSizeSize = writeSize(decConfigBitstr, static_cast<uint32_t>(decConfigSize));
decConfigBitstr.write8Bits(mES_Descriptor.decConfigDescr.objectTypeIndication);
decConfigBitstr.write8Bits((mES_Descriptor.decConfigDescr.streamType << 2) | 0x01);
decConfigBitstr.write24Bits(mES_Descriptor.decConfigDescr.bufferSizeDB);
decConfigBitstr.write32Bits(mES_Descriptor.decConfigDescr.maxBitrate);
decConfigBitstr.write32Bits(mES_Descriptor.decConfigDescr.avgBitrate);
if (mES_Descriptor.decConfigDescr.decSpecificInfo.DecSpecificInfoTag == 5)
{
writeDecoderSpecificInfo(decConfigBitstr, mES_Descriptor.decConfigDescr.decSpecificInfo);
}
for (const auto& decSpecificInfo : mOtherDecSpecificInfo)
{
writeDecoderSpecificInfo(decConfigBitstr, decSpecificInfo);
}
decConfigSizeConverged = decConfigBitstr.getSize() == std::uint64_t(decConfigSize) + decConfigSizeSize;
if (!decConfigSizeConverged)
{
decConfigSize = decConfigBitstr.getSize() - decConfigSizeSize;
}
}
esBitstr.writeBitStream(decConfigBitstr);
esSizeConverged = esBitstr.getSize() == std::uint64_t(esDescriptorSize) + esSizeSize;
if (!esSizeConverged)
{
esDescriptorSize = std::uint32_t(esBitstr.getSize() - esSizeSize);
}
}
bitstr.writeBitStream(esBitstr);
updateSize(bitstr);
}
