Tag Parser 11.0.0
C++ library for reading and writing MP4 (iTunes), ID3, Vorbis, Opus, FLAC and Matroska tags
mp4track.h
Go to the documentation of this file.
1#ifndef TAG_PARSER_MP4TRACK_H
2#define TAG_PARSER_MP4TRACK_H
3
4#include "../abstracttrack.h"
5
6#include <memory>
7#include <vector>
8
9namespace TagParser {
10
11class Mp4Atom;
12class Mpeg4Descriptor;
13struct AvcConfiguration;
14struct Av1Configuration;
15struct TrackHeaderInfo;
16struct Mp4Timings;
17
19public:
21
22 std::uint8_t audioObjectType;
24 std::uint32_t sampleFrequency;
34 std::uint16_t coreCoderDelay;
35 std::uint8_t extensionFlag;
36 std::uint8_t layerNr;
37 std::uint8_t numOfSubFrame;
38 std::uint16_t layerLength;
39 std::uint8_t resilienceFlags;
40 std::uint8_t epConfig;
41};
42
44public:
46
47 std::uint8_t profile;
48 std::string userData;
49};
50
52public:
54
55 bool dependencyFlag() const;
56 bool urlFlag() const;
57 bool ocrFlag() const;
58 std::uint8_t priority() const;
59 std::uint8_t streamTypeId() const;
60 bool upstream() const;
61
62 std::uint16_t id;
63 std::uint8_t esDescFlags;
64 std::uint16_t dependsOnId;
65 std::string url;
66 std::uint16_t ocrId;
67 std::uint8_t objectTypeId;
68 std::uint8_t decCfgDescFlags;
69 std::uint32_t bufferSize;
70 std::uint32_t maxBitrate;
71 std::uint32_t averageBitrate;
72 std::unique_ptr<Mpeg4AudioSpecificConfig> audioSpecificConfig;
73 std::unique_ptr<Mpeg4VideoSpecificConfig> videoSpecificConfig;
74};
75
77 : id(0)
78 , esDescFlags(0)
79 , dependsOnId(0)
80 , ocrId(0)
81 , objectTypeId(0)
82 , decCfgDescFlags(0)
83 , bufferSize(0)
84 , maxBitrate(0)
85 , averageBitrate(0)
86{
87}
88
90{
91 return esDescFlags & 0x80;
92}
93
95{
96 return esDescFlags & 0x40;
97}
98
100{
101 return esDescFlags & 0x20;
102}
103
104inline std::uint8_t Mpeg4ElementaryStreamInfo::priority() const
105{
106 return esDescFlags & 0x1F;
107}
108
110{
111 return decCfgDescFlags >> 2;
112}
113
115{
116 return decCfgDescFlags & 0x02;
117}
118
120public:
121 Mp4Track(Mp4Atom &trakAtom);
122 ~Mp4Track() override;
123 TrackType type() const override;
124
125 // getter methods specific for MP4 tracks
126 Mp4Atom &trakAtom();
127 const std::vector<std::uint32_t> &sampleSizes() const;
128 unsigned int chunkOffsetSize() const;
129 std::uint32_t chunkCount() const;
130 std::uint32_t sampleToChunkEntryCount() const;
131 const Mpeg4ElementaryStreamInfo *mpeg4ElementaryStreamInfo() const;
132 const AvcConfiguration *avcConfiguration() const;
133 const Av1Configuration *av1Configuration() const;
134
135 // methods to parse configuration details from the track header
136 static std::unique_ptr<Mpeg4ElementaryStreamInfo> parseMpeg4ElementaryStreamInfo(
137 CppUtilities::BinaryReader &reader, Mp4Atom *esDescAtom, Diagnostics &diag);
138 static std::unique_ptr<Mpeg4AudioSpecificConfig> parseAudioSpecificConfig(
139 std::istream &stream, std::uint64_t startOffset, std::uint64_t size, Diagnostics &diag);
140 static std::unique_ptr<Mpeg4VideoSpecificConfig> parseVideoSpecificConfig(
141 CppUtilities::BinaryReader &reader, std::uint64_t startOffset, std::uint64_t size, Diagnostics &diag);
142
143 // methods to read the "index" (chunk offsets and sizes)
144 std::vector<std::uint64_t> readChunkOffsets(bool parseFragments, Diagnostics &diag);
145 std::vector<std::tuple<std::uint32_t, std::uint32_t, std::uint32_t>> readSampleToChunkTable(Diagnostics &diag);
146 std::vector<std::uint64_t> readChunkSizes(TagParser::Diagnostics &diag);
147
148 // methods to make the track header
149 void bufferTrackAtoms(Diagnostics &diag);
150 std::uint64_t requiredSize(Diagnostics &diag) const;
151 void makeTrack(Diagnostics &diag);
152 void makeTrackHeader(Diagnostics &diag);
153 void makeMedia(Diagnostics &diag);
154 void makeMediaInfo(Diagnostics &diag);
155 void makeSampleTable(Diagnostics &diag);
156
157 // methods to update chunk offsets
158 void updateChunkOffsets(const std::vector<std::int64_t> &oldMdatOffsets, const std::vector<std::int64_t> &newMdatOffsets);
159 void updateChunkOffsets(const std::vector<std::uint64_t> &chunkOffsets);
160 void updateChunkOffset(std::uint32_t chunkIndex, std::uint64_t offset);
161
162 static void addInfo(const AvcConfiguration &avcConfig, AbstractTrack &track);
163 static void addInfo(const Av1Configuration &av1Config, AbstractTrack &track);
164
165protected:
166 void internalParseHeader(Diagnostics &diag, AbortableProgressFeedback &progress) override;
167
168private:
169 // private helper methods
170 std::uint64_t accumulateSampleSizes(std::size_t &sampleIndex, std::size_t count, Diagnostics &diag);
171 void addChunkSizeEntries(
172 std::vector<std::uint64_t> &chunkSizeTable, std::size_t count, std::size_t &sampleIndex, std::uint32_t sampleCount, Diagnostics &diag);
173 const TrackHeaderInfo &verifyPresentTrackHeader() const;
174 Mp4Timings computeTimings() const;
175
176 Mp4Atom *m_trakAtom;
177 Mp4Atom *m_tkhdAtom;
178 Mp4Atom *m_mdiaAtom;
179 Mp4Atom *m_mdhdAtom;
180 Mp4Atom *m_hdlrAtom;
181 Mp4Atom *m_minfAtom;
182 Mp4Atom *m_stblAtom;
183 Mp4Atom *m_stsdAtom;
184 Mp4Atom *m_stscAtom;
185 Mp4Atom *m_stcoAtom;
186 Mp4Atom *m_stszAtom;
187 std::uint32_t m_rawMediaType;
188 std::uint16_t m_framesPerSample;
189 std::vector<std::uint32_t> m_sampleSizes;
190 unsigned int m_chunkOffsetSize;
191 std::uint32_t m_chunkCount;
192 std::uint32_t m_sampleToChunkEntryCount;
193 std::uint64_t m_rawTkhdCreationTime;
194 std::uint64_t m_rawMdhdCreationTime;
195 std::uint64_t m_rawTkhdModificationTime;
196 std::uint64_t m_rawMdhdModificationTime;
197 std::uint64_t m_rawTkhdDuration;
198 std::uint64_t m_rawMdhdDuration;
199 std::unique_ptr<Mpeg4ElementaryStreamInfo> m_esInfo;
200 std::unique_ptr<AvcConfiguration> m_avcConfig;
201 std::unique_ptr<Av1Configuration> m_av1Config;
202 mutable std::unique_ptr<TrackHeaderInfo> m_trackHeaderInfo;
203};
204
209{
210 return *m_trakAtom;
211}
212
220inline const std::vector<std::uint32_t> &Mp4Track::sampleSizes() const
221{
222 return m_sampleSizes;
223}
224
230inline unsigned int Mp4Track::chunkOffsetSize() const
231{
232 return m_chunkOffsetSize;
233}
234
238inline std::uint32_t Mp4Track::chunkCount() const
239{
240 return m_chunkCount;
241}
242
246inline std::uint32_t Mp4Track::sampleToChunkEntryCount() const
247{
248 return m_sampleToChunkEntryCount;
249}
250
259{
260 return m_esInfo.get();
261}
262
270{
271 return m_avcConfig.get();
272}
273
281{
282 return m_av1Config.get();
283}
284
285} // namespace TagParser
286
287#endif // TAG_PARSER_MP4TRACK_H
The AbortableProgressFeedback class provides feedback about an ongoing operation via callbacks.
The AbstractTrack class parses and stores technical information about video, audio and other kinds of...
The Diagnostics class is a container for DiagMessage.
Definition: diagnostics.h:156
The Mp4Atom class helps to parse MP4 files.
Definition: mp4atom.h:38
Implementation of TagParser::AbstractTrack for the MP4 container.
Definition: mp4track.h:119
const Av1Configuration * av1Configuration() const
Returns the AV1 configuration.
Definition: mp4track.h:280
std::uint32_t chunkCount() const
Returns the number of chunks denoted by the stco atom.
Definition: mp4track.h:238
std::uint32_t sampleToChunkEntryCount() const
Returns the number of "sample to chunk" entries within the stsc atom.
Definition: mp4track.h:246
const std::vector< std::uint32_t > & sampleSizes() const
Returns the sample size table for the track.
Definition: mp4track.h:220
unsigned int chunkOffsetSize() const
Returns the size of a single chunk offset denotation within the stco atom.
Definition: mp4track.h:230
const Mpeg4ElementaryStreamInfo * mpeg4ElementaryStreamInfo() const
Returns information about the MPEG-4 elementary stream.
Definition: mp4track.h:258
const AvcConfiguration * avcConfiguration() const
Returns the AVC configuration.
Definition: mp4track.h:269
Mp4Atom & trakAtom()
Returns the trak atom for the current instance.
Definition: mp4track.h:208
The Mpeg4AudioSpecificConfig class holds MPEG-4 audio specific config parsed using Mp4Track::parseAud...
Definition: mp4track.h:18
std::uint32_t extensionSampleFrequency
Definition: mp4track.h:30
std::uint8_t extensionChannelConfiguration
Definition: mp4track.h:31
std::uint8_t extensionSampleFrequencyIndex
Definition: mp4track.h:29
The Mpeg4ElementaryStreamInfo class holds MPEG-4 elementary stream info parsed using Mp4Track::parseM...
Definition: mp4track.h:51
std::unique_ptr< Mpeg4AudioSpecificConfig > audioSpecificConfig
Definition: mp4track.h:72
std::uint8_t priority() const
Definition: mp4track.h:104
std::uint8_t streamTypeId() const
Definition: mp4track.h:109
std::unique_ptr< Mpeg4VideoSpecificConfig > videoSpecificConfig
Definition: mp4track.h:73
The Mpeg4VideoSpecificConfig class holds MPEG-4 video specific config parsed using Mp4Track::parseVid...
Definition: mp4track.h:43
#define TAG_PARSER_EXPORT
Marks the symbol to be exported by the tagparser library.
Contains all classes and functions of the TagInfo library.
Definition: aaccodebook.h:10
TrackType
The TrackType enum specifies the underlying file type of a track and the concrete class of the track ...
Definition: abstracttrack.h:31
The Av1Configuration struct provides a parser for AV1 configuration found in ISOBMFF files.
The AvcConfiguration struct provides a parser for AVC configuration.
The Mp4Timings struct holds timing values found in multiple MP4 atoms.
Definition: mp4track.cpp:36
The TrackHeaderInfo struct holds information about the present track header (tkhd atom) and informati...
Definition: mp4track.cpp:50