ID3v2.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
 
#if __DCL_WINDOWS
#include <windows.h>
#endif
 
#include <dcl/size_t.h>
#include <dcl/String.h>
#include <dcl/Charset.h>
#include <dcl/File.h>
 
#include "ID3v2.h"
 
#define __TRACE_THIS    0
#if __TRACE_THIS
#define __DCL_TRACE1_N  __DCL_TRACE1
#define __DCL_TRACE2_N  __DCL_TRACE2
#define __DCL_TRACE3_N  __DCL_TRACE3
#define __DCL_TRACE4_N  __DCL_TRACE4
#else
#define __DCL_TRACE1_N(fmt, arg)
#define __DCL_TRACE2_N(fmt, arg1, arg2)
#define __DCL_TRACE3_N(fmt, arg1, arg2, arg3)
#define __DCL_TRACE4_N(fmt, arg1, arg2, arg3, arg4)
#endif
 
__DCL_BEGIN_NAMESPACE
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("media/ID3v2.cpp");
#endif
 
IMPLEMENT_CLASSINFO(ID3v2, Object)
 
ID3v2::ID3v2()
    : __header{'\0', }, __data(NULL), __fsbits(0)
{
}
 
ID3v2::~ID3v2()
{
    if (__data) {
        free(__data);
        __data = NULL;
    }
 
    for (size_t i = 0; i < __frames.size(); i++) {
        delete (ID3v2Frame*)__frames[i];
    }
}
 
uint32_t ID3v2::word7(const char* _bytes, size_t _n)
{
    uint32_t r = 0;
    const char* end = _bytes + _n;
    while (_bytes < end) {
        r = r << 7 | (0x7f & *_bytes++);
    }
    return r;
}
 
uint32_t ID3v2::word8(const char* _bytes, size_t _n)
{
    uint32_t r = 0;
    const char* end = _bytes + _n;
    while (_bytes < end) {
        // r = r << 7 | (0x7f & *_bytes++);
        // spec에는 최상위 비트를 사용하지 않는다고 되어 있는데
        // 사용하는 경우가 있다. 버그를 허용한다.
        r = r << 8 | ((byte_t)*_bytes++);
    }
    return r;
}
 
bool __IS_UPPER(const char* _begin, const char* _end)
{
    while (_begin < _end) {
        if (!(isupper(*_begin) || isdigit(*_begin))) {
            return false;
        }
        _begin++;
    }
    return true;
}
 
int __find_frame_size_bits(char _version,
    const char* _begin, const char* _end, bool _debug)
{
    size_t __3_or_4 = 3;
    size_t __6_or_10 = 6;
    if (_version > 2) {
        __3_or_4 = 4;
        __6_or_10 = 10;
    }
 
    // 8bits를 검사한다.
    const char* p = _begin;
    bool valid = true;
    while (p + __6_or_10 < _end && *p != '\0') {
        if (__IS_UPPER(p, p + __3_or_4)) {
            String name = AsciiDecoder::decode(p, __3_or_4);
            uint32_t size = ID3v2::word8(p + __3_or_4, __3_or_4);
            if (_debug) {
                __DCL_TRACE2(L"[%ls][%d]\n", name.data(), size);
            }
            p += size + __6_or_10;
        }
        else {
            if (_debug) {
                __DCL_TRACE0(L"false\n");
            }
            valid = false;
            break;
        }
    }
 
    if (p > _end || (p < _end && *p != '\0')) {
        // 마지막 프레임의 size로 인해 p가 _end 지나쳤거나
        // padding 위치가 아니면
        if (_debug) {
            __DCL_TRACE3(L"false [%p][%p][%x]\n", p, _end, *p);
        }
        valid = false;
    }
 
    if (valid) {
        return 8;
    }
 
    // 7bits를 검사한다.
    p = _begin;
    valid = true;
    while (p + __6_or_10 < _end && *p != '\0') {
        if (__IS_UPPER(p, p + __3_or_4)) {
            String name = AsciiDecoder::decode(p, __3_or_4);
            uint32_t size = ID3v2::word7(p + __3_or_4, __3_or_4);
            if (_debug) {
                __DCL_TRACE2(L"[%ls][%d]\n", name.data(), size);
            }
            p += size + __6_or_10;
        }
        else {
            if (_debug) {
                __DCL_TRACE0(L"false\n");
            }
            valid = false;
            break;
        }
    }
 
    if (p > _end || (p < _end && *p != '\0')) {
        // 마지막 프레임의 size로 인해 p가 _end 지나쳤거나
        // padding 위치가 아니면
        if (_debug) {
            __DCL_TRACE3(L"false [%p][%p][%x]\n", p, _end, *p);
        }
        valid = false;
    }
 
    if (valid) {
        return 7;
    }
 
    return 0;
}
 
bool ID3v2::read(File& _file, const char _header[10])
{
    char buf[10];
    if (_header == NULL) {
        // 파일의 처음으로 이동한다.
        _file.seek(0, File::BEGIN);
        size_t n = _file.read(buf, 10);
        if (n < 10) {
            return false;
        }
        _header = buf;
    }
    else {
        _file.seek(10, File::BEGIN);
    }
 
    __DCL_TRACE1_N(L"[%ls]\n", String::tryString(_header, 10).data());
    if (!(_header[0] == 'I' && _header[1] == 'D' && _header[2] == '3'
        && _header[3] <= 4      // version 4
        // _header[4]   revision
        // _header[5]   flags
        && _header[6] < 0x80 && _header[7] < 0x80   // size
        && _header[8] < 0x80 && _header[9] < 0x80)) {
        return false;
    }
 
    __ID3 = AsciiDecoder::decode(&_header[0], 3);
    __size = word7(&_header[6], 4);
 
    __data = (char*) malloc(__size);
    size_t n = _file.read(__data, __size);
    if (n < __size) {
        return false;
    }
 
    memcpy(__header, _header, 10);
    __DCL_TRACE1_N(L"%ls\n", toString().data());
    __DCL_TRACE1_N(L"data [%ls]\n", String::tryString(__data, n, 200).data());
 
    const char* _begin = __data;
    const char* _end = _begin + n;
 
    // Extended header 있으면 이것을 SKIP 한다.
    if (Extended_header(flags())) {
        _begin += skipExtendedHeader(_begin, _end);
    }
 
    // 프레임을 검사한다.
    __fsbits = __find_frame_size_bits(version(), _begin, _end, false);
    if (__fsbits == 0) {
        __DCL_TRACE1(L"ID3v2 Invalid Frames [%ls]\n", _file.path().data());
        __fsbits = __find_frame_size_bits(version(), _begin, _end, true);
        return false;
    }
 
    // 프레임을 읽는다.
    // 최소 프레임 헤더는 6 또는 10 bytes 이어야 한다.
    // Padding은 $00으로 체워져 있다.
    size_t __3_or_4 = 3;
    size_t __6_or_10 = 6;
    if (version() > 2) {
        __3_or_4 = 4;
        __6_or_10 = 10;
    }
    while ((_begin + __6_or_10 < _end) && *_begin != '\0') {
        if ('A' <= *_begin && *_begin <= 'Z') {
            ID3v2Frame* frame = new ID3v2Frame(*this);
            _begin += frame->read(_begin, _end);
#ifdef __DCL_DEBUG
            try {
                __DCL_TRACE1_N(L"[%ls]\n", frame->toString().data());
            }
            catch (Exception* e) {
                __DCL_TRACE1_N(L"%ls\n", e->toStringAll().data());
                __DCL_TRACE1_N(L"[%ls]\n", String::tryString(_begin, _end - _begin, 80).data());
                e->destroy();
            }
#endif
            __frames.add(frame);
        }
        else {
            __DCL_TRACE1(L"ID3v2 Frame Read Failed [%ls]\n", _file.path().data());
        //  throw new GenerialException(L"ID3v2 Frame Read Failed ["
        //      + _file.path() + L"]");
            break;
        }
    }
 
    return true;
}
 
String ID3v2::toString() const
{
    return String::format(L""
        "%ls version[%d] revision[%d] flags[%x] size[%d] fsbits[%d]",
        ID3().data(), version(), revision(), flags(), size(), fsbits()
    );
}
 
size_t ID3v2::skipExtendedHeader(
        const char* _begin,
        const char* _end
    ) const
{
    // 최소 6 bytes 되어야 한다.
    __DCL_ASSERT(_begin + 6 <= _end);
    uint32_t r = word7(&_begin[0], 4);
    __DCL_TRACE1(L"Number of flag bytes [%d]\n", (int)_begin[4]);
    return r;
}
 
IMPLEMENT_CLASSINFO(ID3v2Frame, Object)
 
ID3v2Frame::ID3v2Frame(const ID3v2& _tag)
    : __tag(_tag)
{
    __size = 0;
    __flags = 0;
    __encoding = 0;
    __type = 0;
}
 
String ID3v2Frame::decode(
        char _encoding,
        const char* _mbs, size_t _nmbs
    ) const
{
    String r;
    try {
        switch (_encoding) {
            default:
            case 0: {
                Latin1Decoder decoder;
                r = decoder.decode(_mbs, _nmbs);
                break;
            }
            case 1: {
                if (_nmbs == 2 && (byte_t)*_mbs == 0xFF) {
                    /*
                    UTF-16에서 BOM이 포함되면, 길이가 0인 문자열이
                    "$FF $FE $00 $00"의 바이트로 표현된다.
                    UTF16Decoder::decodede에 BOM "$FF $FE" "$FE $FF"만 주어지면
                    CS_SOURCE_FEW 예외가 발생한다.
                    UTF16Decoder::decodede에 "$FF $FE $00 $00"을 적용하면
                    L"\0" 길이가 1인 String을 반환한다.
                    _nmbs는 $00 직전까지를 이므로, 이 경우는 제외한다.
                    */
                    break;
                }
                UTF16Decoder decoder(CS_LITTLE_ENDIAN);
                r = decoder.decode(_mbs, _nmbs);
                break;
            }
            case 2: {
                if (_nmbs == 2 && (byte_t)*_mbs == 0xFE) {
                    // "$FE $FF"를 제외한다.
                    break;
                }
                UTF16Decoder decoder(CS_BIG_ENDIAN);
                r = decoder.decode(_mbs, _nmbs);
                break;
            }
            case 3: {
                UTF8Decoder decoder;
                r = decoder.decode(_mbs, _nmbs);
                break;
            }
        }
    }
    catch (Exception* _e) {
        __DCL_TRACE3_N(L"%ls[%zd][%ls]\n", _e->toStringAll().data(),
            _nmbs, String::tryString(_mbs, _nmbs).data());
        _e->destroy();
    }
    return r;
}
 
size_t __decode_length__(char _encoding, const char* _psz, size_t _max)
{
    __DCL_ASSERT_PARAM(_psz != NULL);
    size_t r = 0;
    if (_encoding == 1 || _encoding == 2) {
        // UTF-16 LE (1), UTF-16 BE (2)
        while ((*_psz++ | *_psz++) && r < _max) {
            r++; r++;
        }
        return r < _max ? r: _max;
    }
    else {
        // ISO-8859-1 (0), UTF-8 (3)
        // cf. ByteString::length(const char* _psz, size_t _max)
        while (*_psz++ && r < _max) {
            r++;
        }
    }
    return r;
}
 
size_t __skip_length__(char _encoding, size_t _n)
{
    // UTF-16은 $00 $00, ASCII ISO-8858-1 UTF-8는 $00
    return _encoding == 1 || _encoding == 2 ? _n + 2 : _n + 1;
}
 
bool __valid_language_code(const char _lang[3])
{
    // https://www.loc.gov/standards/iso639-2/
    return (_lang[0] == 'X' && _lang[1] == 'X' && _lang[2] == 'X') ||
        (islower(_lang[0]) && islower(_lang[1]) && islower(_lang[2]));
}
 
size_t ID3v2Frame::read(const char* _begin, const char* _end)
{
    size_t __6_OR_10__ = __tag.version() == 2 ? 6 : 10;
    // 프레임 헤더를 읽는다.
    // 최소 __6_OR_10__ bytes보다 커야 한다.
    __DCL_ASSERT(_begin + __6_OR_10__ < _end);
    char FIRST = *_begin;
    if (__tag.version() == 2) {
        __id = AsciiDecoder::decode(_begin, 3); // Frame ID 3 bytes
        __size = word(_begin + 3, 3); // size 3 bytes
    }
    else {
        // 2.3, 2.4
        __id = AsciiDecoder::decode(_begin, 4); // Frame ID 4 bytes
        __size = word(_begin + 4, 4); // size 4 bytes
        __flags = *(_begin + 8);             // flags 2 bytes
        __flags = __flags << 8 | *(_begin + 9);
    }
 
#define __IF_ENCODING__ \
    if (_begin < _end) { \
        __encoding = *_begin++; \
    }
#define __IF_LANGUAGE__ \
    if (_begin + 3 < _end && __valid_language_code(_begin)) { \
        __url = AsciiDecoder::decode(_begin, 3).trim(); \
        _begin += 3; \
    }
#define __IF_DESCRIPTION__ \
    if (_begin < _end) { \
        size_t n = __decode_length__(__encoding, _begin, _end - _begin); \
        __description = decode(__encoding, _begin, n).trim(); \
        _begin += __skip_length__(__encoding, n); \
    }
#define __IF_TEXT__ \
    if (_begin < _end) { \
        size_t n = __decode_length__(__encoding, _begin, _end - _begin); \
        __text = decode(__encoding, _begin, n).trim(); \
        _begin += __skip_length__(__encoding, n); \
    }
#define __IF_URL__ \
    if (_begin < _end) { \
        size_t n = ByteString::length(_begin, _end - _begin); \
        __url = decode(0, _begin, n).trim(); \
        _begin += n + 1; \
    }
#define __IF_TYPE__ \
    if (_begin < _end) { \
        __type = *_begin++; \
    }
#define __IF_BINARY__ \
    if (_begin < _end) { \
        __binary.assign(_begin, _end - _begin); \
    }
 
    _begin += __6_OR_10__;
    _end = _begin + __size;
    switch (FIRST) {
        default: {
            // "ENCR" "CRM" Owner identifier, Moehod symbol, Encryption data (b)
            // "EQU2" "EQU" Interpolation method, Identification
            // "ETCO" "ETC" Time stamp format
            // "LINK" "LNK" Frame identifier, URL, ID
            // "MCDI" "MCI" CD TOC
            // "MLLT" "MLL" MPEG frames between reference, ...
            // "OWNE"       Text encoding, Price paid, ... Seller
            // "RBUF" "BUF" Buffer size, Embedded info flag, Offset to next tag
            // "RVA2" "RVA" Identification
            // "RVRB" "REV" Reverb left (ms), ...
            // "SEEK"       Minium offset to next tag
            // "SIGN"       Group symbol, Signature (b)
            // "SYLT" "SLT" Text encoding, Language, Time stamp format, ...
            // "SYTC" "STC" Time stamp format, Temp data (b)
            __IF_BINARY__
            __DCL_TRACE3_N(L"[%ls][%zd][%ls]\n",
                __id.data(), __size, String::toHexString(__binary, 40).data());
            __DCL_TRACE1_N(L"[%ls]\n", String::tryString(__binary, 40).data());
            break;
        }
        case 'A': {
            if (__id == L"AENC") {  // Audio encryption
                __IF_URL__            // Owner identifier
                __IF_BINARY__      // Preview start, Preview length, Encryption info
            }
            else if (__id == L"APIC") {
                uint32_t dataLength = 0;
                if (__flags & 0x01) {
                    dataLength = word(_begin, 4);
                    _begin += 4;
                }
                __DCL_TRACE4_N(L"[%ls][%d][%d][%ls]\n", __id.data(), __size,
                    dataLength, String::tryString(_begin, __size, 40).data());
                __IF_ENCODING__
                __IF_URL__            // MIME type or URL
                __IF_TYPE__          // Picture type
                __IF_DESCRIPTION__
                if (_begin < _end) {// Picture data
                    __binary.assign(_begin,
                        dataLength > 0 ? dataLength : _end - _begin);
                }   
            }
            else {
                // ASPI
                __IF_BINARY__
            }
            break;
        }
        case 'C': {
            if (__id == L"COMM" || __id == L"COM") {
                __IF_ENCODING__
                __IF_LANGUAGE__
                __IF_DESCRIPTION__
                __IF_TEXT__
            }
            else if (__id == L"CRA") {  // Audio encryption
                __IF_URL__            // Owner identifier
                __IF_BINARY__      // Preview start, Preview length, Encryption info
            }
            else {
                // COMR
                __IF_BINARY__      // Text encoding, Price string, ... Seller logo
            }
            break;
        }
        case 'G': {
            if (__id == L"GEOB" || __id == L"GEO") {
                __IF_ENCODING__
                __IF_URL__            // MIME type or URL
                __IF_TEXT__          // Filename
                __IF_DESCRIPTION__
                __IF_BINARY__      // Encapsulated object
            }
            else {
                // GRID
                __IF_BINARY__      // Owner identifier, Group symbol, Group dependent data
            }
            break;
        }
        case 'P': {
            if (__id == L"PIC") {
                __IF_ENCODING__
                if (_begin < _end) {
                    __url = AsciiDecoder::decode(_begin, 3);
                    _begin += 3;
                }
                __IF_TYPE__          // Picture type
                __IF_DESCRIPTION__
                __IF_BINARY__      // Picture data
            }
            else if (__id == L"PRIV") {
                __IF_URL__            // Owner identifier
                __IF_BINARY__      // The private data (b)
            }
            else {
                // "PCNT" "CNT" Counter
                // "POPM" "POP" Email to user, Rating, Counter
                // "POSS"       Time stamp format, Position
                __IF_BINARY__
            }
            break;
        }
        case 'I': {
            if (__id.compare(L"IPL", 3) != 0) { // Involved people list
                __IF_BINARY__
                break;
            }
            // IPLS(3), IPL(2), TIPL(4)
        }
        case 'T': {
            __IF_ENCODING__
            if (__id.compare(L"TXX", 3) == 0) {
                __IF_DESCRIPTION__
            }
            __IF_TEXT__
            break;
        }
        case 'U': {
            // UFID USER USLT
            if (__id.compare(L"UFI", 3) == 0) {
                __IF_URL__
                if (_begin < _end) {
                    // up to 64 bytes binary data
                    size_t n = _end - _begin;
                    __binary.assign(_begin, __MIN(64, n));
                    if (n <= 64) {
                        __text = String::tryString(__binary);
                    }
                }
                break;
            }
            __IF_ENCODING__
            __IF_LANGUAGE__
 
            if (__id == L"USLT" || __id == L"ULT") {
                __IF_DESCRIPTION__
            }
            __IF_TEXT__
            break;
        }
        case 'W': {
            if (__id.compare(L"WXX", 3)) {
                __IF_ENCODING__
                __IF_DESCRIPTION__
            }
            __IF_URL__
            break;
        }
    }
 
    // 프레임 데이터 크기 + 프레임 헤더 6 또는 10 bytes
    return __size + __6_OR_10__;
}
 
String ID3v2Frame::toString() const
{
    StringBuilder sb(__id);
    sb.format(L" size[%d] flags[%x] encoding[%d] type[%d]",
        __size, __flags,  __encoding, __type);
    if (!__url.isEmpty()) {
        sb.format(L" url[%ls]", __url.data());
    }
    if (!__description.isEmpty()) {
        sb.format(L" description[%ls]", __description.data());
    }
    if (!__text.isEmpty()) {
        sb.format(L" text[%ls]", __text.data());
    }
    if (!__binary.isEmpty()) {
        sb.format(L" binary[%zd][%ls]", __binary.length(),
            String::tryString(__binary, 40).data());
    }
    return sb;
}
 
__DCL_END_NAMESPACE