Tag Parser  9.2.0
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 
60 {
61  auto parts = splitString<vector<string>>(codecId, "/", EmptyPartsTreat::Keep, 3);
62  parts.resize(3);
63  const auto &part1 = parts[0], &part2 = parts[1], &part3 = parts[2];
64  MediaFormat fmt;
65  if (part1 == "V_MS" && part2 == "VFW" && part3 == "FOURCC") {
67  } else if (part1 == "V_UNCOMPRESSED") {
69  } else if (part1 == "V_MPEG4") {
71  if (part2 == "ISO") {
72  if (part3 == "SP") {
74  } else if (part3 == "ASP") {
76  } else if (part3 == "AVC") {
78  }
79  } else if (part2 == "MS" && part3 == "V3") {
81  }
82  } else if (part1 == "V_MPEG1") {
84  } else if (part1 == "V_MPEG2") {
86  } else if (part1 == "V_REAL") {
88  } else if (part1 == "V_QUICKTIME") {
90  } else if (part1 == "V_THEORA") {
92  } else if (part1 == "V_PRORES") {
94  } else if (part1 == "V_VP8") {
96  } else if (part1 == "V_VP9") {
98  } else if (part1 == "V_AV1") {
100  } else if (part1 == "A_MPEG") {
102  if (part2 == "L1") {
104  } else if (part2 == "L2") {
106  } else if (part2 == "L3") {
108  }
109  } else if (part1 == "V_MPEGH" && part2 == "ISO" && part3 == "HEVC") {
111  } else if (part1 == "A_PCM") {
113  if (part2 == "INT") {
114  if (part3 == "BIG") {
116  } else if (part3 == "LIT") {
118  }
119  } else if (part2 == "FLOAT" && part3 == "IEEE") {
121  }
122  } else if (part1 == "A_MPC") {
124  } else if (part1 == "A_AC3") {
126  } else if (part1 == "A_EAC3") {
128  } else if (part1 == "A_ALAC") {
130  } else if (part1 == "A_DTS") {
132  if (part2 == "EXPRESS") {
134  } else if (part2 == "LOSSLESS") {
136  }
137  } else if (part1 == "A_VORBIS") {
139  } else if (part1 == "A_FLAC") {
141  } else if (part1 == "A_OPUS") {
143  } else if (part1 == "A_REAL") {
145  } else if (part1 == "A_MS" && part2 == "ACM") {
147  } else if (part1 == "A_AAC") {
149  if (part2 == "MPEG2") {
150  if (part3 == "MAIN") {
152  } else if (part3 == "LC") {
154  } else if (part3 == "SBR") {
157  } else if (part3 == "SSR") {
159  }
160  } else if (part2 == "MPEG4") {
161  if (part3 == "MAIN") {
163  } else if (part3 == "LC") {
165  } else if (part3 == "SBR") {
168  } else if (part3 == "SSR") {
170  } else if (part3 == "LTP") {
172  }
173  }
174  } else if (part1 == "A_QUICKTIME") {
176  } else if (part1 == "A_TTA1") {
178  } else if (part1 == "A_WAVPACK4") {
180  } else if (part1 == "S_TEXT") {
182  if (part2 == "UTF8") {
184  } else if (part2 == "SSA") {
186  } else if (part2 == "ASS") {
188  } else if (part2 == "USF") {
190  } else if (part2 == "WEBVTT") {
192  }
193  } else if (part1 == "S_IMAGE") {
195  if (part2 == "BMP") {
197  }
198  } else if (part1 == "S_VOBSUB") {
200  } else if (part1 == "S_KATE") {
202  } else if (part1 == "B_VOBBTN") {
204  } else if (part1 == "S_DVBSUB") {
206  } else if (part1 == "V_MSWMV") {
208  }
209  return fmt;
210 }
211 
213 
214 template <typename PropertyType, typename ConversionFunction>
215 void MatroskaTrack::assignPropertyFromTagValue(const std::unique_ptr<MatroskaTag> &tag, const char *fieldId, PropertyType &property,
216  const ConversionFunction &conversionFunction, Diagnostics &diag)
217 {
218  const TagValue &value = tag->value(fieldId);
219  if (!value.isEmpty()) {
220  try {
221  property = conversionFunction(value);
222  } catch (const ConversionException &) {
223  string message;
224  try {
225  message = argsToString("Ignoring invalid value \"", value.toString(TagTextEncoding::Utf8), "\" of \"", fieldId, '\"', '.');
226  } catch (const ConversionException &) {
227  message = argsToString("Ignoring invalid value of \"", fieldId, '\"', '.');
228  }
229  diag.emplace_back(DiagLevel::Warning, message, argsToString("reading track statatistic from \"", tag->toString(), '\"'));
230  }
231  }
232 }
233 
234 template <typename NumberType, Traits::EnableIf<std::is_integral<NumberType>> * = nullptr> NumberType tagValueToNumber(const TagValue &tagValue)
235 {
236  // optimization for Latin1/UTF-8 strings
237  if (tagValue.type() == TagDataType::Text) {
238  switch (tagValue.dataEncoding()) {
241  return bufferToNumber<NumberType>(tagValue.dataPointer(), tagValue.dataSize());
242  default:;
243  }
244  }
245  // generic conversion
246  return stringToNumber<NumberType>(tagValue.toString(TagTextEncoding::Utf8));
247 }
248 
249 template <typename NumberType, Traits::EnableIf<std::is_floating_point<NumberType>> * = nullptr>
250 NumberType tagValueToBitrate(const TagValue &tagValue)
251 {
252  return stringToNumber<NumberType>(tagValue.toString(TagTextEncoding::Utf8)) / 1000;
253 }
254 
256 
266 void MatroskaTrack::readStatisticsFromTags(const std::vector<std::unique_ptr<MatroskaTag>> &tags, Diagnostics &diag)
267 {
268  using namespace std::placeholders;
269  using namespace MatroskaTagIds::TrackSpecific;
270  for (const auto &tag : tags) {
271  const TagTarget &target = tag->target();
272  if (find(target.tracks().cbegin(), target.tracks().cend(), id()) == target.tracks().cend()) {
273  continue;
274  }
275  assignPropertyFromTagValue(tag, numberOfBytes(), m_size, &tagValueToNumber<std::uint64_t>, diag);
276  assignPropertyFromTagValue(tag, numberOfFrames(), m_sampleCount, &tagValueToNumber<std::uint64_t>, diag);
277  assignPropertyFromTagValue(tag, MatroskaTagIds::TrackSpecific::duration(), m_duration, bind(&TagValue::toTimeSpan, _1), diag);
278  assignPropertyFromTagValue(tag, MatroskaTagIds::TrackSpecific::bitrate(), m_bitrate, &tagValueToBitrate<double>, diag);
279  assignPropertyFromTagValue(tag, writingDate(), m_modificationTime, bind(&TagValue::toDateTime, _1), diag);
280  if (m_creationTime.isNull()) {
282  }
283  }
284 }
285 
287 {
288  static const string context("parsing header of Matroska track");
289  try {
290  m_trackElement->parse(diag);
291  } catch (const Failure &) {
292  diag.emplace_back(DiagLevel::Critical, "Unable to parse track element.", context);
293  throw;
294  }
295  // read information about the track from the children of the track entry element
296  for (EbmlElement *trackInfoElement = m_trackElement->firstChild(), *subElement = nullptr; trackInfoElement;
297  trackInfoElement = trackInfoElement->nextSibling()) {
298  try {
299  trackInfoElement->parse(diag);
300  } catch (const Failure &) {
301  diag.emplace_back(DiagLevel::Critical, "Unable to parse track information element.", context);
302  break;
303  }
304  std::uint32_t defaultDuration = 0;
305  switch (trackInfoElement->id()) {
307  switch (trackInfoElement->readUInteger()) {
310  break;
313  break;
316  break;
319  break;
322  break;
323  default:
325  }
326  break;
328  for (subElement = trackInfoElement->firstChild(); subElement; subElement = subElement->nextSibling()) {
329  try {
330  subElement->parse(diag);
331  } catch (const Failure &) {
332  diag.emplace_back(DiagLevel::Critical, "Unable to parse video track element.", context);
333  break;
334  }
335  switch (subElement->id()) {
337  m_displaySize.setWidth(subElement->readUInteger());
338  break;
340  m_displaySize.setHeight(subElement->readUInteger());
341  break;
343  m_pixelSize.setWidth(subElement->readUInteger());
344  break;
346  m_pixelSize.setHeight(subElement->readUInteger());
347  break;
349  m_cropping.setTop(subElement->readUInteger());
350  break;
352  m_cropping.setLeft(subElement->readUInteger());
353  break;
355  m_cropping.setBottom(subElement->readUInteger());
356  break;
358  m_cropping.setRight(subElement->readUInteger());
359  break;
361  m_fps = subElement->readFloat();
362  break;
364  m_interlaced = subElement->readUInteger();
365  break;
367  m_colorSpace = subElement->readUInteger();
368  break;
369  default:;
370  }
371  }
372  break;
374  for (subElement = trackInfoElement->firstChild(); subElement; subElement = subElement->nextSibling()) {
375  try {
376  subElement->parse(diag);
377  } catch (const Failure &) {
378  diag.emplace_back(DiagLevel::Critical, "Unable to parse audio track element.", context);
379  break;
380  }
381  switch (subElement->id()) {
383  m_bitsPerSample = subElement->readUInteger();
384  break;
386  m_channelCount = subElement->readUInteger();
387  break;
389  if (!m_samplingFrequency) {
390  m_samplingFrequency = subElement->readFloat();
391  }
392  break;
395  m_extensionSamplingFrequency = subElement->readFloat();
396  }
397  break;
398  default:;
399  }
400  }
401  break;
403  m_trackNumber = trackInfoElement->readUInteger();
404  break;
406  m_id = trackInfoElement->readUInteger();
407  break;
409  m_name = trackInfoElement->readString();
410  break;
412  m_language = trackInfoElement->readString();
413  break;
415  m_format = codecIdToMediaFormat(m_formatId = trackInfoElement->readString());
416  break;
418  m_formatName = trackInfoElement->readString();
419  break;
421  break; // TODO
423  m_enabled = trackInfoElement->readUInteger();
424  break;
426  m_default = trackInfoElement->readUInteger();
427  break;
429  m_forced = trackInfoElement->readUInteger();
430  break;
432  m_lacing = trackInfoElement->readUInteger();
433  break;
435  defaultDuration = trackInfoElement->readUInteger();
436  break;
437  default:;
438  }
439  switch (m_mediaType) {
440  case MediaType::Video:
441  if (!m_fps && defaultDuration) {
442  m_fps = 1000000000.0 / defaultDuration;
443  }
444  break;
445  default:;
446  }
447  }
448 
449  // read further information from the CodecPrivate element for some codecs
450  EbmlElement *codecPrivateElement;
451  switch (m_format.general) {
453  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
454  // parse bitmap info header to determine actual format
455  if (codecPrivateElement->dataSize() >= 0x28) {
456  m_istream->seekg(static_cast<streamoff>(codecPrivateElement->dataOffset()));
457  BitmapInfoHeader bitmapInfoHeader;
458  bitmapInfoHeader.parse(reader());
459  m_formatId.reserve(m_formatId.size() + 7);
460  m_formatId += " \"";
461  m_formatId += interpretIntegerAsString(bitmapInfoHeader.compression);
462  m_formatId += "\"";
464  } else {
465  diag.emplace_back(DiagLevel::Critical, "BITMAPINFOHEADER structure (in \"CodecPrivate\"-element) is truncated.", context);
466  }
467  }
468  break;
470  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
471  // parse WAVE header to determine actual format
472  m_istream->seekg(static_cast<streamoff>(codecPrivateElement->dataOffset()));
473  WaveFormatHeader waveFormatHeader;
474  waveFormatHeader.parse(reader(), codecPrivateElement->dataSize(), diag);
475  WaveAudioStream::addInfo(waveFormatHeader, *this);
476  }
477  break;
479  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
480  auto audioSpecificConfig
481  = Mp4Track::parseAudioSpecificConfig(*m_istream, codecPrivateElement->dataOffset(), codecPrivateElement->dataSize(), diag);
483  audioSpecificConfig->audioObjectType, audioSpecificConfig->sbrPresent, audioSpecificConfig->psPresent);
484  if (audioSpecificConfig->sampleFrequencyIndex == 0xF) {
485  //m_samplingFrequency = audioSpecificConfig->sampleFrequency;
486  } else if (audioSpecificConfig->sampleFrequencyIndex < sizeof(mpeg4SamplingFrequencyTable)) {
487  //m_samplingFrequency = mpeg4SamplingFrequencyTable[audioSpecificConfig->sampleFrequencyIndex];
488  } else {
489  diag.emplace_back(DiagLevel::Warning, "Audio specific config has invalid sample frequency index.", context);
490  }
491  if (audioSpecificConfig->extensionSampleFrequencyIndex == 0xF) {
492  //m_extensionSamplingFrequency = audioSpecificConfig->extensionSampleFrequency;
493  } else if (audioSpecificConfig->extensionSampleFrequencyIndex < sizeof(mpeg4SamplingFrequencyTable)) {
494  //m_extensionSamplingFrequency = mpeg4SamplingFrequencyTable[audioSpecificConfig->extensionSampleFrequencyIndex];
495  } else {
496  diag.emplace_back(DiagLevel::Warning, "Audio specific config has invalid extension sample frequency index.", context);
497  }
498  m_channelConfig = audioSpecificConfig->channelConfiguration;
499  m_extensionChannelConfig = audioSpecificConfig->extensionChannelConfiguration;
500  }
501  break;
503  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
504  auto avcConfig = make_unique<TagParser::AvcConfiguration>();
505  try {
506  m_istream->seekg(static_cast<streamoff>(codecPrivateElement->dataOffset()));
507  avcConfig->parse(m_reader, codecPrivateElement->dataSize(), diag);
508  Mp4Track::addInfo(*avcConfig, *this);
509  } catch (const TruncatedDataException &) {
510  diag.emplace_back(DiagLevel::Critical, "AVC configuration is truncated.", context);
511  } catch (const Failure &) {
512  diag.emplace_back(DiagLevel::Critical, "AVC configuration is invalid.", context);
513  }
514  }
515  break;
516  default:;
517  }
518 
519  // parse format name for unknown formats
521  if (startsWith<string>(m_formatId, "V_") || startsWith<string>(m_formatId, "A_") || startsWith<string>(m_formatId, "S_")) {
522  m_formatName = m_formatId.substr(2);
523  } else {
525  }
526  m_formatName.append(" (unknown)");
527  }
528 
529  // use pixel size as display size if display size not specified
530  if (!m_displaySize.width()) {
532  }
533  if (!m_displaySize.height()) {
535  }
536 
537  // set English if no language has been specified (it is default value of MatroskaIds::TrackLanguage)
538  if (m_language.empty()) {
539  m_language = "eng";
540  }
541 }
542 
554 MatroskaTrackHeaderMaker::MatroskaTrackHeaderMaker(const MatroskaTrack &track, Diagnostics &diag)
555  : m_track(track)
556  , m_dataSize(0)
557 {
558  CPP_UTILITIES_UNUSED(diag);
559 
560  // calculate size for recognized elements
561  m_dataSize += 2 + 1 + EbmlElement::calculateUIntegerLength(m_track.id());
562  m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.trackNumber());
563  m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.isEnabled());
564  m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.isDefault());
565  m_dataSize += 2 + 1 + EbmlElement::calculateUIntegerLength(m_track.isForced());
566  if (!m_track.name().empty()) {
567  m_dataSize += 2 + EbmlElement::calculateSizeDenotationLength(m_track.name().size()) + m_track.name().size();
568  }
569  if (!m_track.language().empty()) {
570  m_dataSize += 3 + EbmlElement::calculateSizeDenotationLength(m_track.language().size()) + m_track.language().size();
571  }
572 
573  // calculate size for other elements
574  for (EbmlElement *trackInfoElement = m_track.m_trackElement->firstChild(); trackInfoElement; trackInfoElement = trackInfoElement->nextSibling()) {
575  switch (trackInfoElement->id()) {
583  // skip recognized elements
584  break;
585  default:
586  trackInfoElement->makeBuffer();
587  m_dataSize += trackInfoElement->totalSize();
588  }
589  }
590  m_sizeDenotationLength = EbmlElement::calculateSizeDenotationLength(m_dataSize);
591  m_requiredSize = 1 + m_sizeDenotationLength + m_dataSize;
592 }
593 
601 void MatroskaTrackHeaderMaker::make(ostream &stream) const
602 {
603  // make ID and size
604  char buffer[9];
605  *buffer = static_cast<char>(MatroskaIds::TrackEntry);
606  EbmlElement::makeSizeDenotation(m_dataSize, buffer + 1);
607  stream.write(buffer, 1 + m_sizeDenotationLength);
608 
609  // make recognized elements
615  if (!m_track.name().empty()) {
617  }
618  if (!m_track.language().empty()) {
620  }
621 
622  // make other elements
623  for (EbmlElement *trackInfoElement = m_track.m_trackElement->firstChild(); trackInfoElement; trackInfoElement = trackInfoElement->nextSibling()) {
624  switch (trackInfoElement->id()) {
632  // skip recognized elements
633  break;
634  default:
635  trackInfoElement->copyBuffer(stream);
636  }
637  }
638 }
639 
640 } // namespace TagParser
TagParser::Mpeg4AudioObjectIds::idToMediaFormat
TAG_PARSER_EXPORT MediaFormat idToMediaFormat(std::uint8_t mpeg4AudioObjectId, bool sbrPresent=false, bool psPresent=false)
Definition: mp4ids.cpp:367
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::MatroskaTagIds::TrackSpecific::writingDate
constexpr TAG_PARSER_EXPORT const char * writingDate()
Definition: matroskatagid.h:468
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:59
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::MatroskaTagIds::TrackSpecific::bitrate
constexpr TAG_PARSER_EXPORT const char * bitrate()
The track's bit rate in bits per second.
Definition: matroskatagid.h:460
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::TagTarget::tracks
const IdContainerType & tracks() const
Returns the tracks.
Definition: tagtarget.h:104
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::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::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
TagParser::MatroskaTagIds::numberOfBytes
constexpr TAG_PARSER_EXPORT const char * numberOfBytes()
Definition: matroskatagid.h:351
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::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:423
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::GenericFileElement::firstChild
ImplementationType * firstChild()
Returns the first child of the element.
Definition: genericfileelement.h:460
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 no or an empty value is assigned.
Definition: tagvalue.h:464
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:601
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::GeneralMediaFormat::EAc3
@ EAc3
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:266
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::MatroskaTagIds::numberOfFrames
constexpr TAG_PARSER_EXPORT const char * numberOfFrames()
Definition: matroskatagid.h:347
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::MatroskaIds::TrackNumber
@ TrackNumber
Definition: matroskaid.h:75
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:422
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::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::MatroskaTagIds::TrackSpecific::duration
constexpr TAG_PARSER_EXPORT const char * duration()
Definition: matroskatagid.h:455
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:286
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:47
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