Tag Parser 11.0.0
C++ library for reading and writing MP4 (iTunes), ID3, Vorbis, Opus, FLAC and Matroska tags
mp4tag.cpp
Go to the documentation of this file.
1#include "./mp4tag.h"
2#include "./mp4atom.h"
3#include "./mp4container.h"
4#include "./mp4ids.h"
5
6#include "../exceptions.h"
7
8#include <c++utilities/conversion/stringconversion.h>
9#include <c++utilities/io/binarywriter.h>
10
11using namespace std;
12using namespace CppUtilities;
13
14namespace TagParser {
15
26{
27 switch (field) {
31 updateOnly = false;
32 break;
36 updateOnly = true; // set record label via extended field only if extended field is already present
37 break;
38 default:;
39 }
40}
41
48{
49 switch (encoding) {
51 return true;
53 return true;
54 default:
55 return false;
56 }
57}
58
60{
61 switch (field) {
62 case KnownField::Genre: {
64 if (!value.isEmpty()) {
65 return value;
66 } else {
68 }
69 }
74 if (!value.isEmpty()) {
75 return value;
76 } else {
78 }
79 }
80 default:
82 }
83}
84
85std::vector<const TagValue *> Mp4Tag::values(KnownField field) const
86{
88 if (const auto extendedId = Mp4ExtendedFieldId(field)) {
89 auto range = fields().equal_range(Mp4TagAtomIds::Extended);
90 for (auto i = range.first; i != range.second; ++i) {
91 const auto &extendedField = i->second;
92 if (extendedId.matches(extendedField)) {
93 values.emplace_back(&extendedField.value());
94 for (const auto &additionalData : extendedField.additionalData()) {
95 values.emplace_back(&additionalData.value);
96 }
97 }
98 }
99 }
100 return values;
101}
102
108const TagValue &Mp4Tag::value(std::string_view mean, std::string_view name) const
109{
110 auto range = fields().equal_range(Mp4TagAtomIds::Extended);
111 for (auto i = range.first; i != range.second; ++i) {
112 if (i->second.mean() == mean && i->second.name() == name) {
113 return i->second.value();
114 }
115 }
116 return TagValue::empty();
117}
118
120{
121 using namespace Mp4TagAtomIds;
122 switch (field) {
124 return Album;
126 return Artist;
128 return Comment;
130 return Year;
132 return Title;
134 return Genre;
136 return TrackPosition;
138 return DiskPosition;
140 return Composer;
142 return Encoder;
143 case KnownField::Bpm:
144 return Bpm;
146 return Cover;
148 return Rating;
150 return Grouping;
152 return Description;
154 return Lyrics;
156 return RecordLabel;
158 return Performers;
160 return Lyricist;
162 return AlbumArtist;
163 default:
164 return 0;
165 }
166 // do not forget to extend Mp4Tag::internallyGetKnownField() and Mp4TagField::appropriateRawDataType() as well
167}
168
169KnownField Mp4Tag::internallyGetKnownField(const IdentifierType &id) const
170{
171 using namespace Mp4TagAtomIds;
172 switch (id) {
173 case Album:
174 return KnownField::Album;
175 case Artist:
176 return KnownField::Artist;
177 case Comment:
178 return KnownField::Comment;
179 case Year:
181 case Title:
182 return KnownField::Title;
183 case PreDefinedGenre:
184 case Genre:
185 return KnownField::Genre;
186 case TrackPosition:
188 case DiskPosition:
190 case Composer:
192 case Encoder:
193 return KnownField::Encoder;
194 case Bpm:
195 return KnownField::Bpm;
196 case Cover:
197 return KnownField::Cover;
198 case Rating:
199 return KnownField::Rating;
200 case Grouping:
202 case Description:
204 case Lyrics:
205 return KnownField::Lyrics;
206 case RecordLabel:
208 case Performers:
210 case Lyricist:
212 case AlbumArtist:
214 default:
215 return KnownField::Invalid;
216 }
217 // do not forget to extend Mp4Tag::internallyGetFieldId() and Mp4TagField::appropriateRawDataType() as well
218}
219
223void Mp4Tag::internallyGetValuesFromField(const Mp4Tag::FieldType &field, std::vector<const TagValue *> &values) const
224{
225 if (!field.value().isEmpty()) {
226 values.emplace_back(&field.value());
227 }
228 for (const auto &value : field.additionalData()) {
229 if (!value.value.isEmpty()) {
230 values.emplace_back(&value.value);
231 }
232 }
233}
234
235bool Mp4Tag::setValue(KnownField field, const TagValue &value)
236{
237 switch (field) {
239 switch (value.type()) {
243 default:
246 }
252 }
253 [[fallthrough]];
254 default:
256 }
257}
258
259bool Mp4Tag::setValues(KnownField field, const std::vector<TagValue> &values)
260{
261 if (const auto extendedId = Mp4ExtendedFieldId(field)) {
262 auto valuesIterator = values.cbegin();
263 auto range = fields().equal_range(Mp4TagAtomIds::Extended);
264 for (; valuesIterator != values.cend() && range.first != range.second;) {
265 if (!valuesIterator->isEmpty()) {
266 auto &extendedField = range.first->second;
267 if (extendedId.matches(extendedField) && (!extendedId.updateOnly || !extendedField.value().isEmpty())) {
268 extendedField.clearValue();
269 extendedField.setValue(*valuesIterator);
270 // note: Not sure which extended tag fields support multiple data atoms and which don't. Let's simply use
271 // only one data atom per extended field here and get rid of any possibly assigned additional data
272 // atoms.
273 ++valuesIterator;
274 }
275 ++range.first;
276 } else {
277 ++valuesIterator;
278 }
279 }
280 for (; valuesIterator != values.cend(); ++valuesIterator) {
281 if (valuesIterator->isEmpty()) {
282 fields().emplace(std::piecewise_construct, std::forward_as_tuple(Mp4TagAtomIds::Extended),
283 std::forward_as_tuple(extendedId.mean, extendedId.name, *valuesIterator));
284 }
285 }
286 for (; range.first != range.second; ++range.first) {
287 range.first->second.clearValue();
288 }
289 }
291}
292
300bool Mp4Tag::setValue(std::string_view mean, std::string_view name, const TagValue &value)
301{
302 auto range = fields().equal_range(Mp4TagAtomIds::Extended);
303 for (auto i = range.first; i != range.second; ++i) {
304 if (i->second.mean() == mean && i->second.name() == name) {
305 i->second.setValue(value);
306 return true;
307 }
308 }
309 fields().insert(make_pair(Mp4TagAtomIds::Extended, FieldType(mean, name, value)));
310 return true;
311}
312
314{
315 switch (field) {
318 default:
320 }
321}
322
330void Mp4Tag::parse(Mp4Atom &metaAtom, Diagnostics &diag)
331{
332 static const string context("parsing MP4 tag");
333 m_size = metaAtom.totalSize();
334 istream &stream = metaAtom.container().stream();
335 BinaryReader &reader = metaAtom.container().reader();
336 if (metaAtom.totalSize() > numeric_limits<std::uint32_t>::max()) {
337 diag.emplace_back(DiagLevel::Critical, "Can't handle such big \"meta\" atoms.", context);
339 }
340 Mp4Atom *subAtom = nullptr;
341 try {
343 } catch (const Failure &) {
344 diag.emplace_back(DiagLevel::Critical, "Unable to parse child atoms of meta atom (stores hdlr and ilst atoms).", context);
345 }
346 if (subAtom) {
347 stream.seekg(static_cast<streamoff>(subAtom->startOffset() + subAtom->headerSize()));
348 int versionByte = reader.readByte();
349 if (versionByte != 0) {
350 diag.emplace_back(DiagLevel::Warning, "Version is unknown.", context);
351 }
352 if (reader.readUInt24BE()) {
353 diag.emplace_back(DiagLevel::Warning, "Flags (hdlr atom) aren't set to 0.", context);
354 }
355 if (reader.readInt32BE()) {
356 diag.emplace_back(DiagLevel::Warning, "Predefined 32-bit integer (hdlr atom) isn't set to 0.", context);
357 }
358 std::uint64_t handlerType = reader.readUInt64BE();
359 if (/*(((handlerType & 0xFFFFFFFF00000000) >> 32) != 0x6D647461) && */ (handlerType != 0x6d6469726170706c)) {
360 diag.emplace_back(DiagLevel::Warning, "Handler type (value in hdlr atom) is unknown. Trying to parse meta information anyhow.", context);
361 }
362 m_version = numberToString(versionByte);
363 } else {
364 m_version.clear();
365 }
366 try {
367 subAtom = metaAtom.childById(Mp4AtomIds::ItunesList, diag);
368 } catch (const Failure &) {
369 diag.emplace_back(DiagLevel::Critical, "Unable to parse child atoms of meta atom (stores hdlr and ilst atoms).", context);
370 }
371 if (!subAtom) {
372 diag.emplace_back(DiagLevel::Warning, "No ilst atom found (stores attached meta information).", context);
373 throw NoDataFoundException();
374 }
375 for (auto *child = subAtom->firstChild(); child; child = child->nextSibling()) {
376 Mp4TagField tagField;
377 try {
378 child->parse(diag);
379 tagField.reparse(*child, diag);
380 fields().emplace(child->id(), move(tagField));
381 } catch (const Failure &) {
382 }
383 }
384}
385
397{
398 return Mp4TagMaker(*this, diag);
399}
400
407void Mp4Tag::make(ostream &stream, Diagnostics &diag)
408{
409 prepareMaking(diag).make(stream, diag);
410}
411
423Mp4TagMaker::Mp4TagMaker(Mp4Tag &tag, Diagnostics &diag)
424 : m_tag(tag)
425 ,
426 // meta head, hdlr atom
427 m_metaSize(8 + 37)
428 ,
429 // ilst head
430 m_ilstSize(8)
431 ,
432 // ensure there only one genre atom is written (prefer genre as string)
433 m_omitPreDefinedGenre(m_tag.fields().count(m_tag.hasField(Mp4TagAtomIds::Genre)))
434{
435 m_maker.reserve(m_tag.fields().size());
436 for (auto &field : m_tag.fields()) {
437 if (!field.second.value().isEmpty() && (!m_omitPreDefinedGenre || field.first != Mp4TagAtomIds::PreDefinedGenre)) {
438 try {
439 m_ilstSize += m_maker.emplace_back(field.second.prepareMaking(diag)).requiredSize();
440 } catch (const Failure &) {
441 }
442 }
443 }
444 if (m_ilstSize != 8) {
445 m_metaSize += m_ilstSize;
446 }
447 if (m_metaSize >= numeric_limits<std::uint32_t>::max()) {
448 diag.emplace_back(DiagLevel::Critical, "Making such big tags is not implemented.", "making MP4 tag");
449 throw NotImplementedException();
450 }
451}
452
460void Mp4TagMaker::make(ostream &stream, Diagnostics &diag)
461{
462 // write meta head
463 BinaryWriter writer(&stream);
464 writer.writeUInt32BE(static_cast<std::uint32_t>(m_metaSize));
465 writer.writeUInt32BE(Mp4AtomIds::Meta);
466 // write hdlr atom
467 static const std::uint8_t hdlrData[37] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x68, 0x64, 0x6C, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
468 0x00, 0x00, 0x00, 0x6D, 0x64, 0x69, 0x72, 0x61, 0x70, 0x70, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
469 stream.write(reinterpret_cast<const char *>(hdlrData), sizeof(hdlrData));
470 if (m_ilstSize != 8) {
471 // write ilst head
472 writer.writeUInt32BE(static_cast<std::uint32_t>(m_ilstSize));
473 writer.writeUInt32BE(Mp4AtomIds::ItunesList);
474 // write fields
475 for (auto &maker : m_maker) {
476 maker.make(stream);
477 }
478 } else {
479 // no fields to be written -> no ilst to be written
480 diag.emplace_back(DiagLevel::Warning, "Tag is empty.", "making MP4 tag");
481 }
482}
483
484} // namespace TagParser
The Diagnostics class is a container for DiagMessage.
Definition: diagnostics.h:156
The class inherits from std::exception and serves as base class for exceptions thrown by the elements...
Definition: exceptions.h:11
bool setValue(const IdentifierType &id, const TagValue &value)
Assigns the given value to the field with the specified id.
bool hasField(KnownField field) const
Returns an indication whether the specified field is present.
typename FieldMapBasedTagTraits< Mp4Tag >::FieldType::IdentifierType IdentifierType
Definition: fieldbasedtag.h:36
const TagValue & value(const IdentifierType &id) const
Returns the value of the field with the specified id.
const std::multimap< IdentifierType, FieldType, Compare > & fields() const
Returns the fields of the tag by providing direct access to the field map of the tag.
typename FieldMapBasedTagTraits< Mp4Tag >::FieldType FieldType
Definition: fieldbasedtag.h:35
std::vector< const TagValue * > values(const IdentifierType &id) const
Returns the values of the field with the specified id.
bool setValues(const IdentifierType &id, const std::vector< TagValue > &values)
Assigns the given values to the field with the specified id.
std::uint64_t startOffset() const
Returns the start offset in the related stream.
std::uint32_t headerSize() const
Returns the header size of the element in byte.
ImplementationType * childById(const IdentifierType &id, Diagnostics &diag)
Returns the first child with the specified id.
ImplementationType * nextSibling()
Returns the next sibling of the element.
ImplementationType * firstChild()
Returns the first child of the element.
std::uint64_t totalSize() const
Returns the total size of the element.
ContainerType & container()
Returns the related container.
The Mp4Atom class helps to parse MP4 files.
Definition: mp4atom.h:38
The Mp4TagField class is used by Mp4Tag to store the fields.
Definition: mp4tagfield.h:112
void reparse(Mp4Atom &ilstChild, Diagnostics &diag)
Parses field information from the specified Mp4Atom.
Definition: mp4tagfield.cpp:73
The Mp4TagMaker class helps writing MP4 tags.
Definition: mp4tag.h:54
void make(std::ostream &stream, Diagnostics &diag)
Saves the tag (specified when constructing the object) to the specified stream.
Definition: mp4tag.cpp:460
Implementation of TagParser::Tag for the MP4 container.
Definition: mp4tag.h:97
std::vector< const TagValue * > values(KnownField field) const override
Returns the values of the specified field.
Definition: mp4tag.cpp:85
const TagValue & value(KnownField value) const override
Returns the value of the specified field.
Definition: mp4tag.cpp:59
bool hasField(KnownField value) const override
Returns an indication whether the specified field is present.
Definition: mp4tag.cpp:313
bool setValue(KnownField field, const TagValue &value) override
Assigns the given value to the specified field.
Definition: mp4tag.cpp:235
IdentifierType internallyGetFieldId(KnownField field) const
Definition: mp4tag.cpp:119
Mp4TagMaker prepareMaking(Diagnostics &diag)
Prepares making.
Definition: mp4tag.cpp:396
bool setValues(KnownField field, const std::vector< TagValue > &values) override
Assigns the given values to the specified field.
Definition: mp4tag.cpp:259
void parse(Mp4Atom &metaAtom, Diagnostics &diag)
Parses tag information from the specified metaAtom.
Definition: mp4tag.cpp:330
void make(std::ostream &stream, Diagnostics &diag)
Writes tag information to the specified stream.
Definition: mp4tag.cpp:407
bool canEncodingBeUsed(TagTextEncoding encoding) const override
Returns an indication whether the specified encoding can be used to provide string values for the tag...
Definition: mp4tag.cpp:47
KnownField internallyGetKnownField(const IdentifierType &id) const
Definition: mp4tag.cpp:169
void internallyGetValuesFromField(const FieldType &field, std::vector< const TagValue * > &values) const
Adds values from additional data atoms as well.
Definition: mp4tag.cpp:223
The exception that is thrown when the data to be parsed holds no parsable information (e....
Definition: exceptions.h:18
This exception is thrown when the an operation is invoked that has not been implemented yet.
Definition: exceptions.h:60
The TagValue class wraps values of different types.
Definition: tagvalue.h:95
TagDataType type() const
Returns the type of the assigned value.
Definition: tagvalue.h:468
static const TagValue & empty()
Returns a default-constructed TagValue where TagValue::isNull() and TagValue::isEmpty() both return t...
Definition: tagvalue.cpp:958
bool isEmpty() const
Returns whether no or an empty value is assigned.
Definition: tagvalue.h:525
std::string m_version
Definition: tag.h:144
std::uint64_t m_size
Definition: tag.h:145
Contains all classes and functions of the TagInfo library.
Definition: aaccodebook.h:10
KnownField
Specifies the field.
Definition: tag.h:42
TagTextEncoding
Specifies the text encoding.
Definition: tagvalue.h:28
The Mp4ExtendedFieldId specifies parameter for an extended field denoted via Mp4TagAtomIds::Extended.
Definition: mp4tag.h:13
bool updateOnly
Whether only existing fields should be updated but no new extended field should be created.
Definition: mp4tag.h:25
std::string_view mean
mean parameter, usually Mp4TagExtendedMeanIds::iTunes
Definition: mp4tag.h:21
Mp4ExtendedFieldId(std::string_view mean, std::string_view name, bool updateOnly=false)
Constructs a new instance with the specified parameter.
Definition: mp4tag.h:31
std::string_view name
name parameter
Definition: mp4tag.h:23