justdan96
/
tsMuxer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Clang format check

master
jcdr428 2022-01-20 22:52:26 +01:00
parent 94387a101d
commit fc3c668097
13 changed files with 213 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

324
tsMuxer/combinedH264Demuxer.cpp
View File

@ -107,188 +107,186 @@ CombinedH264Reader::ReadState CombinedH264Reader::detectStreamByNal(const uint8_
}
}
void CombinedH264Reader::fillPids(const PIDSet& acceptedPIDs, int pid)
void CombinedH264Reader::fillPids(const PIDSet& acceptedPIDs, int pid)
{
m_mvcStreamIndex = SubTrackFilter::pidToSubPid(pid, MVC_STREAM_INDEX);
m_avcStreamIndex = SubTrackFilter::pidToSubPid(pid, AVC_STREAM_INDEX);
if (acceptedPIDs.find(m_mvcStreamIndex) == acceptedPIDs.end())
m_mvcStreamIndex = -1;
if (acceptedPIDs.find(m_avcStreamIndex) == acceptedPIDs.end())
m_avcStreamIndex = -1;
}
// --------------------------------------------- CombinedH264Demuxer ---------------------------
CombinedH264Demuxer::CombinedH264Demuxer(const BufferedReaderManager& readManager, const char* streamName)
: CombinedH264Reader(), AbstractDemuxer(), m_readManager(readManager)
{
m_bufferedReader = (const_cast<BufferedReaderManager&>(m_readManager)).getReader(streamName);
m_readerID = m_bufferedReader->createReader(MAX_TMP_BUFFER_SIZE);
if (m_bufferedReader == 0)
THROW(ERR_COMMON,
"TS demuxer can't accept reader because this reader does not support BufferedReader interface");
m_lastReadRez = 0;
m_dataProcessed = 0;
}
CombinedH264Demuxer::~CombinedH264Demuxer() { m_bufferedReader->deleteReader(m_readerID); }
void CombinedH264Demuxer::getTrackList(std::map<uint32_t, TrackInfo>& trackList)
{
trackList.insert(std::make_pair(MVC_STREAM_INDEX, TrackInfo(CODEC_V_MPEG4_H264_DEP, "", 0)));
trackList.insert(std::make_pair(AVC_STREAM_INDEX, TrackInfo(CODEC_V_MPEG4_H264, "", 0)));
}
int CombinedH264Demuxer::simpleDemuxBlock(DemuxedData& demuxedData, const PIDSet& acceptedPIDs, int64_t& discardSize)
{
if (m_firstDemuxCall)
{
m_mvcStreamIndex = SubTrackFilter::pidToSubPid(pid, MVC_STREAM_INDEX);
m_avcStreamIndex = SubTrackFilter::pidToSubPid(pid, AVC_STREAM_INDEX);
if (acceptedPIDs.find(m_mvcStreamIndex) == acceptedPIDs.end())
m_mvcStreamIndex = -1;
if (acceptedPIDs.find(m_avcStreamIndex) == acceptedPIDs.end())
m_avcStreamIndex = -1;
fillPids(acceptedPIDs, 0);
m_firstDemuxCall = false;
}
// --------------------------------------------- CombinedH264Demuxer ---------------------------
discardSize = 0;
CombinedH264Demuxer::CombinedH264Demuxer(const BufferedReaderManager& readManager, const char* streamName)
: CombinedH264Reader(), AbstractDemuxer(), m_readManager(readManager)
uint32_t readedBytes;
int readRez = 0;
bool isFirstBlock = false;
uint8_t* data = m_bufferedReader->readBlock(m_readerID, readedBytes, readRez, &isFirstBlock); // blocked read mode
if (readRez == BufferedFileReader::DATA_NOT_READY)
{
m_bufferedReader = (const_cast<BufferedReaderManager&>(m_readManager)).getReader(streamName);
m_readerID = m_bufferedReader->createReader(MAX_TMP_BUFFER_SIZE);
if (m_bufferedReader == 0)
THROW(ERR_COMMON,
"TS demuxer can't accept reader because this reader does not support BufferedReader interface");
m_lastReadRez = 0;
m_dataProcessed = 0;
}
CombinedH264Demuxer::~CombinedH264Demuxer() { m_bufferedReader->deleteReader(m_readerID); }
void CombinedH264Demuxer::getTrackList(std::map<uint32_t, TrackInfo> & trackList)
{
trackList.insert(std::make_pair(MVC_STREAM_INDEX, TrackInfo(CODEC_V_MPEG4_H264_DEP, "", 0)));
trackList.insert(std::make_pair(AVC_STREAM_INDEX, TrackInfo(CODEC_V_MPEG4_H264, "", 0)));
}
int CombinedH264Demuxer::simpleDemuxBlock(DemuxedData & demuxedData, const PIDSet& acceptedPIDs,
int64_t& discardSize)
{
if (m_firstDemuxCall)
{
fillPids(acceptedPIDs, 0);
m_firstDemuxCall = false;
}
discardSize = 0;
uint32_t readedBytes;
int readRez = 0;
bool isFirstBlock = false;
uint8_t* data =
m_bufferedReader->readBlock(m_readerID, readedBytes, readRez, &isFirstBlock); // blocked read mode
if (readRez == BufferedFileReader::DATA_NOT_READY)
{
m_lastReadRez = readRez;
return BufferedFileReader::DATA_NOT_READY;
}
if (readedBytes + m_tmpBuffer.size() == 0 || (readedBytes == 0 && m_lastReadRez == BufferedReader::DATA_EOF))
{
m_lastReadRez = readRez;
return BufferedReader::DATA_EOF;
}
if (readedBytes > 0)
m_bufferedReader->notify(m_readerID, readedBytes);
m_lastReadRez = readRez;
data += MAX_TMP_BUFFER_SIZE;
uint8_t* dataEnd = data + readedBytes;
if (m_tmpBuffer.size() > 0)
{
data -= m_tmpBuffer.size();
memcpy(data, m_tmpBuffer.data(), m_tmpBuffer.size());
m_tmpBuffer.clear();
}
const uint8_t* curNal = data;
return BufferedFileReader::DATA_NOT_READY;
}
const uint8_t* nextNal = NALUnit::findNALWithStartCode(curNal + 3, dataEnd, true);
while (curNal < dataEnd - 4)
if (readedBytes + m_tmpBuffer.size() == 0 || (readedBytes == 0 && m_lastReadRez == BufferedReader::DATA_EOF))
{
m_lastReadRez = readRez;
return BufferedReader::DATA_EOF;
}
if (readedBytes > 0)
m_bufferedReader->notify(m_readerID, readedBytes);
m_lastReadRez = readRez;
data += MAX_TMP_BUFFER_SIZE;
uint8_t* dataEnd = data + readedBytes;
if (m_tmpBuffer.size() > 0)
{
data -= m_tmpBuffer.size();
memcpy(data, m_tmpBuffer.data(), m_tmpBuffer.size());
m_tmpBuffer.clear();
}
const uint8_t* curNal = data;
const uint8_t* nextNal = NALUnit::findNALWithStartCode(curNal + 3, dataEnd, true);
while (curNal < dataEnd - 4)
{
int prefixLen = getPrefixLen(curNal, dataEnd);
if (prefixLen != 0)
{
int prefixLen = getPrefixLen(curNal, dataEnd);
if (prefixLen != 0)
m_state = detectStreamByNal(curNal + prefixLen, nextNal);
if (m_state == ReadState::NeedMoreData)
{
m_state = detectStreamByNal(curNal + prefixLen, nextNal);
if (m_state == ReadState::NeedMoreData)
if (dataEnd - curNal < MAX_TMP_BUFFER_SIZE)
{
if (dataEnd - curNal < MAX_TMP_BUFFER_SIZE)
{
m_tmpBuffer.append(curNal, dataEnd - curNal);
return 0;
}
else
{
// some error in a stream, just ignore
m_state = ReadState::Primary;
}
m_tmpBuffer.append(curNal, dataEnd - curNal);
return 0;
}
else
{
// some error in a stream, just ignore
m_state = ReadState::Primary;
}
}
if (m_state == ReadState::Both)
{
addDataToPrimary(curNal, nextNal, demuxedData, discardSize);
addDataToSecondary(curNal, nextNal, demuxedData, discardSize);
}
else if (m_state == ReadState::Primary)
addDataToPrimary(curNal, nextNal, demuxedData, discardSize);
else
addDataToSecondary(curNal, nextNal, demuxedData, discardSize);
curNal = nextNal;
nextNal = NALUnit::findNALWithStartCode(curNal + 3, dataEnd, true);
}
if (curNal < dataEnd)
if (m_state == ReadState::Both)
{
if (m_lastReadRez == BufferedReader::DATA_EOF)
{
if (m_state == ReadState::Primary)
addDataToPrimary(curNal, dataEnd, demuxedData, discardSize);
else
addDataToSecondary(curNal, dataEnd, demuxedData, discardSize);
}
else
{
m_tmpBuffer.append(curNal, dataEnd - curNal);
}
addDataToPrimary(curNal, nextNal, demuxedData, discardSize);
addDataToSecondary(curNal, nextNal, demuxedData, discardSize);
}
return 0;
else if (m_state == ReadState::Primary)
addDataToPrimary(curNal, nextNal, demuxedData, discardSize);
else
addDataToSecondary(curNal, nextNal, demuxedData, discardSize);
curNal = nextNal;
nextNal = NALUnit::findNALWithStartCode(curNal + 3, dataEnd, true);
}
void CombinedH264Demuxer::openFile(const std::string& streamName)
if (curNal < dataEnd)
{
readClose();
BufferedFileReader* fileReader = dynamic_cast<BufferedFileReader*>(m_bufferedReader);
if (!m_bufferedReader->openStream(m_readerID, streamName.c_str()))
THROW(ERR_FILE_NOT_FOUND, "Can't open stream " << streamName);
m_dataProcessed = 0;
}
void CombinedH264Demuxer::readClose() {}
uint64_t CombinedH264Demuxer::getDemuxedSize() { return m_dataProcessed; }
void CombinedH264Demuxer::setFileIterator(FileNameIterator * itr)
{
BufferedFileReader* br = dynamic_cast<BufferedFileReader*>(m_bufferedReader);
if (br)
br->setFileIterator(itr, m_readerID);
else if (itr != 0)
THROW(ERR_COMMON, "Can not set file iterator. Reader does not support bufferedReader interface.");
}
// ------------------------------ CombinedH264Filter -----------------------------------
CombinedH264Filter::CombinedH264Filter(int demuxedPID) : CombinedH264Reader(), SubTrackFilter(demuxedPID) {}
int CombinedH264Filter::demuxPacket(DemuxedData & demuxedData, const PIDSet& acceptedPIDs, AVPacket& avPacket)
{
if (m_firstDemuxCall)
if (m_lastReadRez == BufferedReader::DATA_EOF)
{
fillPids(acceptedPIDs, m_srcPID);
m_firstDemuxCall = false;
}
const uint8_t* curNal = avPacket.data;
const uint8_t* dataEnd = avPacket.data + avPacket.size;
const uint8_t* nextNal = NALUnit::findNALWithStartCode(curNal + 3, dataEnd, true);
int64_t discardSize = 0;
while (curNal < dataEnd - 4)
{
int prefixLen = getPrefixLen(curNal, dataEnd);
if (prefixLen != 0)
m_state = detectStreamByNal(curNal + prefixLen, nextNal);
if (m_state == ReadState::Both)
{
addDataToPrimary(curNal, nextNal, demuxedData, discardSize);
addDataToSecondary(curNal, nextNal, demuxedData, discardSize);
}
else if (m_state == ReadState::Primary)
addDataToPrimary(curNal, nextNal, demuxedData, discardSize);
if (m_state == ReadState::Primary)
addDataToPrimary(curNal, dataEnd, demuxedData, discardSize);
else
addDataToSecondary(curNal, nextNal, demuxedData, discardSize);
curNal = nextNal;
nextNal = NALUnit::findNALWithStartCode(curNal + 3, dataEnd, true);
addDataToSecondary(curNal, dataEnd, demuxedData, discardSize);
}
else
{
m_tmpBuffer.append(curNal, dataEnd - curNal);
}
return avPacket.size - (int)discardSize;
}
return 0;
}
void CombinedH264Demuxer::openFile(const std::string& streamName)
{
readClose();
BufferedFileReader* fileReader = dynamic_cast<BufferedFileReader*>(m_bufferedReader);
if (!m_bufferedReader->openStream(m_readerID, streamName.c_str()))
THROW(ERR_FILE_NOT_FOUND, "Can't open stream " << streamName);
m_dataProcessed = 0;
}
void CombinedH264Demuxer::readClose() {}
uint64_t CombinedH264Demuxer::getDemuxedSize() { return m_dataProcessed; }
void CombinedH264Demuxer::setFileIterator(FileNameIterator* itr)
{
BufferedFileReader* br = dynamic_cast<BufferedFileReader*>(m_bufferedReader);
if (br)
br->setFileIterator(itr, m_readerID);
else if (itr != 0)
THROW(ERR_COMMON, "Can not set file iterator. Reader does not support bufferedReader interface.");
}
// ------------------------------ CombinedH264Filter -----------------------------------
CombinedH264Filter::CombinedH264Filter(int demuxedPID) : CombinedH264Reader(), SubTrackFilter(demuxedPID) {}
int CombinedH264Filter::demuxPacket(DemuxedData& demuxedData, const PIDSet& acceptedPIDs, AVPacket& avPacket)
{
if (m_firstDemuxCall)
{
fillPids(acceptedPIDs, m_srcPID);
m_firstDemuxCall = false;
}
const uint8_t* curNal = avPacket.data;
const uint8_t* dataEnd = avPacket.data + avPacket.size;
const uint8_t* nextNal = NALUnit::findNALWithStartCode(curNal + 3, dataEnd, true);
int64_t discardSize = 0;
while (curNal < dataEnd - 4)
{
int prefixLen = getPrefixLen(curNal, dataEnd);
if (prefixLen != 0)
m_state = detectStreamByNal(curNal + prefixLen, nextNal);
if (m_state == ReadState::Both)
{
addDataToPrimary(curNal, nextNal, demuxedData, discardSize);
addDataToSecondary(curNal, nextNal, demuxedData, discardSize);
}
else if (m_state == ReadState::Primary)
addDataToPrimary(curNal, nextNal, demuxedData, discardSize);
else
addDataToSecondary(curNal, nextNal, demuxedData, discardSize);
curNal = nextNal;
nextNal = NALUnit::findNALWithStartCode(curNal + 3, dataEnd, true);
}
return avPacket.size - (int)discardSize;
}

4
tsMuxer/dtsStreamReader.cpp
View File

@ -77,7 +77,7 @@ int DTSStreamReader::getTSDescriptor(uint8_t* dstBuff, bool blurayMode, bool hdm
// ETSI TS 101 154 F.4.2 DTS registration descriptor
*dstBuff++ = (int)TSDescriptorTag::REGISTRATION; // descriptor tag
*dstBuff++ = 4; // descriptor length
*dstBuff++ = 4; // descriptor length
*dstBuff++ = 'D';
*dstBuff++ = 'T';
*dstBuff++ = 'S';
@ -101,7 +101,7 @@ int DTSStreamReader::getTSDescriptor(uint8_t* dstBuff, bool blurayMode, bool hdm
BitStreamWriter bitWriter{};
*dstBuff++ = (uint8_t)TSDescriptorTag::DTS; // descriptor tag;
*dstBuff++ = 5; // descriptor length
*dstBuff++ = 5; // descriptor length
bitWriter.setBuffer(dstBuff, dstBuff + 5);
bitWriter.putBits(4, pi_sample_rate_index);
bitWriter.putBits(6, pi_bit_rate_index);

10
tsMuxer/hevc.cpp
View File

@ -50,8 +50,9 @@ int HevcUnit::deserialize()
nal_unit_type = (NalType)m_reader.getBits(6);
nuh_layer_id = m_reader.getBits(6);
nuh_temporal_id_plus1 = m_reader.getBits(3);
if (nuh_temporal_id_plus1 == 0 || (nuh_temporal_id_plus1 != 1 && (nal_unit_type == HevcUnit::NalType::VPS ||
nal_unit_type == HevcUnit::NalType::SPS ||
if (nuh_temporal_id_plus1 == 0 ||
(nuh_temporal_id_plus1 != 1 &&
(nal_unit_type == HevcUnit::NalType::VPS || nal_unit_type == HevcUnit::NalType::SPS ||
nal_unit_type == HevcUnit::NalType::EOS || nal_unit_type == HevcUnit::NalType::EOB)))
return 1;
return 0;
@ -917,7 +918,10 @@ int HevcSliceHeader::deserialize(const HevcSpsUnit* sps, const HevcPpsUnit* pps)
}
}
bool HevcSliceHeader::isIDR() const { return nal_unit_type == NalType::IDR_W_RADL || nal_unit_type == NalType::IDR_N_LP; }
bool HevcSliceHeader::isIDR() const
{
return nal_unit_type == NalType::IDR_W_RADL || nal_unit_type == NalType::IDR_N_LP;
}
vector<vector<uint8_t>> hevc_extract_priv_data(const uint8_t* buff, int size, int* nal_size)
{

51
tsMuxer/iso_writer.cpp
View File

@ -140,9 +140,7 @@ std::vector<std::uint8_t> serializeDString(const std::string& str, size_t fieldL
if (canUse8BitUnicode(utf8Str))
{
rv.push_back(8);
IterateUTF8Chars(utf8Str,
[&](auto c)
{
IterateUTF8Chars(utf8Str, [&](auto c) {
rv.push_back(c);
return rv.size() < maxHeaderAndContentLength;
});
@ -150,25 +148,23 @@ std::vector<std::uint8_t> serializeDString(const std::string& str, size_t fieldL
else
{
rv.push_back(16);
IterateUTF8Chars(utf8Str,
[&](auto c)
{
UTF16 high_surrogate, low_surrogate;
std::tie(high_surrogate, low_surrogate) = ConvertUTF32toUTF16(c);
auto spaceLeft = maxHeaderAndContentLength - rv.size();
if ((spaceLeft < 2) || (low_surrogate && spaceLeft < 4))
{
return false;
}
rv.push_back((uint8_t)(high_surrogate >> 8));
rv.push_back((uint8_t)high_surrogate);
if (low_surrogate)
{
rv.push_back((uint8_t)(low_surrogate >> 8));
rv.push_back((uint8_t)low_surrogate);
}
return true;
});
IterateUTF8Chars(utf8Str, [&](auto c) {
UTF16 high_surrogate, low_surrogate;
std::tie(high_surrogate, low_surrogate) = ConvertUTF32toUTF16(c);
auto spaceLeft = maxHeaderAndContentLength - rv.size();
if ((spaceLeft < 2) || (low_surrogate && spaceLeft < 4))
{
return false;
}
rv.push_back((uint8_t)(high_surrogate >> 8));
rv.push_back((uint8_t)high_surrogate);
if (low_surrogate)
{
rv.push_back((uint8_t)(low_surrogate >> 8));
rv.push_back((uint8_t)low_surrogate);
}
return true;
});
}
auto contentLength = (uint8_t)rv.size();
auto paddingSize = maxHeaderAndContentLength - rv.size();
@ -332,10 +328,7 @@ FileEntryInfo::FileEntryInfo(IsoWriter* owner, FileEntryInfo* parent, uint32_t o
m_sectorBuffer = 0;
}
bool FileEntryInfo::isFile() const
{
return m_fileType == FileTypes::File || m_fileType == FileTypes::RealtimeFile;
}
bool FileEntryInfo::isFile() const { return m_fileType == FileTypes::File || m_fileType == FileTypes::RealtimeFile; }
FileEntryInfo::~FileEntryInfo()
{
@ -881,8 +874,7 @@ void IsoWriter::close()
m_file.seek(1024 * 576);
// metadata file location and length (located at 576K, point to 640K address)
m_tagLocationBaseAddr = m_partitionStartAddress;
writeExtentFileDescriptor(0, 0, FileTypes::Metadata, m_metadataFileLen,
m_metadataLBN - m_partitionStartAddress, 0);
writeExtentFileDescriptor(0, 0, FileTypes::Metadata, m_metadataFileLen, m_metadataLBN - m_partitionStartAddress, 0);
m_tagLocationBaseAddr = m_metadataLBN; // Don't know why. Doing just as scenarist does
writeMetadata(m_metadataLBN);
@ -949,8 +941,7 @@ void IsoWriter::writeEntity(FileEntryInfo* dir)
int IsoWriter::allocateEntity(FileEntryInfo* entity, int sectorNum)
{
if ((entity->m_fileType == FileTypes::File || entity->m_fileType == FileTypes::RealtimeFile) &&
entity->m_objectId)
if ((entity->m_fileType == FileTypes::File || entity->m_fileType == FileTypes::RealtimeFile) && entity->m_objectId)
m_totalFiles++;
else if (entity->m_fileType == FileTypes::Directory)
m_totalDirectories++;

4
tsMuxer/main.cpp
View File

@ -724,8 +724,8 @@ int main(int argc, char** argv)
DiskType dt = checkBluRayMux(argv[1], autoChapterLen, customChapterList, firstMplsOffset, firstM2tsOffset,
insertBlankPL, blankNum, stereoMode, isoDiskLabel);
std::string fileExt2 = unquoteStr(fileExt);
bool muxMode = fileExt2 == "M2TS" || fileExt2 == "TS" || fileExt2 == "SSIF" || fileExt2 == "ISO" ||
dt != DiskType::NONE;
bool muxMode =
fileExt2 == "M2TS" || fileExt2 == "TS" || fileExt2 == "SSIF" || fileExt2 == "ISO" || dt != DiskType::NONE;
if (muxMode)
{

12
tsMuxer/matroskaDemuxer.cpp
View File

@ -2134,12 +2134,12 @@ int MatroskaDemuxer::matroska_add_stream()
if ((res = ebml_read_uint(&id, &num)) < 0)
break;
if (num != (uint64_t)MatroskaEyeMode::MONO && num != (uint64_t)MatroskaEyeMode::LEFT &&
num != (uint64_t)MatroskaEyeMode::RIGHT && num != (uint64_t)MatroskaEyeMode::BOTH)
{
LTRACE(LT_INFO, 0, "Ignoring unknown eye mode " << (uint32_t)num);
break;
}
if (num != (uint64_t)MatroskaEyeMode::MONO && num != (uint64_t)MatroskaEyeMode::LEFT &&
num != (uint64_t)MatroskaEyeMode::RIGHT && num != (uint64_t)MatroskaEyeMode::BOTH)
{
LTRACE(LT_INFO, 0, "Ignoring unknown eye mode " << (uint32_t)num);
break;
}
videotrack->eye_mode = (MatroskaEyeMode)num;
break;
}

6
tsMuxer/movDemuxer.cpp
View File

@ -794,9 +794,9 @@ void MovDemuxer::getTrackList(std::map<uint32_t, TrackInfo>& trackList)
for (int i = 0; i < num_tracks; i++)
{
if (tracks[i]->type != IOContextTrackType::CONTROL)
trackList.insert(std::make_pair(
i + 1, TrackInfo(tracks[i]->type == IOContextTrackType::SUBTITLE ? TRACKTYPE_SRT : 0,
tracks[i]->language, 0)));
trackList.insert(
std::make_pair(i + 1, TrackInfo(tracks[i]->type == IOContextTrackType::SUBTITLE ? TRACKTYPE_SRT : 0,
tracks[i]->language, 0)));
}
}

2
tsMuxer/mpeg2StreamReader.cpp
View File

@ -50,7 +50,7 @@ int MPEG2StreamReader::getTSDescriptor(uint8_t* dstBuff, bool blurayMode, bool h
// HDMV registration descriptor
*dstBuff++ = (uint8_t)TSDescriptorTag::HDMV; // registration descriptor tag
*dstBuff++ = 8; // descriptor length
*dstBuff++ = 8; // descriptor length
memcpy(dstBuff, "HDMV\xff", 5);
dstBuff += 5;

5
tsMuxer/nalUnits.cpp
View File

@ -263,7 +263,7 @@ int NALUnit::deserialize(uint8_t* buffer, uint8_t* end)
}
nal_ref_idc = (*buffer >> 5) & 0x3;
nal_unit_type = (NALType)( * buffer & 0x1f);
nal_unit_type = (NALType)(*buffer & 0x1f);
return 0;
}
@ -1219,8 +1219,7 @@ void SliceUnit::nal_unit_header_mvc_extension()
bool SliceUnit::isIDR() const
{
return nal_unit_type == NALType::nuSliceIDR ||
nal_unit_type == NALType::nuSliceExt && !non_idr_flag;
return nal_unit_type == NALType::nuSliceIDR || nal_unit_type == NALType::nuSliceExt && !non_idr_flag;
}
bool SliceUnit::isIFrame() const

8
tsMuxer/textSubtitles.cpp
View File

@ -389,8 +389,8 @@ uint8_t* TextToPGSConverter::doConvert(std::string& text, const TextAnimation& a
m_paletteID = 0;
m_paletteVersion = 0;
curPos += composePresentationSegment(curPos, CompositionMode::Start, inTimePTS,
inTimePTS - PRESENTATION_DTS_DELTA, objectWindowTop, true, forced);
curPos += composePresentationSegment(curPos, CompositionMode::Start, inTimePTS, inTimePTS - PRESENTATION_DTS_DELTA,
objectWindowTop, true, forced);
curPos += composeWindowDefinition(curPos, inTimePTS - windowsTransferTime, inTimePTS - PRESENTATION_DTS_DELTA,
objectWindowTop, objectWindowHeight);
curPos += composePaletteDefinition(buildPalette(toCurve(opacity)), curPos, inTimePTS - PRESENTATION_DTS_DELTA,
@ -465,8 +465,8 @@ long TextToPGSConverter::composePresentationSegment(uint8_t* buff, CompositionMo
curPos += composeVideoDescriptor(curPos);
curPos += composeCompositionDescriptor(curPos, m_composition_number++,
mode == CompositionMode::Start ? EPOTH_START : EPOTH_NORMAL);
*curPos++ = palette_update_flag << 7; // palette_update_flag = 0 and 7 reserved bits
*curPos++ = m_paletteID; // paletteID ref
*curPos++ = palette_update_flag << 7; // palette_update_flag = 0 and 7 reserved bits
*curPos++ = m_paletteID; // paletteID ref
*curPos++ = mode != CompositionMode::Finish ? 1 : 0; // number_of_composition_objects
// composition object
if (mode != CompositionMode::Finish)

2
tsMuxer/vc1Parser.cpp
View File

@ -173,7 +173,7 @@ int VC1SequenceHeader::decode_sequence_header()
}
}
bitReader.skipBits(8); // frmrtq_postproc, bitrtq_postproc
bitReader.skipBits(8); // frmrtq_postproc, bitrtq_postproc
if (bitReader.getBit() && profile == Profile::SIMPLE) // loop_filter
LTRACE(LT_WARN, 0, "LOOPFILTER shell not be enabled in simple profile");
if (bitReader.getBit()) // reserved res_x8

5
tsMuxer/vvc.cpp
View File

@ -50,9 +50,8 @@ int VvcUnit::deserialize()
nal_unit_type = (NalType)m_reader.getBits(5);
nuh_temporal_id_plus1 = m_reader.getBits(3);
if (nuh_temporal_id_plus1 == 0 ||
(nuh_temporal_id_plus1 != 1 &&
((nal_unit_type >= NalType::OPI && nal_unit_type <= NalType::SPS) ||
nal_unit_type == NalType::EOS || nal_unit_type == NalType::EOB)))
(nuh_temporal_id_plus1 != 1 && ((nal_unit_type >= NalType::OPI && nal_unit_type <= NalType::SPS) ||
nal_unit_type == NalType::EOS || nal_unit_type == NalType::EOB)))
return 1;
return 0;
}

2
tsMuxer/vvcStreamReader.cpp
View File

@ -119,7 +119,7 @@ int VVCStreamReader::getTSDescriptor(uint8_t* dstBuff, bool blurayMode, bool hdm
if (hdmvDescriptors)
{
*dstBuff++ = (uint8_t)TSDescriptorTag::HDMV; // descriptor tag
*dstBuff++ = 8; // descriptor length
*dstBuff++ = 8; // descriptor length
memcpy(dstBuff, "HDMV\xff", 5);
dstBuff += 5;