APEv2.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>
 
#if __DCL_WINDOWS
#include <windows.h>
#endif
 
#include <string.h>
 
#include <dcl/String.h>
#include <dcl/Charset.h>
#include <dcl/File.h>
 
#include "APEv2.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
#else
#define __DCL_TRACE1_N(fmt, arg)
#define __DCL_TRACE2_N(fmt, arg1, arg2)
#define __DCL_TRACE3_N(fmt, arg1, arg2, arg3)
#endif
 
__DCL_BEGIN_NAMESPACE
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("media/APEv2.cpp");
#endif
 
IMPLEMENT_CLASSINFO(APEv2, Object)
 
APEv2::APEv2()
{
    __version = __size = __count = __flags = 0;
    __data = NULL;
}
 
APEv2::~APEv2()
{
    if (__data) {
        free(__data);
        __data = NULL;
    }
 
    for (size_t i = 0; i < __items.size(); i++) {
        delete (APEv2Item*)__items[i];
    }
}
 
uint32_t APEv2::word(const char _chars[4])
{
    uint32_t r = (byte_t)_chars[3];
    r = (r << 8) | (byte_t)_chars[2];
    r = (r << 8) | (byte_t)_chars[1];
    r = (r << 8) | (byte_t)_chars[0];
    return r;
}
 
bool APEv2::read(File& _file, const char _footerOr[32], File::off_t _off)
{
    char buf[160];       // 32 + 128
    if (_footerOr == NULL) {
        // ID3v1이 있는것으로 가정하여
        // 파일의 끝에서 160 바이트를 읽는다.
        _file.seek(-160, File::END);
        size_t n = _file.read(buf, 160);
        if (n < 160) {
            return false;
        }
 
        __DCL_TRACE1_N(L"[%ls]\n", String::tryString(buf, 32).data());
        if (memcmp(buf, "APETAGEX", 8) == 0) {
            _footerOr = buf;
            _off = -160;
        }
        else {
            __DCL_TRACE1_N(L"[%ls]\n", String::tryString(&buf[128], 32).data());
            if (memcmp(&buf[128], "APETAGEX", 8) == 0) {
                _footerOr = &buf[128];
                _off = -32;
            }
        }
    }
 
    if (_footerOr == NULL) {
        // 파일의 시작에서 32 바이트를 읽는다.
        _file.seek(0, File::BEGIN);
        size_t n = _file.read(buf, 32);
        if (n < 32) {
            return false;
        }
        _footerOr = buf;
        _off = 0;
    }
 
    if (_footerOr == NULL || memcmp(_footerOr, "APETAGEX", 8) != 0) {
        return false;
    }
 
    __APETAGEX = AsciiDecoder::decode(&_footerOr[0], 8);
    __version = word(&_footerOr[8]);
    __size = word(&_footerOr[12]);
    __count = word(&_footerOr[16]);
    __flags = word(&_footerOr[20]);
    // Reserved 24 ~ 31
 
    __DCL_TRACE2_N(L"[%lld] %ls\n", _off, toString().data());
 
    // Header, Item 데이터를 읽는다.
    if (_off < 0) {
        _file.seek(_off - __size, File::END);
    }
 
    __data = (char*)malloc(__size);
    size_t n = _file.read(__data, __size);
    if (n < __size) {
        return false;
    }
 
    __DCL_TRACE2_N(L"[%zd] [%ls]\n", n, String::tryString(__data, n, 500).data());
 
    const char* _begin = __data;
    const char* _end = _begin + n;
 
    if (__flags & 0x80000000 && _begin + 32 <= _end) {
        // header가 있다.
        String sig = AsciiDecoder::decode(_begin, 8);
        uint32_t version = word(_begin + 8);
        uint32_t size = word(_begin + 12);
        uint32_t count = word(_begin + 16);
        uint32_t flags = word(_begin + 20);
 
        String s = String::format(L""
            "Header[%ls] version[%d] size[%d] count[%d] flags[%x]",
            sig.data(),
            version, size, count, flags
        );
        __DCL_TRACE1_N(L"%ls\n", s.data());
        _begin += 32;
    }
 
    // Item을 읽는다.
    // 최소 8 bytes (size 4, flags 4)가 있어야 한다.
    while (_begin + 8 < _end) {
        APEv2Item* item = new APEv2Item;
        _begin += item->read(_begin, _end);
        __DCL_TRACE1_N(L"%ls\n", item->toString().data());
        __items.add(item);
    }
 
    return true;
}
 
String APEv2::toString() const
{
    return String::format(L""
        "%ls version[%d] size[%d] count[%d] flags[%x]",
        __APETAGEX.data(),
        __version, __size, __count, __flags
    );
}
 
IMPLEMENT_CLASSINFO(APEv2Item, Object)
 
APEv2Item::APEv2Item()
{
    __size = __flags = 0;
}
 
size_t APEv2Item::read(const char* _begin, const char* _end)
{
    // 최소 8 bytes는 되어야 한다.
    __DCL_ASSERT(_begin + 8 < _end);
    __size = APEv2::word(_begin);
    __flags = APEv2::word(_begin + 4);
    _begin += 8;
 
    // bit 2... 1
    int type = (__flags & 0x0006) >> 1;
    if (_begin < _end) {
        __key = AsciiDecoder::decode(_begin,
            ByteString::length(_begin, _end - _begin));
        _begin += __key.length() + 1;
    }
    if (_begin + __size < _end) {
        switch (type) {
        case 0: {
            size_t n = ByteString::length(_begin, __size);
            try {
                __value = UTF8Decoder::decode(_begin, n);
            }
            catch (CharsetConvertException* e) {
                __DCL_TRACE0(L"UTF8Decoder::decode failed. retry Latin1Decoder\n");
                __DCL_TRACE3(L"Item size[%d] flags[%x] type[%d] ",
                    __size, __flags, type);
                __DCL_TRACE3(L"%ls key[%ls] [%ls]\n",
                    e->toStringAll().data(),
                    __key.data(), String::tryString(_begin, __size).data()
                );
                e->destroy();
                __value = Latin1Decoder::decode(_begin, n);
            }
            __value = __value.trim();
            break;
        }
        case 1 :
            __value = String::tryString(_begin,
                ByteString::length(_begin, __size));
        case 2 :
        default :
            ;
        }
    }
 
    return 4 + 4 + __key.length() + 1 + __size;
}
 
String APEv2Item::toString() const
{
    StringBuilder sb;
    sb.format(L"size[%d] flags[%x] key[%ls] value[%ls]",
        __size, __flags,
        __key.data(), __value.data());
 
    return sb;
}
__DCL_END_NAMESPACE