Tag Parser  9.4.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") {
66  fmt.general = GeneralMediaFormat::MicrosoftVideoCodecManager;
67  } else if (part1 == "V_UNCOMPRESSED") {
68  fmt.general = GeneralMediaFormat::UncompressedVideoFrames;
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") {
85  fmt.general = GeneralMediaFormat::Mpeg2Video;
86  } else if (part1 == "V_REAL") {
87  fmt.general = GeneralMediaFormat::RealVideo;
88  } else if (part1 == "V_QUICKTIME") {
89  fmt.general = GeneralMediaFormat::QuicktimeVideo;
90  } else if (part1 == "V_THEORA") {
91  fmt.general = GeneralMediaFormat::Theora;
92  } else if (part1 == "V_PRORES") {
93  fmt.general = GeneralMediaFormat::ProRes;
94  } else if (part1 == "V_VP8") {
96  } else if (part1 == "V_VP9") {
98  } else if (part1 == "V_AV1") {
99  fmt.general = GeneralMediaFormat::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") {
110  fmt.general = GeneralMediaFormat::Hevc;
111  } else if (part1 == "A_PCM") {
112  fmt.general = GeneralMediaFormat::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") {
123  fmt.general = GeneralMediaFormat::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") {
138  fmt.general = GeneralMediaFormat::Vorbis;
139  } else if (part1 == "A_FLAC") {
141  } else if (part1 == "A_OPUS") {
143  } else if (part1 == "A_REAL") {
144  fmt.general = GeneralMediaFormat::RealAudio;
145  } else if (part1 == "A_MS" && part2 == "ACM") {
146  fmt.general = GeneralMediaFormat::MicrosoftAudioCodecManager;
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") {
175  fmt.general = GeneralMediaFormat::QuicktimeAudio;
176  } else if (part1 == "A_TTA1") {
177  fmt.general = GeneralMediaFormat::Tta;
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") {
199  fmt.general = GeneralMediaFormat::VobSub;
200  } else if (part1 == "S_KATE") {
201  fmt.general = GeneralMediaFormat::OggKate;
202  } else if (part1 == "B_VOBBTN") {
203  fmt.general = GeneralMediaFormat::VobBtn;
204  } else if (part1 == "S_DVBSUB") {
205  fmt.general = GeneralMediaFormat::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()) {
239  case TagTextEncoding::Latin1:
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;
315  m_mediaType = MediaType::Text;
316  break;
319  break;
322  break;
323  default:
324  m_mediaType = MediaType::Unknown;
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  diag.emplace_back(DiagLevel::Warning,
416  "\"TrackEntry\"-element contains a \"LanguageIETF\"-element which is not supported yet. It will be ignored.", context);
417  break;
419  m_format = codecIdToMediaFormat(m_formatId = trackInfoElement->readString());
420  break;
422  m_formatName = trackInfoElement->readString();
423  break;
425  break; // TODO
427  m_enabled = trackInfoElement->readUInteger();
428  break;
430  m_default = trackInfoElement->readUInteger();
431  break;
433  m_forced = trackInfoElement->readUInteger();
434  break;
436  m_lacing = trackInfoElement->readUInteger();
437  break;
439  defaultDuration = trackInfoElement->readUInteger();
440  break;
441  default:;
442  }
443  switch (m_mediaType) {
444  case MediaType::Video:
445  if (!m_fps && defaultDuration) {
446  m_fps = 1000000000.0 / defaultDuration;
447  }
448  break;
449  default:;
450  }
451  }
452 
453  // read further information from the CodecPrivate element for some codecs
454  EbmlElement *codecPrivateElement;
455  switch (m_format.general) {
456  case GeneralMediaFormat::MicrosoftVideoCodecManager:
457  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
458  // parse bitmap info header to determine actual format
459  if (codecPrivateElement->dataSize() >= 0x28) {
460  m_istream->seekg(static_cast<streamoff>(codecPrivateElement->dataOffset()));
461  BitmapInfoHeader bitmapInfoHeader;
462  bitmapInfoHeader.parse(reader());
463  m_formatId.reserve(m_formatId.size() + 7);
464  m_formatId += " \"";
465  m_formatId += interpretIntegerAsString(bitmapInfoHeader.compression);
466  m_formatId += "\"";
468  } else {
469  diag.emplace_back(DiagLevel::Critical, "BITMAPINFOHEADER structure (in \"CodecPrivate\"-element) is truncated.", context);
470  }
471  }
472  break;
473  case GeneralMediaFormat::MicrosoftAudioCodecManager:
474  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
475  // parse WAVE header to determine actual format
476  m_istream->seekg(static_cast<streamoff>(codecPrivateElement->dataOffset()));
477  WaveFormatHeader waveFormatHeader;
478  waveFormatHeader.parse(reader(), codecPrivateElement->dataSize(), diag);
479  WaveAudioStream::addInfo(waveFormatHeader, *this);
480  }
481  break;
483  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
484  auto audioSpecificConfig
485  = Mp4Track::parseAudioSpecificConfig(*m_istream, codecPrivateElement->dataOffset(), codecPrivateElement->dataSize(), diag);
487  audioSpecificConfig->audioObjectType, audioSpecificConfig->sbrPresent, audioSpecificConfig->psPresent);
488  if (audioSpecificConfig->sampleFrequencyIndex == 0xF) {
489  //m_samplingFrequency = audioSpecificConfig->sampleFrequency;
490  } else if (audioSpecificConfig->sampleFrequencyIndex < sizeof(mpeg4SamplingFrequencyTable)) {
491  //m_samplingFrequency = mpeg4SamplingFrequencyTable[audioSpecificConfig->sampleFrequencyIndex];
492  } else {
493  diag.emplace_back(DiagLevel::Warning, "Audio specific config has invalid sample frequency index.", context);
494  }
495  if (audioSpecificConfig->extensionSampleFrequencyIndex == 0xF) {
496  //m_extensionSamplingFrequency = audioSpecificConfig->extensionSampleFrequency;
497  } else if (audioSpecificConfig->extensionSampleFrequencyIndex < sizeof(mpeg4SamplingFrequencyTable)) {
498  //m_extensionSamplingFrequency = mpeg4SamplingFrequencyTable[audioSpecificConfig->extensionSampleFrequencyIndex];
499  } else {
500  diag.emplace_back(DiagLevel::Warning, "Audio specific config has invalid extension sample frequency index.", context);
501  }
502  m_channelConfig = audioSpecificConfig->channelConfiguration;
503  m_extensionChannelConfig = audioSpecificConfig->extensionChannelConfiguration;
504  }
505  break;
507  if ((codecPrivateElement = m_trackElement->childById(MatroskaIds::CodecPrivate, diag))) {
508  auto avcConfig = make_unique<TagParser::AvcConfiguration>();
509  try {
510  m_istream->seekg(static_cast<streamoff>(codecPrivateElement->dataOffset()));
511  avcConfig->parse(m_reader, codecPrivateElement->dataSize(), diag);
512  Mp4Track::addInfo(*avcConfig, *this);
513  } catch (const TruncatedDataException &) {
514  diag.emplace_back(DiagLevel::Critical, "AVC configuration is truncated.", context);
515  } catch (const Failure &) {
516  diag.emplace_back(DiagLevel::Critical, "AVC configuration is invalid.", context);
517  }
518  }
519  break;
520  default:;
521  }
522 
523  // parse format name for unknown formats
524  if (m_format.general == GeneralMediaFormat::Unknown && m_formatName.empty()) {
525  if (startsWith<string>(m_formatId, "V_") || startsWith<string>(m_formatId, "A_") || startsWith<string>(m_formatId, "S_")) {
526  m_formatName = m_formatId.substr(2);
527  } else {
529  }
530  m_formatName.append(" (unknown)");
531  }
532 
533  // use pixel size as display size if display size not specified
534  if (!m_displaySize.width()) {
536  }
537  if (!m_displaySize.height()) {
539  }
540 
541  // set English if no language has been specified (it is default value of MatroskaIds::TrackLanguage)
542  if (m_language.empty()) {
543  m_language = "eng";
544  }
545 }
546 
558 MatroskaTrackHeaderMaker::MatroskaTrackHeaderMaker(const MatroskaTrack &track, Diagnostics &diag)
559  : m_track(track)
560  , m_dataSize(0)
561 {
562  CPP_UTILITIES_UNUSED(diag);
563 
564  // calculate size for recognized elements
565  m_dataSize += 2 + 1 + EbmlElement::calculateUIntegerLength(m_track.id());
566  m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.trackNumber());
567  m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.isEnabled());
568  m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.isDefault());
569  m_dataSize += 2 + 1 + EbmlElement::calculateUIntegerLength(m_track.isForced());
570  if (!m_track.name().empty()) {
571  m_dataSize += 2 + EbmlElement::calculateSizeDenotationLength(m_track.name().size()) + m_track.name().size();
572  }
573  if (!m_track.language().empty()) {
574  m_dataSize += 3 + EbmlElement::calculateSizeDenotationLength(m_track.language().size()) + m_track.language().size();
575  }
576 
577  // calculate size for other elements
578  for (EbmlElement *trackInfoElement = m_track.m_trackElement->firstChild(); trackInfoElement; trackInfoElement = trackInfoElement->nextSibling()) {
579  switch (trackInfoElement->id()) {
587  // skip recognized elements
588  break;
589  default:
590  trackInfoElement->makeBuffer();
591  m_dataSize += trackInfoElement->totalSize();
592  }
593  }
594  m_sizeDenotationLength = EbmlElement::calculateSizeDenotationLength(m_dataSize);
595  m_requiredSize = 1 + m_sizeDenotationLength + m_dataSize;
596 }
597 
605 void MatroskaTrackHeaderMaker::make(ostream &stream) const
606 {
607  // make ID and size
608  char buffer[9];
609  *buffer = static_cast<char>(MatroskaIds::TrackEntry);
610  EbmlElement::makeSizeDenotation(m_dataSize, buffer + 1);
611  stream.write(buffer, 1 + m_sizeDenotationLength);
612 
613  // make recognized elements
619  if (!m_track.name().empty()) {
621  }
622  if (!m_track.language().empty()) {
624  }
625 
626  // make other elements
627  for (EbmlElement *trackInfoElement = m_track.m_trackElement->firstChild(); trackInfoElement; trackInfoElement = trackInfoElement->nextSibling()) {
628  switch (trackInfoElement->id()) {
636  // skip recognized elements
637  break;
638  default:
639  trackInfoElement->copyBuffer(stream);
640  }
641  }
642 }
643 
644 } // 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:131
TagParser::SubFormats::DtsLossless
@ DtsLossless
Definition: mediaformat.h:219
TagParser::MatroskaTagIds::TrackSpecific::writingDate
constexpr TAG_PARSER_EXPORT const char * writingDate()
Definition: matroskatagid.h:464
TagParser::AbstractTrack::m_colorSpace
std::uint32_t m_colorSpace
Definition: abstracttrack.h:167
TagParser::AbstractTrack::m_samplingFrequency
std::uint32_t m_samplingFrequency
Definition: abstracttrack.h:140
TagParser::SubFormats::ImgSubBmp
@ ImgSubBmp
Definition: mediaformat.h:234
TagParser::Mpeg4ElementaryStreamObjectIds::Aac
@ Aac
Definition: mp4ids.h:455
TagParser::MatroskaTrackType::Subtitle
@ Subtitle
Definition: matroskaid.h:405
TagParser::SubFormats::PcmIntBe
@ PcmIntBe
Definition: mediaformat.h:224
TagParser::SubFormats::ImageSubtitle
ImageSubtitle
Definition: mediaformat.h:234
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:405
TagParser::MatroskaIds::BitDepth
@ BitDepth
Definition: matroskaid.h:146
TagParser::MatroskaIds::PixelCropTop
@ PixelCropTop
Definition: matroskaid.h:131
TagParser::AbstractTrack::isEnabled
bool isEnabled() const
Returns true if the track is denoted as enabled; otherwise returns false.
Definition: abstracttrack.h:601
TagParser::AbstractTrack::m_enabled
bool m_enabled
Definition: abstracttrack.h:160
TagParser::AbstractTrack::m_bitrate
double m_bitrate
Definition: abstracttrack.h:135
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::MatroskaIds::PixelCropBottom
@ PixelCropBottom
Definition: matroskaid.h:130
TagParser::MatroskaIds::TrackLanguageIETF
@ TrackLanguageIETF
Definition: matroskaid.h:91
TagParser::MatroskaTagIds::TrackSpecific::bitrate
constexpr TAG_PARSER_EXPORT const char * bitrate()
The track's bit rate in bits per second.
Definition: matroskatagid.h:456
TagParser::SubFormats::AacMpeg4LongTermPrediction
@ AacMpeg4LongTermPrediction
Definition: mediaformat.h:121
TagParser::RawDataType::Utf8
@ Utf8
Definition: mp4tagfield.h:21
TagParser::BitmapInfoHeader::compression
std::uint32_t compression
Definition: bitmapinfoheader.h:25
TagParser::SubFormats::PlainUtf8Subtitle
@ PlainUtf8Subtitle
Definition: mediaformat.h:227
TagParser::MatroskaIds::TrackFlagDefault
@ TrackFlagDefault
Definition: matroskaid.h:79
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:139
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:146
TagParser::Margin::setBottom
void setBottom(std::uint32_t bottom)
Sets the bottom margin to bottom.
Definition: margin.h:91
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::SubFormats::Mpeg1Layer3
@ Mpeg1Layer3
Definition: mediaformat.h:112
TagParser::AbstractTrack::m_forced
bool m_forced
Definition: abstracttrack.h:162
TagParser::AbstractTrack::m_displaySize
Size m_displaySize
Definition: abstracttrack.h:151
TagParser::SubFormats::SubStationAlpha
@ SubStationAlpha
Definition: mediaformat.h:228
TagParser::SubFormats::Mpeg4SimpleProfile1
@ Mpeg4SimpleProfile1
Definition: mediaformat.h:139
TagParser::MatroskaIds::PixelCropLeft
@ PixelCropLeft
Definition: matroskaid.h:132
TagParser::TrackType::MatroskaTrack
@ MatroskaTrack
TagParser::FourccIds::Dts
@ Dts
Definition: mp4ids.h:259
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:128
TagParser::SubFormats::UniversalSubtitleFormat
@ UniversalSubtitleFormat
Definition: mediaformat.h:230
TagParser::SubFormats::AacMpeg2ScalableSamplingRateProfile
@ AacMpeg2ScalableSamplingRateProfile
Definition: mediaformat.h:117
TagParser::MatroskaIds::DisplayWidth
@ DisplayWidth
Definition: matroskaid.h:134
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:133
TagParser::AbstractTrack::m_formatId
std::string m_formatId
Definition: abstracttrack.h:126
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:129
TagParser::AbstractTrack::m_sampleCount
std::uint64_t m_sampleCount
Definition: abstracttrack.h:148
TagParser::Mpeg4ElementaryStreamObjectIds::Avc
@ Avc
Definition: mp4ids.h:451
TagParser::FourccIds::Flac
@ Flac
Definition: mp4ids.h:272
TagParser::AbstractTrack::m_reader
CppUtilities::BinaryReader m_reader
Definition: abstracttrack.h:121
TagParser::Margin::setTop
void setTop(std::uint32_t top)
Sets the top margin to top.
Definition: margin.h:59
TagParser::FourccIds::Opus
@ Opus
Definition: mp4ids.h:346
TagParser::AbstractTrack::isForced
bool isForced() const
Returns true if the track is denoted as forced; otherwise returns false.
Definition: abstracttrack.h:635
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::FourccIds::Ac3
@ Ac3
Definition: mp4ids.h:146
matroskatag.h
TagParser::MatroskaIds::DisplayHeight
@ DisplayHeight
Definition: matroskaid.h:135
TagParser::BitmapInfoHeader
The BitmapInfoHeader class parses the BITMAPINFOHEADER structure defined by MS.
Definition: bitmapinfoheader.h:14
TagParser::MatroskaIds::FrameRate
@ FrameRate
Definition: matroskaid.h:140
TagParser::MatroskaIds::PixelCropRight
@ PixelCropRight
Definition: matroskaid.h:133
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:405
TagParser::MatroskaIds::CodecDelay
@ CodecDelay
Definition: matroskaid.h:101
TagParser::MatroskaIds::TrackType
@ TrackType
Definition: matroskaid.h:77
TagParser::SubFormats::AacMpeg4LowComplexityProfile
@ AacMpeg4LowComplexityProfile
Definition: mediaformat.h:119
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:93
TagParser::FourccIds::Mpeg4Video
@ Mpeg4Video
Definition: mp4ids.h:331
TagParser::Mpeg4ElementaryStreamObjectIds::Mpeg1Audio
@ Mpeg1Audio
Definition: mp4ids.h:467
matroskaid.h
TagParser::SubFormats::TextSubtitle
TextSubtitle
Definition: mediaformat.h:226
TagParser::SubFormats::Mpeg4AdvancedSimpleProfile1
@ Mpeg4AdvancedSimpleProfile1
Definition: mediaformat.h:186
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:134
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:605
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:141
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:132
TagParser::MatroskaTrack::~MatroskaTrack
~MatroskaTrack() override
Destroys the track.
Definition: matroskatrack.cpp:46
TagParser::MatroskaIds::SamplingFrequency
@ SamplingFrequency
Definition: matroskaid.h:146
TagParser::FourccIds::Vp8
@ Vp8
Definition: mp4ids.h:387
TagParser::MatroskaIds::CodecName
@ CodecName
Definition: matroskaid.h:94
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:130
TagParser::MatroskaIds::TrackName
@ TrackName
Definition: matroskaid.h:89
TagParser::MatroskaIds::ColorSpace
@ ColorSpace
Definition: matroskaid.h:138
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:105
CppUtilities
Definition: abstractcontainer.h:15
TagParser::Mpeg4ElementaryStreamObjectIds::Vc1
@ Vc1
Definition: mp4ids.h:473
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:161
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:144
TagParser::AbstractTrack::m_pixelSize
Size m_pixelSize
Definition: abstracttrack.h:150
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:138
TagParser::AbstractTrack::m_mediaType
MediaType m_mediaType
Definition: abstracttrack.h:128
TagParser::SubFormats::Mpeg1Layer2
@ Mpeg1Layer2
Definition: mediaformat.h:112
TagParser::MediaFormat::general
GeneralMediaFormat general
Definition: mediaformat.h:258
TagParser::FourccIds::Vp9
@ Vp9
Definition: mp4ids.h:388
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:142
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.
Definition: tagvalue.h:75
TagParser::MatroskaIds::CodecID
@ CodecID
Definition: matroskaid.h:92
TagParser::AbstractTrack::m_format
MediaFormat m_format
Definition: abstracttrack.h:125
TagParser::FourccIds::Alac
@ Alac
Definition: mp4ids.h:150
TagParser::AbstractTrack::language
const std::string & language() const
Returns the language of the track if known; otherwise returns an empty string.
Definition: abstracttrack.h:417
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::Mpeg4ElementaryStreamObjectIds::Mpeg1Video
@ Mpeg1Video
Definition: mp4ids.h:466
TagParser::Size::height
constexpr std::uint32_t height() const
Returns the height.
Definition: size.h:67
TagParser::FourccIds::EAc3
@ EAc3
Definition: mp4ids.h:266
TagParser::AbstractTrack::m_fps
std::uint32_t m_fps
Definition: abstracttrack.h:155
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:341
TagParser::AbstractTrack::reader
CppUtilities::BinaryReader & reader()
Returns a binary reader for the associated stream.
Definition: abstracttrack.h:218
TagParser::SubFormats::AacMpeg2LowComplexityProfile
@ AacMpeg2LowComplexityProfile
Definition: mediaformat.h:116
TagParser::MatroskaTrackType::Video
@ Video
Definition: matroskaid.h:405
TagParser::AbstractTrack::m_lacing
bool m_lacing
Definition: abstracttrack.h:163
TagParser::AbstractTrack::isDefault
bool isDefault() const
Returns true if the track is denoted as default; otherwise returns false.
Definition: abstracttrack.h:618
ebmlelement.h
TagParser::AbstractTrack::m_channelConfig
std::uint8_t m_channelConfig
Definition: abstracttrack.h:145
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:451
TagParser::MatroskaTrack::internalParseHeader
void internalParseHeader(Diagnostics &diag) override
This method is internally called to parse header information.
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:127
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:158
TagParser::SubFormats::PcmIntLe
@ PcmIntLe
Definition: mediaformat.h:224
TagParser::MatroskaIds::TrackAudio
@ TrackAudio
Definition: matroskaid.h:104
TagParser::AbstractTrack::m_creationTime
CppUtilities::DateTime m_creationTime
Definition: abstracttrack.h:137
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:358
TagParser::MatroskaIds::Channels
@ Channels
Definition: matroskaid.h:146
TagParser::MatroskaIds::FlagInterlaced
@ FlagInterlaced
Definition: matroskaid.h:124
TagParser::AbstractTrack::m_cropping
Margin m_cropping
Definition: abstracttrack.h:168
TagParser::MediaFormat
The MediaFormat class specifies the format of media data.
Definition: mediaformat.h:245
TagParser::AbstractTrack::m_istream
std::istream * m_istream
Definition: abstracttrack.h:119
TagParser::MatroskaTrackType::Audio
@ Audio
Definition: matroskaid.h:405
TagParser::SubFormats::AdvancedSubStationAlpha
@ AdvancedSubStationAlpha
Definition: mediaformat.h:229
TagParser::AbstractTrack::m_extensionChannelConfig
std::uint8_t m_extensionChannelConfig
Definition: abstracttrack.h:146
TagParser::AbstractTrack::trackNumber
std::uint32_t trackNumber() const
Returns the track number if known; otherwise returns 0.
Definition: abstracttrack.h:324