/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (C) 2005 Thom Johansen 
 * Copyright (C) 2010 Andree Buschmann
 *
 * 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 <string.h>
#include <inttypes.h>
#include "system.h"
#include "metadata.h"
#include "metadata_common.h"
#include "metadata_parsers.h"
#include "logf.h"
#include "replaygain.h"
#include "fixedpoint.h"

/* Needed for replay gain and clipping prevention of SV8 files. */
#define SV8_TO_SV7_CONVERT_GAIN (6482)  /* 64.82 * 100, MPC_OLD_GAIN_REF */
#define SV8_TO_SV7_CONVERT_PEAK (23119) /* 256 * 20 * log10(32768) */

static int set_replaygain_sv7(struct mp3entry* id3, 
                              bool album, 
                              long value, 
                              long used)
{
    long gain = (int16_t) ((value >> 16) & 0xffff);
    long peak = (uint16_t) (value & 0xffff);
    
    /* We use a peak value of 0 to indicate a given gain type isn't used. */
    if (peak != 0) {
        /* Save the ReplayGain data to id3-structure for further processing. */
        used += parse_replaygain_int(album, gain * 512 / 100, peak << 9,
            id3, id3->toc + used, sizeof(id3->toc) - used);
    }
    
    return used;
}

static int set_replaygain_sv8(struct mp3entry* id3, 
                              bool album, 
                              long gain, 
                              long peak,
                              long used)
{
    gain = (long)(SV8_TO_SV7_CONVERT_GAIN - ((gain*100)/256));

    /* Transform SV8's logarithmic peak representation to the desired linear
     * representation: linear = pow(10, peak/256/20).
     *
     * FP_BITS   = 24 bits = desired fp representation for dsp routines
     * FRAC_BITS = 12 bits = resolution used for fp_bits
     * fp_factor(peak*(1<<FRAC_BITS)/256, FRAC_BITS) << (FP_BITS-FRAC_BITS)
     **/
    peak = (fp_factor((peak-SV8_TO_SV7_CONVERT_PEAK)*16, 12) << 12);

    /* We use a peak value of 0 to indicate a given gain type isn't used. */
    if (peak != 0) {
        /* Save the ReplayGain data to id3-structure for further processing. */
        used += parse_replaygain_int(album, gain * 512 / 100, peak,
            id3, id3->toc + used, sizeof(id3->toc) - used);
    }
    
    return used;
}

static int sv8_get_size(uint8_t *buffer, int index, uint64_t *p_size)
{
    unsigned char tmp;
    uint64_t size = 0;

    do {
        tmp = buffer[index++];
        size = (size << 7) | (tmp & 0x7F);
    } while((tmp & 0x80));

    *p_size = size;
    return index;
}

bool get_musepack_metadata(int fd, struct mp3entry *id3)
{
    static const int32_t sfreqs[4] = { 44100, 48000, 37800, 32000 };
    uint32_t header[8];
    uint64_t samples = 0;
    int i;
    
    if (!skip_id3v2(fd, id3))
        return false;
    if (read(fd, header, 4*8) != 4*8) return false;
    /* Musepack files are little endian, might need swapping */
    for (i = 1; i < 8; i++) 
       header[i] = letoh32(header[i]); 
    if (!memcmp(header, "MP+", 3)) { /* Compare to sig "MP+" */
        unsigned int streamversion;
        header[0] = letoh32(header[0]);
        streamversion = (header[0] >> 24) & 15;
        if (streamversion == 7) {
            unsigned int gapless = (header[5] >> 31) & 0x0001;
            unsigned int last_frame_samples = (header[5] >> 20) & 0x07ff;
            unsigned int bufused = 0;
            
            id3->frequency = sfreqs[(header[2] >> 16) & 0x0003];
            samples = (uint64_t)header[1]*1152; /* 1152 is mpc frame size */
            if (gapless)
                samples -= 1152 - last_frame_samples;
            else
                samples -= 481; /* Musepack subband synth filter delay */
           
            bufused = set_replaygain_sv7(id3, false, header[3], bufused);
            bufused = set_replaygain_sv7(id3, true , header[4], bufused);
        } else {
            return false; /* only SV7 is allowed within a "MP+" signature */
        }
    } else if (!memcmp(header, "MPCK", 4)) { /* Compare to sig "MPCK" */
        uint8_t sv8_header[32];
        /* 4 bytes 'MPCK' */
        lseek(fd, 4, SEEK_SET);
        if (read(fd, sv8_header, 2) != 2) return false; /* read frame ID */
        if (!memcmp(sv8_header, "SH", 2)) { /* Stream Header ID */
            int32_t k = 0;
            uint32_t streamversion;
            uint64_t size  = 0; /* tag size */
            uint64_t dummy = 0; /* used to dummy read data from header */

            /* 4 bytes 'MPCK' +  2 'SH' */
            lseek(fd, 6, SEEK_SET);
            if (read(fd, sv8_header, 32) != 32) return false;
            
            /* Read the size of 'SH'-tag */
            k = sv8_get_size(sv8_header, k, &size);
            
            /* Skip crc32 */
            k += 4;
        
            /* Read stream version */
            streamversion = sv8_header[k++];
            if (streamversion != 8) return false; /* Only SV8 is allowed. */
            
            /* Number of samples */
            k = sv8_get_size(sv8_header, k, &samples);
            
            /* Number of leading zero-samples */
            k = sv8_get_size(sv8_header, k, &dummy);
            
            /* Sampling frequency */
            id3->frequency = sfreqs[(sv8_header[k++] >> 5) & 0x0003];
            
            /* Number of channels */
            id3->channels = (sv8_header[k++] >> 4) + 1;

            /* Skip to next tag: k = size -2 */
            k = size - 2;

            if (!memcmp(sv8_header+k, "RG", 2)) { /* Replay Gain ID */
                long peak, gain; 
                int bufused = 0;
                
                k += 2; /* 2 bytes 'RG' */
                
                /* sv8_get_size must be called to skip the right amount of
                 * bits within the header data. */
                k = sv8_get_size(sv8_header, k, &size);
                
                /* Read and set replay gain */
                if (sv8_header[k++] == 1) {
                    /* Title's peak and gain */
                    gain = (int16_t) ((sv8_header[k]<<8) + sv8_header[k+1]); k += 2;
                    peak = (uint16_t)((sv8_header[k]<<8) + sv8_header[k+1]); k += 2;
                    bufused += set_replaygain_sv8(id3, false, gain, peak, bufused);

                    /* Album's peak and gain */
                    gain = (int16_t) ((sv8_header[k]<<8) + sv8_header[k+1]); k += 2;
                    peak = (uint16_t)((sv8_header[k]<<8) + sv8_header[k+1]); k += 2;
                    bufused += set_replaygain_sv8(id3, true , gain, peak, bufused);
                }
            }
        } else {
            /* No sv8 stream header found */
            return false;
        }
    } else {
        return false; /* SV4-6 is not supported anymore */
    }

    id3->vbr = true;
    /* Estimate bitrate, we should probably subtract the various header sizes
       here for super-accurate results */
    id3->length = ((int64_t) samples * 1000) / id3->frequency;

    if (id3->length <= 0)
    {
        logf("mpc length invalid!");
        return false;
    }

    id3->filesize = filesize(fd);
    id3->bitrate = id3->filesize * 8 / id3->length;
    return true;
}
