rockbox/lib/rbcodec/metadata/smaf.c

/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (C) 2010 Yoshihisa Uchida
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/
#include <inttypes.h>
#include <stdio.h>
#include "platform.h"

#include "string-extra.h"
#include "metadata.h"
#include "metadata_common.h"
#include "metadata_parsers.h"
#include "rbunicode.h"
#include "logf.h"

static const int basebits[4] = { 4, 8, 12, 16 };

static const int frequency[5] = { 4000, 8000, 11025, 22050, 44100 };

static const int support_codepages[5] = {
    SJIS, ISO_8859_1, -1, GB_2312, BIG_5,
};

/* extra codepage */
#define UCS2  (NUM_CODEPAGES + 1)

/* support id3 tag */
#define TAG_TITLE    (('S'<<8)|'T')
#define TAG_ARTIST   (('A'<<8)|'N')
#define TAG_COMPOSER (('S'<<8)|'W')

/* convert functions */
#define CONVERT_SMAF_CHANNELS(c) (((c) >> 7) + 1)


static inline int convert_smaf_audio_basebit(unsigned int basebit)
{
    if (basebit > 3)
        return 0;
    return basebits[basebit];
}

static inline int convert_smaf_audio_frequency(unsigned int freq)
{
    if (freq > 4)
        return 0;
    return frequency[freq];
}

static int convert_smaf_codetype(unsigned int codetype)
{
    if (codetype < 5)
        return support_codepages[codetype];
    else if (codetype == 0x20 || codetype == 0x24) /* In Rockbox, UCS2 and UTF-16 are same. */
        return UCS2;
    else if (codetype == 0x23)
        return UTF_8;
    else if (codetype == 0xff)
        return ISO_8859_1;
    return -1;
}

static void set_length(struct mp3entry *id3, unsigned int ch, unsigned int basebit,
                       unsigned int numbytes)
{
    int bitspersample = convert_smaf_audio_basebit(basebit);

    if (bitspersample != 0 && id3->frequency != 0)
    {
        /* Calculate track length [ms] and bitrate [kbit/s] */
        id3->length  = (uint64_t)numbytes * 8000LL
                       / (bitspersample * CONVERT_SMAF_CHANNELS(ch) * id3->frequency);
        id3->bitrate = bitspersample * id3->frequency / 1000;
    }

    /* output contents/wave data/id3 info (for debug) */
    DEBUGF("contents info ----\n");
    DEBUGF("  TITLE:         %s\n", (id3->title)? id3->title : "(NULL)");
    DEBUGF("  ARTIST:        %s\n", (id3->artist)? id3->artist : "(NULL)");
    DEBUGF("  COMPOSER:      %s\n", (id3->composer)? id3->composer : "(NULL)");
    DEBUGF("wave data info ----\n");
    DEBUGF("  channels:      %u\n", CONVERT_SMAF_CHANNELS(ch));
    DEBUGF("  bitspersample: %d\n", bitspersample);
    DEBUGF("  numbytes;      %u\n", numbytes);
    DEBUGF("id3 info ----\n");
    DEBUGF("  frquency:      %u\n", (unsigned int)id3->frequency);
    DEBUGF("  bitrate:       %d\n", id3->bitrate);
    DEBUGF("  length:        %u\n", (unsigned int)id3->length);
}

/* contents parse functions */

/* Note: 
 *  1) When the codepage is UTF-8 or UCS2, contents data do not start BOM.
 *  2) The byte order of contents data is big endian.
 */

static void decode2utf8(const unsigned char *src, unsigned char **dst,
                        int srcsize, int *dstsize, int codepage)
{
    unsigned char tmpbuf[srcsize * 3 + 1];
    unsigned char *p;
    int utf8size;

    if (codepage < NUM_CODEPAGES)
        p = iso_decode(src, tmpbuf, codepage, srcsize);
    else /* codepage == UCS2 */
        p = utf16BEdecode(src, tmpbuf, srcsize);

    *p = '\0';

    strlcpy(*dst, tmpbuf, *dstsize);
    utf8size = (p - tmpbuf) + 1;
    if (utf8size > *dstsize)
    {
        DEBUGF("metadata warning: data length: %d > contents store buffer size: %d\n",
                    utf8size, *dstsize);
        utf8size = *dstsize;
    }
    *dst     += utf8size;
    *dstsize -= utf8size;
}

static int read_audio_track_contents(int fd, int codepage, unsigned char **dst,
                                    int *dstsize)
{
    /* value length <= 256 bytes */
    unsigned char buf[256];
    unsigned char *p = buf;
    unsigned char *q = buf;

    int datasize = read(fd, buf, 256);
    if (datasize <= 0)
        return  0;

    while (p - buf < datasize && *p != ',')
    {
        /* skip yen mark */
        if (codepage != UCS2)
        {
            if (*p == '\\')
                p++;
        }
        else if (*p == '\0' && *(p+1) == '\\')
            p += 2;

        if (*p > 0x7f)
        {
            if (codepage == UTF_8)
            {
                while ((*p & MASK) != COMP)
                    *q++ = *p++;
            }
            else if (codepage == SJIS)
            {
                if (*p <= 0xa0 || *p >= 0xe0)
                    *q++ = *p++;
            }
        }

        *q++ = *p++;
        if (codepage == UCS2)
            *q++ = *p++;
    }

    datasize =  p - buf + 1;
    lseek(fd, datasize - 256, SEEK_CUR);

    if (dst != NULL)
        decode2utf8(buf, dst, q - buf, dstsize, codepage);

    return datasize;
}

static void read_score_track_contents(int fd, int codepage, int datasize,
                                     unsigned char **dst, int *dstsize)
{
    unsigned char buf[datasize];
    if (read(fd, buf, datasize) != datasize)
        memset(buf, 0, datasize);
    decode2utf8(buf, dst, datasize, dstsize, codepage);
}

/* traverse chunk functions */

static unsigned int search_chunk(int fd, const unsigned char *name, int nlen)
{
    unsigned char buf[8];
    unsigned int chunksize;

    while (read(fd, buf, 8) == 8)
    {
        chunksize = get_long_be(buf + 4);
        if (memcmp(buf, name, nlen) == 0)
            return chunksize;

        lseek(fd, chunksize, SEEK_CUR);
    }
    DEBUGF("metadata error: missing '%s' chunk\n", name);
    return 0;
}

static bool parse_smaf_audio_track(int fd, struct mp3entry *id3, unsigned int datasize)
{
    /* temporary buffer */
    unsigned char *tmp = (unsigned char*)id3->path;
    /* contents stored buffer */
    unsigned char *buf = id3->id3v2buf;
    int bufsize = sizeof(id3->id3v2buf);
    int valsize;
    unsigned int chunksize = datasize;
    int codepage = -1;

    /* parse contents info */
    if (read(fd, tmp, 5) == 5)
        codepage = convert_smaf_codetype(tmp[2]);

    if (codepage < 0)
    {
        DEBUGF("metadata error: smaf unsupport codetype: %d\n", tmp[2]);
        return false;
    }

    datasize -= 5;
    while ((id3->title == NULL || id3->artist == NULL || id3->composer == NULL)
           && (datasize > 0 && bufsize > 0))
    {
        if (read(fd, tmp, 3) != 3)
            return false;

        if (tmp[2] != ':')
        {
            DEBUGF("metadata error: illegal tag: %c%c%c\n", tmp[0], tmp[1], tmp[2]);
            return false;
        }
        switch ((tmp[0]<<8)|tmp[1])
        {
            case TAG_TITLE:
                id3->title = buf;
                valsize = read_audio_track_contents(fd, codepage, &buf, &bufsize);
                break;
            case TAG_ARTIST:
                id3->artist = buf;
                valsize = read_audio_track_contents(fd, codepage, &buf, &bufsize);
                break;
            case TAG_COMPOSER:
                id3->composer = buf;
                valsize = read_audio_track_contents(fd, codepage, &buf, &bufsize);
                break;
            default:
                valsize = read_audio_track_contents(fd, codepage, NULL, &bufsize);
                break;
        }
        datasize -= (valsize + 3);
    }

    /* search PCM Audio Track Chunk */
    lseek(fd, 16 + chunksize, SEEK_SET);

    chunksize = search_chunk(fd, "ATR", 3);
    if (chunksize == 0)
    {
        DEBUGF("metadata error: missing PCM Audio Track Chunk\n");
        return false;
    }

    /*
     * get format
     *  tmp
     *    +0: Format Type
     *    +1: Sequence Type
     *    +2: bit 7 0:mono/1:stereo, bit 4-6 format, bit 0-3: frequency
     *    +3: bit 4-7: base bit
     *    +4: TimeBase_D
     *    +5: TimeBase_G
     *
     * Note: If PCM Audio Track does not include Sequence Data Chunk,
     *       tmp+6 is the start position of Wave Data Chunk.
     */
    read(fd, tmp, 6);

    /* search Wave Data Chunk */
    chunksize = search_chunk(fd, "Awa", 3);
    if (chunksize == 0)
    {
        DEBUGF("metadata error: missing Wave Data Chunk\n");
        return false;
    }

    /* set track length and bitrate */
    id3->frequency = convert_smaf_audio_frequency(tmp[2] & 0x0f);
    set_length(id3, tmp[2], tmp[3] >> 4, chunksize);
    return true;
}

static bool parse_smaf_score_track(int fd, struct mp3entry *id3)
{
    /* temporary buffer */
    unsigned char *tmp = (unsigned char*)id3->path;
    unsigned char *p = tmp;
    /* contents stored buffer */
    unsigned char *buf = id3->id3v2buf;
    int bufsize = sizeof(id3->id3v2buf);

    unsigned int chunksize;
    unsigned int datasize;
    int valsize;

    int codepage;

    /* parse Optional Data Chunk */
    read(fd, tmp, 21);
    if (memcmp(tmp + 5, "OPDA", 4) != 0)
    {
        DEBUGF("metadata error: missing Optional Data Chunk\n");
        return false;
    }

    /* Optional Data Chunk size */
    chunksize = get_long_be(tmp + 9);

    /* parse Data Chunk */
    if (memcmp(tmp + 13, "Dch", 3) != 0)
    {
        DEBUGF("metadata error: missing Data Chunk\n");
        return false;
    }

    codepage = convert_smaf_codetype(tmp[16]);
    if (codepage < 0)
    {
        DEBUGF("metadata error: smaf unsupport codetype: %d\n", tmp[16]);
        return false;
    }

    /* Data Chunk size */
    datasize = get_long_be(tmp + 17);
    while ((id3->title == NULL || id3->artist == NULL || id3->composer == NULL)
           && (datasize > 0 && bufsize > 0))
    {
        if (read(fd, tmp, 4) != 4)
            return false;

        valsize = (tmp[2] << 8) | tmp[3];
        datasize -= (valsize + 4);
        switch ((tmp[0]<<8)|tmp[1])
        {
            case TAG_TITLE:
                id3->title = buf;
                read_score_track_contents(fd, codepage, valsize, &buf, &bufsize);
                break;
            case TAG_ARTIST:
                id3->artist = buf;
                read_score_track_contents(fd, codepage, valsize, &buf, &bufsize);
                break;
            case TAG_COMPOSER:
                id3->composer = buf;
                read_score_track_contents(fd, codepage, valsize, &buf, &bufsize);
                break;
            default:
                lseek(fd, valsize, SEEK_CUR);
                break;
        }
    }

    /* search Score Track Chunk */
    lseek(fd, 29 + chunksize, SEEK_SET);

    if (search_chunk(fd, "MTR", 3) == 0)
    {
        DEBUGF("metadata error: missing Score Track Chunk\n");
        return false;
    }

    /*
     * search next chunk
     * usually, next chunk ('M***') found within 40 bytes.
     */
    chunksize = 40;
    read(fd, tmp, chunksize);

    tmp[chunksize] = 'M'; /* stopper */
    while (*p != 'M')
        p++;

    chunksize -= (p - tmp);
    if (chunksize == 0)
    {
        DEBUGF("metadata error: missing Score Track Stream PCM Data Chunk");
        return false;
    }

    /* search Score Track Stream PCM Data Chunk */
    lseek(fd, -chunksize, SEEK_CUR);
    if (search_chunk(fd, "Mtsp", 4) == 0)
    {
        DEBUGF("metadata error: missing Score Track Stream PCM Data Chunk\n");
        return false;
    }

    /*
     * parse Score Track Stream Wave Data Chunk
     *  tmp
     *    +4-7: chunk size (WaveType(3bytes) + wave data count)
     *    +8:   bit 7 0:mono/1:stereo, bit 4-6 format, bit 0-3: base bit
     *    +9:   frequency (MSB)
     *    +10:  frequency (LSB)
     */
    read(fd, tmp, 11);
    if (memcmp(tmp, "Mwa", 3) != 0)
    {
        DEBUGF("metadata error: missing Score Track Stream Wave Data Chunk\n");
        return false;
    }

    /* set track length and bitrate */
    id3->frequency = (tmp[9] << 8) | tmp[10];
    set_length(id3, tmp[8], tmp[8] & 0x0f, get_long_be(tmp + 4) - 3);
    return true;
}

bool get_smaf_metadata(int fd, struct mp3entry* id3)
{
    /* temporary buffer */
    unsigned char *tmp = (unsigned char *)id3->path;
    unsigned int chunksize;

    id3->title    = NULL;
    id3->artist   = NULL;
    id3->composer = NULL;

    id3->vbr      = false;   /* All SMAF files are CBR */
    id3->filesize = filesize(fd);

    /* check File Chunk and Contents Info Chunk */
    lseek(fd, 0, SEEK_SET);

    if (read(fd, tmp, 16) != 16 || (memcmp(tmp, "MMMD", 4) != 0) || (memcmp(tmp + 8, "CNTI", 4) != 0))
    {
        DEBUGF("metadata error: no smaf format\n");
        return false;
    }

    chunksize = get_long_be(tmp + 12);
    if (chunksize > 5)
        return parse_smaf_audio_track(fd, id3, chunksize);

    return parse_smaf_score_track(fd, id3);
}