Tag Parser  9.1.2
C++ library for reading and writing MP4 (iTunes), ID3, Vorbis, Opus, FLAC and Matroska tags
matroskatrack.cpp
Go to the documentation of this file.
1 #include "./matroskatrack.h"
2 #include "./ebmlelement.h"
3 #include "./matroskacontainer.h"
4 #include "./matroskaid.h"
5 #include "./matroskatag.h"
6 
7 #include "../avi/bitmapinfoheader.h"
8 
9 #include "../wav/waveaudiostream.h"
10 
11 #include "../avc/avcconfiguration.h"
12 
13 #include "../mp4/mp4ids.h"
14 #include "../mp4/mp4track.h"
15 
16 #include "../exceptions.h"
17 #include "../mediaformat.h"
18 
19 #include <c++utilities/conversion/stringconversion.h>
20 
21 using namespace std;
22 using namespace CppUtilities;
23 
24 namespace TagParser {
25 
37 MatroskaTrack::MatroskaTrack(EbmlElement &trackElement)
38  : AbstractTrack(trackElement.stream(), trackElement.startOffset())
39  , m_trackElement(&trackElement)
40 {
41 }
42 
47 {
48 }
49 
51 {
53 }
54 
59 {
60  auto parts = splitString<vector<string>>(codecId, "/", EmptyPartsTreat::Keep, 3);
61  parts.resize(3);
62  const auto &part1 = parts[0], &part2 = parts[1], &part3 = parts[2];
63  MediaFormat fmt;
64  if (part1 == "V_MS" && part2 == "VFW" && part3 == "FOURCC") {
66  } else if (part1 == "V_UNCOMPRESSED") {
68  } else if (part1 == "V_MPEG4") {
70  if (part2 == "ISO") {
71  if (part3 == "SP") {
73  } else if (part3 == "ASP") {
75  } else if (part3 == "AVC") {
77  }
78  } else if (part2 == "MS" && part3 == "V3") {
80  }
81  } else if (part1 == "V_MPEG1") {
83  } else if (part1 == "V_MPEG2") {
85  } else if (part1 == "V_REAL") {
87  } else if (part1 == "V_QUICKTIME") {
89  } else if (part1 == "V_THEORA") {
91  } else if (part1 == "V_PRORES") {
93  } else if (part1 == "V_VP8") {
95  } else if (part1 == "V_VP9") {
97  } else if (part1 == "V_AV1") {
99  } else if (part1 == "A_MPEG") {
101  if (part2 == "L1") {
103  } else if (part2 == "L2") {
105  } else if (part2 == "L3") {
107  }
108  } else if (part1 == "V_MPEGH" && part2 == "ISO" && part3 == "HEVC") {
110  } else if (part1 == "A_PCM") {
112  if (part2 == "INT") {
113  if (part3 == "BIG") {
115  } else if (part3 == "LIT") {
117  }
118  } else if (part2 == "FLOAT" && part3 == "IEEE") {
120  }
121  } else if (part1 == "A_MPC") {
123  } else if (part1 == "A_AC3") {
125  } else if (part1 == "A_ALAC") {
127  } else if (part1 == "A_DTS") {
129  if (part2 == "EXPRESS") {
131  } else if (part2 == "LOSSLESS") {
133  }
134  } else if (part1 == "A_VORBIS") {
136  } else if (part1 == "A_FLAC") {
138  } else if (part1 == "A_OPUS") {
140  } else if (part1 == "A_REAL") {
142  } else if (part1 == "A_MS" && part2 == "ACM") {
144  } else if (part1 == "A_AAC") {
146  if (part2 == "MPEG2") {
147  if (part3 == "MAIN") {
149  } else if (part3 == "LC") {
151  } else if (part3 == "SBR") {
154  } else if (part3 == "SSR") {
156  }
157  } else if (part2 == "MPEG4") {
158  if (part3 == "MAIN") {
160  } else if (part3 == "LC") {
162  } else if (part3 == "SBR") {
165  } else if (part3 == "SSR") {
167  } else if (part3 == "LTP") {
169  }
170  }
171  } else if (part1 == "A_QUICKTIME") {
173  } else if (part1 == "A_TTA1") {
175  } else if (part1 == "A_WAVPACK4") {
177  } else if (part1 == "S_TEXT") {
179  if (part2 == "UTF8") {
181  } else if (part2 == "SSA") {
183  } else if (part2 == "ASS") {
185  } else if (part2 == "USF") {
187  } else if (part2 == "WEBVTT") {
189  }
190  } else if (part1 == "S_IMAGE") {
192  if (part2 == "BMP") {
194  }
195  } else if (part1 == "S_VOBSUB") {
197  } else if (part1 == "S_KATE") {
199  } else if (part1 == "B_VOBBTN") {
201  } else if (part1 == "S_DVBSUB") {
203  } else if (part1 == "V_MSWMV") {
205  }
206  return fmt;
207 }
208 
210 
211 template <typename PropertyType, typename ConversionFunction>
212 void MatroskaTrack::assignPropertyFromTagValue(const std::unique_ptr<MatroskaTag> &tag, const char *fieldId, PropertyType &property,
213  const ConversionFunction &conversionFunction, Diagnostics &diag)
214 {
215  const TagValue &value = tag->value(fieldId);
216  if (!value.isEmpty()) {
217  try {
218  property = conversionFunction(value);
219  } catch (const ConversionException &) {
220  string message;
221  try {
222  message = argsToString("Ignoring invalid value \"", value.toString(TagTextEncoding::Utf8), "\" of \"", fieldId, '\"', '.');
223  } catch (const ConversionException &) {
224  message = argsToString("Ignoring invalid value of \"", fieldId, '\"', '.');
225  }
226  diag.emplace_back(DiagLevel::Warning, message, argsToString("reading track statatistic from \"", tag->toString(), '\"'));
227  }
228  }
229 }
230 
231 template <typename NumberType, Traits::EnableIf<std::is_integral<NumberType>> * = nullptr> NumberType tagValueToNumber(const TagValue &tagValue)
232 {
233  // optimization for Latin1/UTF-8 strings
234  if (tagValue.type() == TagDataType::Text) {
235  switch (tagValue.dataEncoding()) {
238  return bufferToNumber<NumberType>(tagValue.dataPointer(), tagValue.dataSize());
239  default:;
240  }
241  }
242  // generic conversion
243  return stringToNumber<NumberType>(tagValue.toString(TagTextEncoding::Utf8));
244 }
245 
246 template <typename NumberType, Traits::EnableIf<std::is_floating_point<NumberType>> * = nullptr>
247 NumberType tagValueToBitrate(const TagValue &tagValue)
248 {
249  return stringToNumber<NumberType>(tagValue.toString(TagTextEncoding::Utf8)) / 1000;
250 }
251 
253 
263 void MatroskaTrack::readStatisticsFromTags(const std::vector<std::unique_ptr<MatroskaTag>> &tags, Diagnostics &diag)
264 {
265  using namespace std::placeholders;
266  using namespace MatroskaTagIds::TrackSpecific;
267  for (const auto &tag : tags) {
268  const TagTarget &target = tag->target();
269  if (find(target.tracks().cbegin(), target.tracks().cend(), id()) == target.tracks().cend()) {
270  continue;
271  }
272  assignPropertyFromTagValue(tag, numberOfBytes(), m_size, &tagValueToNumber<std::uint64_t>, diag);
273  assignPropertyFromTagValue(tag, numberOfFrames(), m_sampleCount, &tagValueToNumber<std::uint64_t>, diag);
274  assignPropertyFromTagValue(tag, MatroskaTagIds::TrackSpecific::duration(), m_duration, bind(&TagValue::toTimeSpan, _1), diag);
275  assignPropertyFromTagValue(tag, MatroskaTagIds::TrackSpecific::bitrate(), m_bitrate, &tagValueToBitrate<double>, diag);
276  assignPropertyFromTagValue(tag, writingDate(), m_modificationTime, bind(&TagValue::toDateTime, _1), diag);
277  if (m_creationTime.isNull()) {
279  }
280  }
281 }
282 
284 {
285  static const string context("parsing header of Matroska track");
286  try {
287  m_trackElement->parse(diag);
288  } catch (const Failure &) {
289  diag.emplace_back(DiagLevel::Critical, "Unable to parse track element.", context);
290  throw;
291  }
292  // read information about the track from the children of the track entry element
293  for (EbmlElement *trackInfoElement = m_trackElement->firstChild(), *subElement = nullptr; trackInfoElement;
294  trackInfoElement = trackInfoElement->nextSibling()) {
295  try {
296  trackInfoElement->parse(diag);
297  } catch (const Failure &) {
298  diag.emplace_back(DiagLevel::Critical, "Unable to parse track information element.", context);
299  break;
300  }
301  std::uint32_t defaultDuration = 0;
302  switch (trackInfoElement->id()) {
304  switch (trackInfoElement->readUInteger()) {
307  break;
310  break;
313  break;
316  break;
319  break;
320  default:
322  }
323  break;
325  for (subElement = trackInfoElement->firstChild(); subElement; subElement = subElement->nextSibling()) {
326  try {
327  subElement->parse(diag);
328  } catch (const Failure &) {
329  diag.emplace_back(DiagLevel::Critical, "Unable to parse video track element.", context);
330  break;
331  }
332  switch (subElement->id()) {
334  m_displaySize.setWidth(subElement->readUInteger());
335  break;
337  m_displaySize.setHeight(subElement->readUInteger());
338  break;
340  m_pixelSize.setWidth(subElement->readUInteger());
341  break;
343  m_pixelSize.setHeight(subElement->readUInteger());
344  break;
346  m_cropping.setTop(subElement->readUInteger());
347  break;
349  m_cropping.setLeft(subElement->readUInteger());
350  break;
352  m_cropping.setBottom(subElement->readUInteger());
353  break;
355  m_cropping.setRight(subElement->readUInteger());
356  break;
358  m_fps = subElement->readFloat();
359  break;
361  m_interlaced = subElement->readUInteger();
362  break;
364  m_colorSpace = subElement->readUInteger();
365  break;
366  default:;
367  }
368  }
369  break;
371  for (subElement = trackInfoElement->firstChild(); subElement; subElement = subElement->nextSibling()) {
372  try {
373  subElement->parse(diag);
374  } catch (const Failure &) {
375  diag.emplace_back(DiagLevel::Critical, "Unable to parse audio track element.", context);
376  break;
377  }
378  switch (subElement->id()) {
380  m_bitsPerSample = subElement->readUInteger();
381  break;
383  m_channelCount = subElement->readUInteger();
384  break;
386  if (!m_samplingFrequency) {
387  m_samplingFrequency = subElement->readFloat();
388  }
389  break;
392  m_extensionSamplingFrequency = subElement->readFloat();
393  }
394  break;
395  default:;
396  }
397  }
398  break;
400  m_trackNumber = trackInfoElement->readUInteger();
401  break;
403  m_id = trackInfoElement->readUInteger();
404  break;
406  m_name = trackInfoElement->readString();
407  break;
409  m_language = trackInfoElement->readString();
410  break;
412  m_format = codecIdToMediaFormat(m_formatId = trackInfoElement->readString());
413  break;
415  m_formatName = trackInfoElement->readString();
416  break;
418  break; // TODO
420  m_enabled = trackInfoElement->readUInteger();
421  break;
423  m_default = trackInfoElement->readUInteger();
424  break;
426  m_forced = trackInfoElement->readUInteger();
427  break;
429  m_lacing = trackInfoElement->readUInteger();
430  break;
432  defaultDuration = trackInfoElement->readUInteger();
433  break;
434  default:;
435  }
436  switch (m_mediaType) {
437  case MediaType::Video:
438  if (!m_fps && defaultDuration) {
439  m_fps = 1000000000.0 / defaultDuration;
440  }
441  break;
442  default:;
443  }
444  }
445 
446  // read further information from the CodecPrivate element for some codecs
447  EbmlElement *codecPrivateElement;
448  switch (m_format.general) {
450  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
451  // parse bitmap info header to determine actual format
452  if (codecPrivateElement->dataSize() >= 0x28) {
453  m_istream->seekg(static_cast<streamoff>(codecPrivateElement->dataOffset()));
454  BitmapInfoHeader bitmapInfoHeader;
455  bitmapInfoHeader.parse(reader());
456  m_formatId.reserve(m_formatId.size() + 7);
457  m_formatId += " \"";
458  m_formatId += interpretIntegerAsString(bitmapInfoHeader.compression);
459  m_formatId += "\"";
461  } else {
462  diag.emplace_back(DiagLevel::Critical, "BITMAPINFOHEADER structure (in \"CodecPrivate\"-element) is truncated.", context);
463  }
464  }
465  break;
467  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
468  // parse WAVE header to determine actual format
469  m_istream->seekg(static_cast<streamoff>(codecPrivateElement->dataOffset()));
470  WaveFormatHeader waveFormatHeader;
471  waveFormatHeader.parse(reader(), codecPrivateElement->dataSize(), diag);
472  WaveAudioStream::addInfo(waveFormatHeader, *this);
473  }
474  break;
476  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
477  auto audioSpecificConfig
478  = Mp4Track::parseAudioSpecificConfig(*m_istream, codecPrivateElement->dataOffset(), codecPrivateElement->dataSize(), diag);
480  audioSpecificConfig->audioObjectType, audioSpecificConfig->sbrPresent, audioSpecificConfig->psPresent);
481  if (audioSpecificConfig->sampleFrequencyIndex == 0xF) {
482  //m_samplingFrequency = audioSpecificConfig->sampleFrequency;
483  } else if (audioSpecificConfig->sampleFrequencyIndex < sizeof(mpeg4SamplingFrequencyTable)) {
484  //m_samplingFrequency = mpeg4SamplingFrequencyTable[audioSpecificConfig->sampleFrequencyIndex];
485  } else {
486  diag.emplace_back(DiagLevel::Warning, "Audio specific config has invalid sample frequency index.", context);
487  }
488  if (audioSpecificConfig->extensionSampleFrequencyIndex == 0xF) {
489  //m_extensionSamplingFrequency = audioSpecificConfig->extensionSampleFrequency;
490  } else if (audioSpecificConfig->extensionSampleFrequencyIndex < sizeof(mpeg4SamplingFrequencyTable)) {
491  //m_extensionSamplingFrequency = mpeg4SamplingFrequencyTable[audioSpecificConfig->extensionSampleFrequencyIndex];
492  } else {
493  diag.emplace_back(DiagLevel::Warning, "Audio specific config has invalid extension sample frequency index.", context);
494  }
495  m_channelConfig = audioSpecificConfig->channelConfiguration;
496  m_extensionChannelConfig = audioSpecificConfig->extensionChannelConfiguration;
497  }
498  break;
500  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
501  auto avcConfig = make_unique<TagParser::AvcConfiguration>();
502  try {
503  m_istream->seekg(static_cast<streamoff>(codecPrivateElement->dataOffset()));
504  avcConfig->parse(m_reader, codecPrivateElement->dataSize(), diag);
505  Mp4Track::addInfo(*avcConfig, *this);
506  } catch (const TruncatedDataException &) {
507  diag.emplace_back(DiagLevel::Critical, "AVC configuration is truncated.", context);
508  } catch (const Failure &) {
509  diag.emplace_back(DiagLevel::Critical, "AVC configuration is invalid.", context);
510  }
511  }
512  break;
513  default:;
514  }
515 
516  // parse format name for unknown formats
518  if (startsWith<string>(m_formatId, "V_") || startsWith<string>(m_formatId, "A_") || startsWith<string>(m_formatId, "S_")) {
519  m_formatName = m_formatId.substr(2);
520  } else {
522  }
523  m_formatName.append(" (unknown)");
524  }
525 
526  // use pixel size as display size if display size not specified
527  if (!m_displaySize.width()) {
529  }
530  if (!m_displaySize.height()) {
532  }
533 
534  // set English if no language has been specified (it is default value of MatroskaIds::TrackLanguage)
535  if (m_language.empty()) {
536  m_language = "eng";
537  }
538 }
539 
551 MatroskaTrackHeaderMaker::MatroskaTrackHeaderMaker(const MatroskaTrack &track, Diagnostics &diag)
552  : m_track(track)
553  , m_dataSize(0)
554 {
555  CPP_UTILITIES_UNUSED(diag);
556 
557  // calculate size for recognized elements
558  m_dataSize += 2 + 1 + EbmlElement::calculateUIntegerLength(m_track.id());
559  m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.trackNumber());
560  m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.isEnabled());
561  m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.isDefault());
562  m_dataSize += 2 + 1 + EbmlElement::calculateUIntegerLength(m_track.isForced());
563  if (!m_track.name().empty()) {
564  m_dataSize += 2 + EbmlElement::calculateSizeDenotationLength(m_track.name().size()) + m_track.name().size();
565  }
566  if (!m_track.language().empty()) {
567  m_dataSize += 3 + EbmlElement::calculateSizeDenotationLength(m_track.language().size()) + m_track.language().size();
568  }
569 
570  // calculate size for other elements
571  for (EbmlElement *trackInfoElement = m_track.m_trackElement->firstChild(); trackInfoElement; trackInfoElement = trackInfoElement->nextSibling()) {
572  switch (trackInfoElement->id()) {
580  // skip recognized elements
581  break;
582  default:
583  trackInfoElement->makeBuffer();
584  m_dataSize += trackInfoElement->totalSize();
585  }
586  }
587  m_sizeDenotationLength = EbmlElement::calculateSizeDenotationLength(m_dataSize);
588  m_requiredSize = 1 + m_sizeDenotationLength + m_dataSize;
589 }
590 
598 void MatroskaTrackHeaderMaker::make(ostream &stream) const
599 {
600  // make ID and size
601  char buffer[9];
602  *buffer = static_cast<char>(MatroskaIds::TrackEntry);
603  EbmlElement::makeSizeDenotation(m_dataSize, buffer + 1);
604  stream.write(buffer, 1 + m_sizeDenotationLength);
605 
606  // make recognized elements
612  if (!m_track.name().empty()) {
614  }
615  if (!m_track.language().empty()) {
617  }
618 
619  // make other elements
620  for (EbmlElement *trackInfoElement = m_track.m_trackElement->firstChild(); trackInfoElement; trackInfoElement = trackInfoElement->nextSibling()) {
621  switch (trackInfoElement->id()) {
629  // skip recognized elements
630  break;
631  default:
632  trackInfoElement->copyBuffer(stream);
633  }
634  }
635 }
636 
637 } // namespace TagParser
TagParser::Mpeg4AudioObjectIds::idToMediaFormat
TAG_PARSER_EXPORT MediaFormat idToMediaFormat(std::uint8_t mpeg4AudioObjectId, bool sbrPresent=false, bool psPresent=false)
Definition: mp4ids.cpp:366
TagParser::AbstractTrack::m_trackNumber
std::uint32_t m_trackNumber
Definition: abstracttrack.h:130
TagParser::GeneralMediaFormat::ImageSubtitle
@ ImageSubtitle
TagParser::SubFormats::DtsLossless
@ DtsLossless
Definition: mediaformat.h:219
TagParser::GeneralMediaFormat::Mpeg4Video
@ Mpeg4Video
TagParser::AbstractTrack::m_colorSpace
std::uint32_t m_colorSpace
Definition: abstracttrack.h:166
TagParser::AbstractTrack::m_samplingFrequency
std::uint32_t m_samplingFrequency
Definition: abstracttrack.h:139
TagParser::MediaType::Text
@ Text
TagParser::GeneralMediaFormat::Aac
@ Aac
TagParser::MediaType::Audio
@ Audio
TagParser::SubFormats::ImgSubBmp
@ ImgSubBmp
Definition: mediaformat.h:234
TagParser::MatroskaTrackType::Subtitle
@ Subtitle
Definition: matroskaid.h:403
TagParser::SubFormats::PcmIntBe
@ PcmIntBe
Definition: mediaformat.h:224
TagParser::MediaFormat::extension
unsigned char extension
Definition: mediaformat.h:260
TagParser::EbmlElement::calculateUIntegerLength
static std::uint8_t calculateUIntegerLength(std::uint64_t integer)
Returns the length of the specified unsigned integer in byte.
Definition: ebmlelement.cpp:415
TagParser::MatroskaTrackType::Buttons
@ Buttons
Definition: matroskaid.h:403
TagParser::MatroskaIds::BitDepth
@ BitDepth
Definition: matroskaid.h:145
TagParser::MatroskaIds::PixelCropTop
@ PixelCropTop
Definition: matroskaid.h:130
TagParser::AbstractTrack::isEnabled
bool isEnabled() const
Returns true if the track is denoted as enabled; otherwise returns false.
Definition: abstracttrack.h:597
TagParser::AbstractTrack::m_enabled
bool m_enabled
Definition: abstracttrack.h:159
TagParser::AbstractTrack::m_bitrate
double m_bitrate
Definition: abstracttrack.h:134
TagParser::MatroskaTrack::codecIdToMediaFormat
static MediaFormat codecIdToMediaFormat(const std::string &codecId)
Returns the MediaFormat for the specified Matroska codec ID.
Definition: matroskatrack.cpp:58
TagParser::WaveAudioStream::addInfo
static void addInfo(const WaveFormatHeader &waveHeader, AbstractTrack &track)
Adds the information from the specified waveHeader to the specified track.
Definition: waveaudiostream.cpp:135
TagParser::TagTextEncoding::Utf8
@ Utf8
TagParser::MatroskaIds::PixelCropBottom
@ PixelCropBottom
Definition: matroskaid.h:129
TagParser::GeneralMediaFormat::Vp8
@ Vp8
TagParser::SubFormats::AacMpeg4LongTermPrediction
@ AacMpeg4LongTermPrediction
Definition: mediaformat.h:121
TagParser::GeneralMediaFormat::MicrosoftVideoCodecManager
@ MicrosoftVideoCodecManager
TagParser::BitmapInfoHeader::compression
std::uint32_t compression
Definition: bitmapinfoheader.h:25
TagParser::GeneralMediaFormat::DvbSub
@ DvbSub
TagParser::GeneralMediaFormat::ProRes
@ ProRes
TagParser::SubFormats::PlainUtf8Subtitle
@ PlainUtf8Subtitle
Definition: mediaformat.h:227
TagParser::MatroskaIds::TrackFlagDefault
@ TrackFlagDefault
Definition: matroskaid.h:79
TagParser::GeneralMediaFormat::OggKate
@ OggKate
TagParser::Margin::setLeft
void setLeft(std::uint32_t left)
Sets the left margin to left.
Definition: margin.h:75
TagParser::WaveFormatHeader
The WaveFormatHeader class parses the WAVEFORMATEX structure defined by MS.
Definition: waveaudiostream.h:8
TagParser::EbmlElement::calculateSizeDenotationLength
static std::uint8_t calculateSizeDenotationLength(std::uint64_t size)
Returns the length of the size denotation for the specified size in byte.
Definition: ebmlelement.cpp:288
TagParser::AbstractTrack::m_language
std::string m_language
Definition: abstracttrack.h:138
TagParser::MatroskaIds::TrackFlagLacing
@ TrackFlagLacing
Definition: matroskaid.h:81
TagParser::MatroskaIds::OutputSamplingFrequency
@ OutputSamplingFrequency
Definition: matroskaid.h:145
TagParser::Margin::setBottom
void setBottom(std::uint32_t bottom)
Sets the bottom margin to bottom.
Definition: margin.h:91
TagParser::GeneralMediaFormat::RealAudio
@ RealAudio
TagParser::SubFormats::PcmFloatIeee
@ PcmFloatIeee
Definition: mediaformat.h:224
TagParser::FourccIds::WavPack
@ WavPack
Definition: mp4ids.h:390
TagParser::MatroskaTrack::type
TrackType type() const override
Returns the type of the track if known; otherwise returns TrackType::Unspecified.
Definition: matroskatrack.cpp:50
TagParser::SubFormats::AacMpeg2MainProfile
@ AacMpeg2MainProfile
Definition: mediaformat.h:115
TagParser::DiagLevel::Warning
@ Warning
TagParser::SubFormats::Mpeg1Layer3
@ Mpeg1Layer3
Definition: mediaformat.h:112
TagParser::AbstractTrack::m_forced
bool m_forced
Definition: abstracttrack.h:161
TagParser::AbstractTrack::m_displaySize
Size m_displaySize
Definition: abstracttrack.h:150
TagParser::SubFormats::SubStationAlpha
@ SubStationAlpha
Definition: mediaformat.h:228
TagParser::SubFormats::Mpeg4SimpleProfile1
@ Mpeg4SimpleProfile1
Definition: mediaformat.h:139
TagParser::MatroskaIds::PixelCropLeft
@ PixelCropLeft
Definition: matroskaid.h:131
TagParser::TrackType::MatroskaTrack
@ MatroskaTrack
TagParser::MatroskaTagIds::numberOfFrames
constexpr const TAG_PARSER_EXPORT char * numberOfFrames()
Definition: matroskatagid.h:350
TagParser::ExtensionFormats::SpectralBandReplication
@ SpectralBandReplication
Definition: mediaformat.h:242
TagParser::Diagnostics
The Diagnostics class is a container for DiagMessage.
Definition: diagnostics.h:156
TagParser::MatroskaIds::PixelWidth
@ PixelWidth
Definition: matroskaid.h:127
TagParser::SubFormats::UniversalSubtitleFormat
@ UniversalSubtitleFormat
Definition: mediaformat.h:230
TagParser::GeneralMediaFormat::Av1
@ Av1
TagParser::GeneralMediaFormat::UncompressedVideoFrames
@ UncompressedVideoFrames
TagParser::TagTarget::tracks
const IdContainerType & tracks() const
Returns the tracks.
Definition: tagtarget.h:104
TagParser::SubFormats::AacMpeg2ScalableSamplingRateProfile
@ AacMpeg2ScalableSamplingRateProfile
Definition: mediaformat.h:117
TagParser::MatroskaIds::DisplayWidth
@ DisplayWidth
Definition: matroskaid.h:133
TagParser::GeneralMediaFormat::MicrosoftAudioCodecManager
@ MicrosoftAudioCodecManager
TagParser::MediaType::Buttons
@ Buttons
TagParser::WaveFormatHeader::parse
std::uint64_t parse(CppUtilities::BinaryReader &reader, std::uint64_t maxSize, Diagnostics &diag)
Parses the WAVE "fmt " header segment using the specified reader.
Definition: waveaudiostream.cpp:25
TagParser::MatroskaIds::TrackUID
@ TrackUID
Definition: matroskaid.h:76
TagParser
Contains all classes and functions of the TagInfo library.
Definition: aaccodebook.h:10
TagParser::AbstractTrack::m_name
std::string m_name
Definition: abstracttrack.h:132
TagParser::AbstractTrack::m_formatId
std::string m_formatId
Definition: abstracttrack.h:125
TagParser::SubFormats::DtsExpress
@ DtsExpress
Definition: mediaformat.h:218
matroskacontainer.h
TagParser::MatroskaIds::TrackFlagEnabled
@ TrackFlagEnabled
Definition: matroskaid.h:78
TagParser::MatroskaIds::PixelHeight
@ PixelHeight
Definition: matroskaid.h:128
TagParser::AbstractTrack::m_sampleCount
std::uint64_t m_sampleCount
Definition: abstracttrack.h:147
TagParser::FourccIds::Flac
@ Flac
Definition: mp4ids.h:272
TagParser::AbstractTrack::m_reader
CppUtilities::BinaryReader m_reader
Definition: abstracttrack.h:120
TagParser::Margin::setTop
void setTop(std::uint32_t top)
Sets the top margin to top.
Definition: margin.h:59
TagParser::MatroskaTagIds::TrackSpecific::writingDate
constexpr const TAG_PARSER_EXPORT char * writingDate()
Definition: matroskatagid.h:471
TagParser::AbstractTrack::isForced
bool isForced() const
Returns true if the track is denoted as forced; otherwise returns false.
Definition: abstracttrack.h:631
TagParser::mpeg4SamplingFrequencyTable
std::uint32_t mpeg4SamplingFrequencyTable[13]
Definition: mp4ids.cpp:422
TagParser::EbmlElement::makeSimpleElement
static void makeSimpleElement(std::ostream &stream, IdentifierType id, std::uint64_t content)
Makes a simple EBML element.
Definition: ebmlelement.cpp:513
TagParser::MediaType::Control
@ Control
TagParser::FourccIds::Ac3
@ Ac3
Definition: mp4ids.h:146
matroskatag.h
TagParser::MatroskaIds::DisplayHeight
@ DisplayHeight
Definition: matroskaid.h:134
TagParser::GeneralMediaFormat::Unknown
@ Unknown
TagParser::BitmapInfoHeader
The BitmapInfoHeader class parses the BITMAPINFOHEADER structure defined by MS.
Definition: bitmapinfoheader.h:14
TagParser::MatroskaIds::FrameRate
@ FrameRate
Definition: matroskaid.h:139
TagParser::MatroskaIds::PixelCropRight
@ PixelCropRight
Definition: matroskaid.h:132
TagParser::GenericFileElement::dataSize
DataSizeType dataSize() const
Returns the data size of the element in byte.
Definition: genericfileelement.h:315
TagParser::MatroskaTrackType::Control
@ Control
Definition: matroskaid.h:403
TagParser::MatroskaIds::CodecDelay
@ CodecDelay
Definition: matroskaid.h:100
TagParser::MatroskaIds::TrackType
@ TrackType
Definition: matroskaid.h:77
TagParser::SubFormats::AacMpeg4LowComplexityProfile
@ AacMpeg4LowComplexityProfile
Definition: mediaformat.h:119
TagParser::GeneralMediaFormat::QuicktimeVideo
@ QuicktimeVideo
TagParser::GeneralMediaFormat::Opus
@ Opus
TagParser::Size::setWidth
void setWidth(std::uint32_t value)
Sets the width.
Definition: size.h:75
TagParser::SubFormats::Mpeg1Layer1
@ Mpeg1Layer1
Definition: mediaformat.h:112
TagParser::MatroskaIds::CodecPrivate
@ CodecPrivate
Definition: matroskaid.h:92
TagParser::GeneralMediaFormat::Pcm
@ Pcm
matroskaid.h
TagParser::SubFormats::Mpeg4AdvancedSimpleProfile1
@ Mpeg4AdvancedSimpleProfile1
Definition: mediaformat.h:186
TagParser::GeneralMediaFormat::TextSubtitle
@ TextSubtitle
TagParser::MatroskaIds::TrackFlagForced
@ TrackFlagForced
Definition: matroskaid.h:80
TagParser::BitmapInfoHeader::parse
void parse(CppUtilities::BinaryReader &reader)
Parses the BITMAPINFOHEADER structure using the specified reader.
Definition: bitmapinfoheader.cpp:36
TagParser::MatroskaIds::DefaultDuration
@ DefaultDuration
Definition: matroskaid.h:84
TagParser::Failure
The class inherits from std::exception and serves as base class for exceptions thrown by the elements...
Definition: exceptions.h:11
matroskatrack.h
TagParser::AbstractTrack::m_duration
CppUtilities::TimeSpan m_duration
Definition: abstracttrack.h:133
TagParser::GeneralMediaFormat::Mpeg1Video
@ Mpeg1Video
TagParser::SubFormats::AacMpeg4MainProfile
@ AacMpeg4MainProfile
Definition: mediaformat.h:118
TagParser::TrackType
TrackType
Specifies the track type.
Definition: abstracttrack.h:27
TagParser::TagValue::isEmpty
bool isEmpty() const
Returns whether an empty value is assigned.
Definition: tagvalue.h:449
TagParser::MatroskaTrackHeaderMaker::make
void make(std::ostream &stream) const
Saves the header for the track (specified when constructing the object) to the specified stream (make...
Definition: matroskatrack.cpp:598
TagParser::EbmlElement::makeSizeDenotation
static std::uint8_t makeSizeDenotation(std::uint64_t size, char *buff)
Makes the size denotation for the specified size and stores it to buff.
Definition: ebmlelement.cpp:343
TagParser::AbstractTrack::m_extensionSamplingFrequency
std::uint32_t m_extensionSamplingFrequency
Definition: abstracttrack.h:140
TagParser::EbmlElement
The EbmlElement class helps to parse EBML files such as Matroska files.
Definition: ebmlelement.h:31
TagParser::AbstractTrack::m_id
std::uint64_t m_id
Definition: abstracttrack.h:131
TagParser::MatroskaTrack::~MatroskaTrack
~MatroskaTrack() override
Destroys the track.
Definition: matroskatrack.cpp:46
TagParser::MatroskaIds::SamplingFrequency
@ SamplingFrequency
Definition: matroskaid.h:145
TagParser::TagTextEncoding::Latin1
@ Latin1
TagParser::MatroskaIds::CodecName
@ CodecName
Definition: matroskaid.h:93
TagParser::Mp4Track::addInfo
static void addInfo(const AvcConfiguration &avcConfig, AbstractTrack &track)
Adds the information from the specified avcConfig to the specified track.
Definition: mp4track.cpp:1015
TagParser::AbstractTrack::m_size
std::uint64_t m_size
Definition: abstracttrack.h:129
TagParser::MatroskaIds::TrackName
@ TrackName
Definition: matroskaid.h:89
TagParser::GeneralMediaFormat::Vc1
@ Vc1
TagParser::MatroskaIds::ColorSpace
@ ColorSpace
Definition: matroskaid.h:137
TagParser::DiagLevel::Critical
@ Critical
TagParser::TagValue::toDateTime
CppUtilities::DateTime toDateTime() const
Converts the value of the current TagValue object to its equivalent DateTime representation.
Definition: tagvalue.cpp:470
TagParser::MatroskaTrack
Implementation of TagParser::AbstractTrack for the Matroska container.
Definition: matroskatrack.h:46
TagParser::MatroskaIds::TrackVideo
@ TrackVideo
Definition: matroskaid.h:104
TagParser::TagDataType::Text
@ Text
CppUtilities
Definition: abstractcontainer.h:15
TagParser::MatroskaTrack::readStatisticsFromTags
void readStatisticsFromTags(const std::vector< std::unique_ptr< MatroskaTag >> &tags, Diagnostics &diag)
Reads track-specific statistics from the specified tags.
Definition: matroskatrack.cpp:263
TagParser::AbstractTrack::m_default
bool m_default
Definition: abstracttrack.h:160
TagParser::AbstractTrack
The AbstractTrack class parses and stores technical information about video, audio and other kinds of...
Definition: abstracttrack.h:39
TagParser::GenericFileElement::childById
ImplementationType * childById(const IdentifierType &id, Diagnostics &diag)
Returns the first child with the specified id.
Definition: genericfileelement.h:602
TagParser::AbstractTrack::m_channelCount
std::uint16_t m_channelCount
Definition: abstracttrack.h:143
TagParser::AbstractTrack::m_pixelSize
Size m_pixelSize
Definition: abstracttrack.h:149
TagParser::Margin::setRight
void setRight(std::uint32_t right)
Sets the right margin to right.
Definition: margin.h:107
TagParser::AbstractTrack::m_modificationTime
CppUtilities::DateTime m_modificationTime
Definition: abstracttrack.h:137
TagParser::AbstractTrack::m_mediaType
MediaType m_mediaType
Definition: abstracttrack.h:127
TagParser::SubFormats::Mpeg1Layer2
@ Mpeg1Layer2
Definition: mediaformat.h:112
TagParser::MediaFormat::general
GeneralMediaFormat general
Definition: mediaformat.h:258
TagParser::MatroskaIds::TrackEntry
@ TrackEntry
Definition: matroskaid.h:68
TagParser::TagValue::toTimeSpan
CppUtilities::TimeSpan toTimeSpan() const
Converts the value of the current TagValue object to its equivalent TimeSpan representation.
Definition: tagvalue.cpp:442
TagParser::AbstractTrack::m_bitsPerSample
std::uint16_t m_bitsPerSample
Definition: abstracttrack.h:141
TagParser::GenericFileElement::firstChild
ImplementationType * firstChild()
Returns the first child of the element.
Definition: genericfileelement.h:460
TagParser::MatroskaIds::TrackNumber
@ TrackNumber
Definition: matroskaid.h:75
TagParser::MatroskaTagIds::TrackSpecific::duration
constexpr const TAG_PARSER_EXPORT char * duration()
Definition: matroskatagid.h:458
TagParser::Size::setHeight
void setHeight(std::uint32_t value)
Sets the height.
Definition: size.h:83
TagParser::TagTarget
The TagTarget class specifies the target of a tag.
Definition: tagtarget.h:20
TagParser::TruncatedDataException
The exception that is thrown when the data to be parsed is truncated and therefore can not be parsed ...
Definition: exceptions.h:39
TagParser::TagValue
The TagValue class wraps values of different types. It is meant to be assigned to a tag field.
Definition: tagvalue.h:75
TagParser::MatroskaIds::CodecID
@ CodecID
Definition: matroskaid.h:91
TagParser::GeneralMediaFormat::Alac
@ Alac
TagParser::AbstractTrack::m_format
MediaFormat m_format
Definition: abstracttrack.h:124
TagParser::AbstractTrack::language
const std::string & language() const
Returns the language of the track if known; otherwise returns an empty string.
Definition: abstracttrack.h:413
TagParser::GeneralMediaFormat::Hevc
@ Hevc
TagParser::TagValue::toString
std::string toString(TagTextEncoding encoding=TagTextEncoding::Unspecified) const
Converts the value of the current TagValue object to its equivalent std::string representation.
Definition: tagvalue.h:407
TagParser::Size::height
constexpr std::uint32_t height() const
Returns the height.
Definition: size.h:67
TagParser::MediaType::Unknown
@ Unknown
TagParser::AbstractTrack::m_fps
std::uint32_t m_fps
Definition: abstracttrack.h:154
TagParser::GeneralMediaFormat::RealVideo
@ RealVideo
TagParser::SubFormats::AacMpeg4ScalableSamplingRateProfile
@ AacMpeg4ScalableSamplingRateProfile
Definition: mediaformat.h:120
TagParser::MatroskaTagIds::TrackSpecific::bitrate
constexpr const TAG_PARSER_EXPORT char * bitrate()
The track's bit rate in bits per second.
Definition: matroskatagid.h:463
TagParser::MatroskaTagIds::numberOfBytes
constexpr const TAG_PARSER_EXPORT char * numberOfBytes()
Definition: matroskatagid.h:354
TagParser::AbstractTrack::id
std::uint64_t id() const
Returns the track ID if known; otherwise returns 0.
Definition: abstracttrack.h:337
TagParser::AbstractTrack::reader
CppUtilities::BinaryReader & reader()
Returns a binary reader for the associated stream.
Definition: abstracttrack.h:214
TagParser::SubFormats::AacMpeg2LowComplexityProfile
@ AacMpeg2LowComplexityProfile
Definition: mediaformat.h:116
TagParser::MatroskaTrackType::Video
@ Video
Definition: matroskaid.h:403
TagParser::AbstractTrack::m_lacing
bool m_lacing
Definition: abstracttrack.h:162
TagParser::AbstractTrack::isDefault
bool isDefault() const
Returns true if the track is denoted as default; otherwise returns false.
Definition: abstracttrack.h:614
TagParser::GeneralMediaFormat::Vp9
@ Vp9
ebmlelement.h
TagParser::AbstractTrack::m_channelConfig
std::uint8_t m_channelConfig
Definition: abstracttrack.h:144
TagParser::Mp4Track::parseAudioSpecificConfig
static std::unique_ptr< Mpeg4AudioSpecificConfig > parseAudioSpecificConfig(std::istream &stream, std::uint64_t startOffset, std::uint64_t size, Diagnostics &diag)
Parses the audio specific configuration for the track.
Definition: mp4track.cpp:648
TagParser::SubFormats::WebVideoTextTracksFormat
@ WebVideoTextTracksFormat
Definition: mediaformat.h:231
TagParser::MatroskaTrack::internalParseHeader
void internalParseHeader(Diagnostics &diag) override
This method is internally called to parse header information. It needs to be implemented when subclas...
Definition: matroskatrack.cpp:283
TagParser::GenericFileElement::dataOffset
std::uint64_t dataOffset() const
Returns the data offset of the element in the related stream.
Definition: genericfileelement.h:333
TagParser::FourccIds::fourccToMediaFormat
TAG_PARSER_EXPORT MediaFormat fourccToMediaFormat(std::uint32_t fourccId)
Definition: mp4ids.cpp:46
TagParser::AbstractTrack::m_formatName
std::string m_formatName
Definition: abstracttrack.h:126
TagParser::GeneralMediaFormat::Mpeg1Audio
@ Mpeg1Audio
TagParser::MediaType::Video
@ Video
TagParser::Size::width
constexpr std::uint32_t width() const
Returns the width.
Definition: size.h:59
TagParser::MatroskaIds::TrackLanguage
@ TrackLanguage
Definition: matroskaid.h:90
TagParser::AbstractTrack::m_interlaced
bool m_interlaced
Definition: abstracttrack.h:157
TagParser::GeneralMediaFormat::VobSub
@ VobSub
TagParser::GeneralMediaFormat::QuicktimeAudio
@ QuicktimeAudio
TagParser::GeneralMediaFormat::Mpeg2Video
@ Mpeg2Video
TagParser::GeneralMediaFormat::Tta
@ Tta
TagParser::GeneralMediaFormat::Theora
@ Theora
TagParser::SubFormats::PcmIntLe
@ PcmIntLe
Definition: mediaformat.h:224
TagParser::MatroskaIds::TrackAudio
@ TrackAudio
Definition: matroskaid.h:103
TagParser::AbstractTrack::m_creationTime
CppUtilities::DateTime m_creationTime
Definition: abstracttrack.h:136
TagParser::GeneralMediaFormat::Vorbis
@ Vorbis
TagParser::GeneralMediaFormat::VobBtn
@ VobBtn
TagParser::MediaFormat::sub
unsigned char sub
Definition: mediaformat.h:259
TagParser::AbstractTrack::name
const std::string name() const
Returns the track name if known; otherwise returns an empty string.
Definition: abstracttrack.h:354
TagParser::MatroskaIds::Channels
@ Channels
Definition: matroskaid.h:145
TagParser::MatroskaIds::FlagInterlaced
@ FlagInterlaced
Definition: matroskaid.h:123
TagParser::AbstractTrack::m_cropping
Margin m_cropping
Definition: abstracttrack.h:167
TagParser::GeneralMediaFormat::Mpc
@ Mpc
TagParser::MediaFormat
The MediaFormat class specifies the format of media data.
Definition: mediaformat.h:245
TagParser::GeneralMediaFormat::Avc
@ Avc
TagParser::AbstractTrack::m_istream
std::istream * m_istream
Definition: abstracttrack.h:118
TagParser::GeneralMediaFormat::Dts
@ Dts
TagParser::MatroskaTrackType::Audio
@ Audio
Definition: matroskaid.h:403
TagParser::SubFormats::AdvancedSubStationAlpha
@ AdvancedSubStationAlpha
Definition: mediaformat.h:229
TagParser::AbstractTrack::m_extensionChannelConfig
std::uint8_t m_extensionChannelConfig
Definition: abstracttrack.h:145
TagParser::AbstractTrack::trackNumber
std::uint32_t trackNumber() const
Returns the track number if known; otherwise returns 0.
Definition: abstracttrack.h:320