Tag Parser 11.5.1
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 Ar = 0x213C617263683E0A,
17 Asf1 = 0x3026B2758E66CF11ul,
18 Asf2 = 0xA6D900AA0062CE6Cul,
19 Png = 0x89504E470D0A1A0Aul,
20 RiffAvi = 0x415649204C495354ul,
21 YUV4Mpeg2 = 0x595556344D504547ul,
22};
23
27enum Sig56 : std::uint64_t {
28 Rar = 0x526172211A0700ul,
29};
30
34enum Sig48 : std::uint64_t {
35 Gif87a = 0x474946383761ul,
36 Gif89a = 0x474946383961ul,
37 SevenZ = 0x377ABCAF271Cul,
38 Xz = 0xFD377A585A00ul,
39};
40
44enum Sig40 : std::uint64_t {
45 Aiff = 0x464F524D00ul,
46};
47
51enum Sig32 : std::uint32_t {
52 Dirac = 0x42424344u,
53 Elf = 0x7F454C46u,
54 Flac = 0x664C6143u,
55 Ivf = 0x444B4946u,
56 JavaClassFile = 0xCAFEBABEu,
57 Ebml = 0x1A45DFA3u,
58 Midi = 0x4D546864u,
59 MonkeysAudio = 0x4D414320u,
60 Mp4 = 0x66747970u,
61 Ogg = 0x4F676753u,
62 PhotoshopDocument = 0x38425053u,
63 QuickTime = 0x6D6F6F76u,
64 Riff = 0x52494646u,
65 RiffWave = 0x57415645u,
66 TiffBigEndian = 0x4D4D002Au,
67 TiffLittleEndian = 0x49492A00u,
68 Utf32Text = 0xFFFE0000u,
69 WavPack = 0x7776706Bu,
70 WindowsIcon = 0x00000100u,
71 Lzip = 0x4C5A4950u,
72 Zip1 = 0x504B0304u,
73 Zip2 = 0x504B0506u,
74 Zip3 = 0x504B0708u,
75};
76
80enum Sig24 : std::uint32_t {
81 Bzip2 = 0x425A68u,
82 Flv = 0x464C56u,
83 Gzip = 0x1F8B08u,
84 Id3v2 = 0x494433u,
85 Utf8Text = 0xEFBBBFu,
86};
87
91enum Sig16 : std::uint16_t {
92 Ac3 = 0x0B77u,
93 Adts = 0xFFF0u,
94 AdtsMask = 0xFFF6u,
95 Jpeg = 0xffd8u,
96 Lha = 0x1FA0u,
97 Lzw = 0x1F9Du,
100 Utf16Text = 0xFFFEu,
101 WindowsBitmap = 0x424du,
102};
103
111ContainerFormat parseSignature(std::string_view buffer)
112{
113 // read signature
114 std::uint64_t sig = 0;
115 if (buffer.size() >= 8) {
116 sig = BE::toUInt64(buffer.data());
117 } else if (buffer.size() >= 4) {
118 sig = BE::toUInt32(buffer.data());
119 sig <<= 4;
120 } else if (buffer.size() >= 2) {
121 sig = BE::toUInt16(buffer.data());
122 sig <<= 6;
123 } else {
125 }
126 // return corresponding container format
127 switch (sig) { // check 64-bit signatures
128 case Ar:
129 return ContainerFormat::Ar;
130 case Asf1:
132 case Asf2:
134 case Png:
136 case YUV4Mpeg2:
137 if (buffer.size() >= 10 && buffer[8] == 0x32 && buffer[9] == 0x20) {
139 }
140 break;
141 default:;
142 }
143 switch (sig & 0x00000000FFFFFFFF) { // check 32-bit signatures @ bit 31
144 case Mp4:
146 case QuickTime:
148 default:;
149 }
150 switch (sig >> 8) { // check 56-bit signatures
151 case Rar:
153 default:;
154 }
155 switch (sig >> 16) { // check 48-bit signatures
156 case Gif87a:
158 case Gif89a:
160 case SevenZ:
162 case Xz:
163 return ContainerFormat::Xz;
164 default:;
165 }
166 switch (sig >> 24) { // check 40-bit signatures
167 case Aiff:
169 default:;
170 }
171 switch (sig >> 32) { // check 32-bit signatures
172 case Dirac:
174 case Elf:
176 case Flac:
178 case Ivf:
180 case JavaClassFile:
182 case Ebml:
184 case Midi:
186 case MonkeysAudio:
188 case Ogg:
192 case Riff:
193 if (buffer.size() >= 16 && BE::toUInt64(buffer.data() + 8) == Sig64::RiffAvi) {
195 } else if (buffer.size() >= 12 && BE::toUInt32(buffer.data() + 8) == RiffWave) {
197 } else {
199 }
200 case TiffBigEndian:
202 case TiffLittleEndian:
204 case Utf32Text:
206 case WavPack:
208 case WindowsIcon:
210 case Lzip:
212 case Zip1:
213 case Zip2:
214 case Zip3:
216 default:;
217 }
218 switch (sig >> 40) { // check 24-bit signatures
219 case Bzip2:
221 case Flv:
223 case Gzip:
225 case Id3v2:
227 case Utf8Text:
229 }
230 switch (sig >> 48) { // check 16-bit signatures
231 case Ac3:
233 case Jpeg:
235 case Lha:
237 case Lzw:
241 case Utf16Text:
243 case WindowsBitmap:
245 default:;
246 }
247 // check other signatures
248 if (((sig >> 48) & AdtsMask) == Adts) {
250 }
251 if ((sig >> 53) == MpegAudioFrames) {
253 }
255}
256
263std::string_view containerFormatAbbreviation(ContainerFormat containerFormat, MediaType mediaType, unsigned int version)
264{
265 switch (containerFormat) {
267 return "ac3";
269 return "a";
271 return "asf";
273 return "drc";
275 return "elf";
277 return "flac";
279 return "flv";
282 return "gif";
284 return "ivf";
286 return "class";
288 return "jpeg";
290 return "lzh";
292 return "lzw";
294 switch (mediaType) {
295 case MediaType::Audio:
296 return "m4a";
297 default:
298 return "mp4";
299 }
301 switch (mediaType) {
302 case MediaType::Video:
303 return "ogv";
304 default:
305 switch (version) {
306 case static_cast<unsigned int>(GeneralMediaFormat::Opus):
307 return "opus";
308 case static_cast<unsigned int>(GeneralMediaFormat::Speex):
309 return "spx";
310 default:
311 return "ogg";
312 }
313 }
315 return "psd";
317 return "png";
319 return "exe";
321 return "rar";
323 switch (mediaType) {
324 case MediaType::Audio:
325 return "mka";
326 default:
327 return "mkv";
328 }
330 switch (version) {
331 case 1:
332 return "mp1";
333 case 2:
334 return "mp2";
335 default:
336 return "mp3";
337 }
339 return "riff";
341 return "wav";
343 return "avi";
345 return "tar";
348 return "tiff";
350 return "bmp";
352 return "ico";
354 return "bz";
356 return "gz";
358 return "lz";
360 return "mov";
362 return "zip";
364 return "7z";
366 return "xz";
368 return "y4m";
370 return "wv";
372 return "ape";
374 return "mid";
376 return "aiff";
377 default:
378 return "";
379 }
380}
381
387std::string_view containerFormatName(ContainerFormat containerFormat)
388{
389 switch (containerFormat) {
391 return "raw Dolby Digital";
393 return "Audio Data Transport Stream";
395 return "Archive (GNU ar)";
397 return "Advanced Systems Format";
399 return "raw Dirac";
401 return "Executable and Linkable Format";
403 return "raw Free Lossless Audio Codec frames";
405 return "Flash Video";
408 return "Graphics Interchange Format";
410 return "IVF";
412 return "Java class file";
414 return "JPEG File Interchange Format";
416 return "LHA compressed file";
418 return "LZW compressed file";
420 return "MPEG-4 Part 14";
422 return "Ogg transport bitstream";
424 return "Photoshop document";
426 return "Portable Network Graphics";
428 return "Portable Executable";
430 return "RAR Archive";
432 return "EBML";
434 return "Matroska";
436 return "WebM";
438 return "MPEG-1 Layer 1/2/3 frames";
440 return "Resource Interchange File Format";
442 return "RIFF/WAVE";
444 return "RIFF/Audio Video Interleave";
446 return "TAR archive";
449 return "Tagged Image File Format";
451 return "UTF-16 text";
453 return "UTF-32 text";
455 return "UTF-8 text";
457 return "WavPack";
459 return "Microsoft Windows Bitmap";
461 return "Microsoft Windows Icon";
463 return "bzip2 compressed file";
465 return "gzip compressed file";
467 return "lzip compressed file";
469 return "7z archive";
471 return "Quick Time";
473 return "xz compressed file";
475 return "YUV4MPEG2";
477 return "ZIP archive";
479 return "Monkey's Audio";
481 return "MIDI";
483 return "Audio Interchange File Format";
484 default:
485 return "unknown";
486 }
487}
488
494std::string_view containerFormatSubversion(ContainerFormat containerFormat)
495{
496 switch (containerFormat) {
498 return "87a";
500 return "89a";
502 return "big endian";
504 return "little endian";
505 default:
506 return "";
507 }
508}
509
515std::string_view containerMimeType(ContainerFormat containerFormat, MediaType mediaType)
516{
517 switch (containerFormat) {
519 return "audio/ac3";
521 return "video/x-ms-asf";
523 return "audio/flac";
525 return "video/x-flv";
528 return "image/gif";
530 return "image/jpeg";
532 return "image/png";
534 return "audio/mpeg";
536 switch (mediaType) {
537 case MediaType::Audio:
538 return "audio/mp4";
539 default:
540 return "video/mp4";
541 }
543 switch (mediaType) {
544 case MediaType::Audio:
545 return "audio/ogg";
546 default:
547 return "video/ogg";
548 }
550 switch (mediaType) {
551 case MediaType::Audio:
552 return "audio/x-matroska";
553 default:
554 return "video/x-matroska";
555 }
557 return "audio/midi";
559 return "application/x-bzip";
561 return "application/gzip";
563 return "application/x-lzh-compressed";
565 return "application/x-rar-compressed";
567 return "application/x-lzip";
569 return "video/quicktime";
571 return "application/zip";
573 return "application/x-7z-compressed";
575 return "application/x-xz";
577 return "image/bmp";
579 return "image/vnd.microsoft.icon";
580 default:
581 return "";
582 }
583}
584
588TagTargetLevel containerTargetLevel(ContainerFormat containerFormat, std::uint64_t targetLevelValue)
589{
590 switch (containerFormat) {
593 return matroskaTagTargetLevel(targetLevelValue);
594 default:
596 }
597}
598
602std::uint64_t containerTargetLevelValue(ContainerFormat containerFormat, TagTargetLevel targetLevel)
603{
604 switch (containerFormat) {
607 return matroskaTagTargetLevelValue(targetLevel);
608 default:
609 return 0;
610 }
611}
612
613} // 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 as C-style string.
Definition: signature.cpp:494
Sig16
Holds 16-bit signatures.
Definition: signature.cpp:91
@ PortableExecutable
Definition: signature.cpp:99
@ MpegAudioFrames
Definition: signature.cpp:98
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 as C-style string considering the specified media ty...
Definition: signature.cpp:263
Sig24
Holds 24-bit signatures.
Definition: signature.cpp:80
Sig48
Holds 48-bit signatures.
Definition: signature.cpp:34
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 as C-style string.
Definition: signature.cpp:387
TAG_PARSER_EXPORT ContainerFormat parseSignature(const char *buffer, std::size_t bufferSize)
Definition: signature.h:81
TAG_PARSER_EXPORT std::string_view containerMimeType(ContainerFormat containerFormat, MediaType mediaType=MediaType::Unknown)
Returns the MIME-type of the container format as C-style string.
Definition: signature.cpp:515
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:27
TAG_PARSER_EXPORT TagTargetLevel containerTargetLevel(ContainerFormat containerFormat, std::uint64_t targetLevelValue)
Returns the general TagTargetLevel for the specified container format and raw targetLevelValue.
Definition: signature.cpp:588
Sig32
Holds 32-bit signatures.
Definition: signature.cpp:51
@ TiffBigEndian
Definition: signature.cpp:66
@ PhotoshopDocument
Definition: signature.cpp:62
@ TiffLittleEndian
Definition: signature.cpp:67
@ MonkeysAudio
Definition: signature.cpp:59
@ JavaClassFile
Definition: signature.cpp:56
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.
Definition: signature.cpp:602
ContainerFormat
Specifies the container format.
Definition: signature.h:18
Sig40
Holds 40-bit signatures.
Definition: signature.cpp:44