Tag Parser 12.5.3
C++ library for reading and writing MP4 (iTunes), ID3, Vorbis, Opus, FLAC and Matroska tags
Loading...
Searching...
No Matches
signature.cpp
Go to the documentation of this file.
1#include "./signature.h"
3
4#include <c++utilities/conversion/binaryconversion.h>
5
6#include <cstdint>
7
8using namespace CppUtilities;
9
10namespace TagParser {
11
15enum Sig64 : std::uint64_t {
16 ApeTag = 0x4150455441474558ul, // APETAGEX
17 Ar = 0x213C617263683E0A,
18 Asf1 = 0x3026B2758E66CF11ul,
19 Asf2 = 0xA6D900AA0062CE6Cul,
20 Png = 0x89504E470D0A1A0Aul,
21 RiffAvi = 0x415649204C495354ul,
22 YUV4Mpeg2 = 0x595556344D504547ul,
23};
24
28enum Sig56 : std::uint64_t {
29 Rar = 0x526172211A0700ul,
30};
31
35enum Sig48 : std::uint64_t {
36 Gif87a = 0x474946383761ul,
37 Gif89a = 0x474946383961ul,
38 SevenZ = 0x377ABCAF271Cul,
39 Xz = 0xFD377A585A00ul,
40};
41
45enum Sig40 : std::uint64_t {
46 Aiff = 0x464F524D00ul,
47};
48
52enum Sig32 : std::uint32_t {
53 Dirac = 0x42424344u,
54 Elf = 0x7F454C46u,
55 Flac = 0x664C6143u,
56 Ivf = 0x444B4946u,
57 JavaClassFile = 0xCAFEBABEu,
58 Ebml = 0x1A45DFA3u,
59 Midi = 0x4D546864u,
60 MonkeysAudio = 0x4D414320u,
61 Mp4 = 0x66747970u,
62 Ogg = 0x4F676753u,
63 PhotoshopDocument = 0x38425053u,
64 QuickTime = 0x6D6F6F76u,
65 Riff = 0x52494646u,
66 RiffWave = 0x57415645u,
67 TiffBigEndian = 0x4D4D002Au,
68 TiffLittleEndian = 0x49492A00u,
69 Utf32Text = 0xFFFE0000u,
70 WavPack = 0x7776706Bu,
71 WindowsIcon = 0x00000100u,
72 Lzip = 0x4C5A4950u,
73 Zip1 = 0x504B0304u,
74 Zip2 = 0x504B0506u,
75 Zip3 = 0x504B0708u,
76 Zstd = 0x28b52ffdu,
77};
78
82enum Sig24 : std::uint32_t {
83 Bzip2 = 0x425A68u,
84 Flv = 0x464C56u,
85 Gzip = 0x1F8B08u,
86 Id3v2 = 0x494433u,
87 Utf8Text = 0xEFBBBFu,
88};
89
93enum Sig16 : std::uint16_t {
94 Ac3 = 0x0B77u,
95 Adts = 0xFFF0u,
96 AdtsMask = 0xFFF6u,
97 Jpeg = 0xffd8u,
98 Lha = 0x1FA0u,
99 Lzw = 0x1F9Du,
102 Utf16Text = 0xFFFEu,
103 WindowsBitmap = 0x424du,
104};
105
113ContainerFormat parseSignature(std::string_view buffer)
114{
115 // read signature
116 std::uint64_t sig = 0;
117 if (buffer.size() >= 8) {
118 sig = BE::toInt<std::uint64_t>(buffer.data());
119 } else if (buffer.size() >= 4) {
120 sig = BE::toInt<std::uint32_t>(buffer.data());
121 sig <<= 4;
122 } else if (buffer.size() >= 2) {
123 sig = BE::toInt<std::uint16_t>(buffer.data());
124 sig <<= 6;
125 } else {
127 }
128 // return corresponding container format
129 switch (sig) { // check 64-bit signatures
130 case ApeTag:
132 case Ar:
133 return ContainerFormat::Ar;
134 case Asf1:
136 case Asf2:
138 case Png:
140 case YUV4Mpeg2:
141 if (buffer.size() >= 10 && buffer[8] == 0x32 && buffer[9] == 0x20) {
143 }
144 break;
145 default:;
146 }
147 switch (sig & 0x00000000FFFFFFFF) { // check 32-bit signatures @ bit 31
148 case Mp4:
150 case QuickTime:
152 default:;
153 }
154 switch (sig >> 8) { // check 56-bit signatures
155 case Rar:
157 default:;
158 }
159 switch (sig >> 16) { // check 48-bit signatures
160 case Gif87a:
162 case Gif89a:
164 case SevenZ:
166 case Xz:
167 return ContainerFormat::Xz;
168 default:;
169 }
170 switch (sig >> 24) { // check 40-bit signatures
171 case Aiff:
173 default:;
174 }
175 switch (sig >> 32) { // check 32-bit signatures
176 case Dirac:
178 case Elf:
180 case Flac:
182 case Ivf:
184 case JavaClassFile:
186 case Ebml:
188 case Midi:
190 case MonkeysAudio:
192 case Ogg:
196 case Riff:
197 if (buffer.size() >= 16 && BE::toInt<std::uint64_t>(buffer.data() + 8) == Sig64::RiffAvi) {
199 } else if (buffer.size() >= 12 && BE::toInt<std::uint32_t>(buffer.data() + 8) == RiffWave) {
201 } else {
203 }
204 case TiffBigEndian:
206 case TiffLittleEndian:
208 case Utf32Text:
210 case WavPack:
212 case WindowsIcon:
214 case Lzip:
216 case Zip1:
217 case Zip2:
218 case Zip3:
220 case Zstd:
222 default:;
223 }
224 switch (sig >> 40) { // check 24-bit signatures
225 case Bzip2:
227 case Flv:
229 case Gzip:
231 case Id3v2:
233 case Utf8Text:
235 }
236 switch (sig >> 48) { // check 16-bit signatures
237 case Ac3:
239 case Jpeg:
241 case Lha:
243 case Lzw:
247 case Utf16Text:
249 case WindowsBitmap:
251 default:;
252 }
253 // check other signatures
254 if (((sig >> 48) & AdtsMask) == Adts) {
256 }
257 if ((sig >> 53) == MpegAudioFrames) {
259 }
261}
262
268std::string_view containerFormatAbbreviation(ContainerFormat containerFormat, MediaType mediaType, unsigned int version)
269{
270 switch (containerFormat) {
272 return "ac3";
274 return "a";
276 return "asf";
278 return "drc";
280 return "elf";
282 return "flac";
284 return "flv";
287 return "gif";
289 return "ivf";
291 return "class";
293 return "jpeg";
295 return "lzh";
297 return "lzw";
299 switch (mediaType) {
300 case MediaType::Audio:
301 return "m4a";
302 default:
303 return "mp4";
304 }
306 switch (mediaType) {
307 case MediaType::Video:
308 return "ogv";
309 default:
310 switch (version) {
311 case static_cast<unsigned int>(GeneralMediaFormat::Opus):
312 return "opus";
313 case static_cast<unsigned int>(GeneralMediaFormat::Speex):
314 return "spx";
315 default:
316 return "ogg";
317 }
318 }
320 return "psd";
322 return "png";
324 return "exe";
326 return "rar";
328 switch (mediaType) {
329 case MediaType::Audio:
330 return "mka";
331 default:
332 return "mkv";
333 }
335 switch (version) {
336 case 1:
337 return "mp1";
338 case 2:
339 return "mp2";
340 default:
341 return "mp3";
342 }
344 return "riff";
346 return "wav";
348 return "avi";
350 return "tar";
353 return "tiff";
355 return "bmp";
357 return "ico";
359 return "bz";
361 return "gz";
363 return "lz";
365 return "mov";
367 return "zip";
369 return "7z";
371 return "xz";
373 return "y4m";
375 return "wv";
377 return "ape";
379 return "mid";
381 return "aiff";
383 return "zst";
384 default:
385 return "";
386 }
387}
388
393std::string_view containerFormatName(ContainerFormat containerFormat)
394{
395 switch (containerFormat) {
397 return "raw Dolby Digital";
399 return "Audio Data Transport Stream";
401 return "Archive (GNU ar)";
403 return "Advanced Systems Format";
405 return "raw Dirac";
407 return "Executable and Linkable Format";
409 return "raw Free Lossless Audio Codec frames";
411 return "Flash Video";
414 return "Graphics Interchange Format";
416 return "IVF";
418 return "Java class file";
420 return "JPEG File Interchange Format";
422 return "LHA compressed file";
424 return "LZW compressed file";
426 return "MPEG-4 Part 14";
428 return "Ogg transport bitstream";
430 return "Photoshop document";
432 return "Portable Network Graphics";
434 return "Portable Executable";
436 return "RAR Archive";
438 return "EBML";
440 return "Matroska";
442 return "WebM";
444 return "MPEG-1 Layer 1/2/3 frames";
446 return "Resource Interchange File Format";
448 return "RIFF/WAVE";
450 return "RIFF/Audio Video Interleave";
452 return "TAR archive";
455 return "Tagged Image File Format";
457 return "UTF-16 text";
459 return "UTF-32 text";
461 return "UTF-8 text";
463 return "WavPack";
465 return "Microsoft Windows Bitmap";
467 return "Microsoft Windows Icon";
469 return "bzip2 compressed file";
471 return "gzip compressed file";
473 return "lzip compressed file";
475 return "7z archive";
477 return "Quick Time";
479 return "xz compressed file";
481 return "YUV4MPEG2";
483 return "ZIP archive";
485 return "Monkey's Audio";
487 return "MIDI";
489 return "Audio Interchange File Format";
491 return "Zstandard compressed file";
493 return "ID3v2 tag";
495 return "APE tag";
496 default:
497 return "unknown";
498 }
499}
500
505std::string_view containerFormatSubversion(ContainerFormat containerFormat)
506{
507 switch (containerFormat) {
509 return "87a";
511 return "89a";
513 return "big endian";
515 return "little endian";
516 default:
517 return "";
518 }
519}
520
525std::string_view containerMimeType(ContainerFormat containerFormat, MediaType mediaType)
526{
527 switch (containerFormat) {
529 return "audio/ac3";
531 return "video/x-ms-asf";
533 return "audio/flac";
535 return "video/x-flv";
538 return "image/gif";
540 return "image/jpeg";
542 return "image/png";
544 return "audio/mpeg";
546 switch (mediaType) {
547 case MediaType::Audio:
548 return "audio/mp4";
549 default:
550 return "video/mp4";
551 }
553 switch (mediaType) {
554 case MediaType::Audio:
555 return "audio/ogg";
556 default:
557 return "video/ogg";
558 }
560 switch (mediaType) {
561 case MediaType::Audio:
562 return "audio/x-matroska";
563 default:
564 return "video/x-matroska";
565 }
567 return "audio/midi";
569 return "application/x-bzip";
571 return "application/gzip";
573 return "application/x-lzh-compressed";
575 return "application/x-rar-compressed";
577 return "application/x-lzip";
579 return "video/quicktime";
581 return "application/zip";
583 return "application/x-7z-compressed";
585 return "application/x-xz";
587 return "image/bmp";
589 return "image/vnd.microsoft.icon";
591 return "application/zstd";
592 default:
593 return "";
594 }
595}
596
600TagTargetLevel containerTargetLevel(ContainerFormat containerFormat, std::uint64_t targetLevelValue)
601{
602 switch (containerFormat) {
605 return matroskaTagTargetLevel(targetLevelValue);
606 default:
608 }
609}
610
614std::uint64_t containerTargetLevelValue(ContainerFormat containerFormat, TagTargetLevel targetLevel)
615{
616 switch (containerFormat) {
619 return matroskaTagTargetLevelValue(targetLevel);
620 default:
621 return 0;
622 }
623}
624
625} // namespace TagParser
Contains all classes and functions of the TagInfo library.
Definition aaccodebook.h:10
TAG_PARSER_EXPORT std::string_view containerFormatSubversion(ContainerFormat containerFormat)
Returns the subversion of the container format.
Sig16
Holds 16-bit signatures.
Definition signature.cpp:93
@ PortableExecutable
TagTargetLevel
The TagTargetLevel enum specifies tag target levels.
Definition tagtarget.h:16
TAG_PARSER_EXPORT std::string_view containerFormatAbbreviation(ContainerFormat containerFormat, MediaType mediaType=MediaType::Unknown, unsigned int version=0)
Returns the abbreviation of the container format considering the specified media type and version.
Sig24
Holds 24-bit signatures.
Definition signature.cpp:82
Sig48
Holds 48-bit signatures.
Definition signature.cpp:35
constexpr TAG_PARSER_EXPORT std::uint64_t matroskaTagTargetLevelValue(TagTargetLevel targetLevel)
Returns the Matroska specific target level value for the specified general targetLevel.
TAG_PARSER_EXPORT std::string_view containerFormatName(ContainerFormat containerFormat)
Returns the name of the specified container format.
TAG_PARSER_EXPORT ContainerFormat parseSignature(const char *buffer, std::size_t bufferSize)
Definition signature.h:83
TAG_PARSER_EXPORT std::string_view containerMimeType(ContainerFormat containerFormat, MediaType mediaType=MediaType::Unknown)
Returns the MIME-type of the container format.
constexpr TAG_PARSER_EXPORT TagTargetLevel matroskaTagTargetLevel(std::uint64_t targetLevelValue)
Returns the general TagTargetLevel for the Matroska specific targetLevelValue.
Sig56
Holds 52-bit signatures.
Definition signature.cpp:28
TAG_PARSER_EXPORT TagTargetLevel containerTargetLevel(ContainerFormat containerFormat, std::uint64_t targetLevelValue)
Returns the general TagTargetLevel for the specified container format and raw targetLevelValue.
Sig32
Holds 32-bit signatures.
Definition signature.cpp:52
@ PhotoshopDocument
Definition signature.cpp:63
@ TiffLittleEndian
Definition signature.cpp:68
MediaType
The MediaType enum specifies the type of media data (audio, video, text, ...).
Definition mediaformat.h:14
Sig64
Holds 64-bit signatures.
Definition signature.cpp:15
TAG_PARSER_EXPORT std::uint64_t containerTargetLevelValue(ContainerFormat containerFormat, TagTargetLevel targetLevel)
Returns the raw target level value for the specified containerFormat and general targetLevel.
ContainerFormat
Specifies the container format.
Definition signature.h:18
Sig40
Holds 40-bit signatures.
Definition signature.cpp:45