apps/codecs/libmusepack/streaminfo.c

   1 /*
   2   Copyright (c) 2005-2009, The Musepack Development Team
   3   All rights reserved.
   4
   5   Redistribution and use in source and binary forms, with or without
   6   modification, are permitted provided that the following conditions are
   7   met:
   8
   9   * Redistributions of source code must retain the above copyright
  10   notice, this list of conditions and the following disclaimer.
  11
  12   * Redistributions in binary form must reproduce the above
  13   copyright notice, this list of conditions and the following
  14   disclaimer in the documentation and/or other materials provided
  15   with the distribution.
  16
  17   * Neither the name of the The Musepack Development Team nor the
  18   names of its contributors may be used to endorse or promote
  19   products derived from this software without specific prior
  20   written permission.
  21
  22   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33 */
  34 /// \file streaminfo.c
  35 /// Implementation of streaminfo reading functions.
  36
  37 #include <math.h>
  38 #include "mpcdec.h"
  39 #include "streaminfo.h"
  40 #include <stdio.h>
  41 #include "internal.h"
  42 #include "huffman.h"
  43 #include "mpc_bits_reader.h"
  44
  45 /* rockbox: not used
  46 static const char na[] = "n.a.";
  47 static char const * const versionNames[] = {
  48     na, "'Unstable/Experimental'", na, na, na, "'quality 0'", "'quality 1'",
  49     "'Telephone'", "'Thumb'", "'Radio'", "'Standard'", "'Extreme'", "'Insane'",
  50     "'BrainDead'", "'quality 9'", "'quality 10'"
  51 };
  52 */
  53 static const mpc_int32_t samplefreqs[8] = { 44100, 48000, 37800, 32000 };
  54 /* rockbox: not used
  55 static const char *
  56 mpc_get_version_string(float profile) // profile is 0...15, where 7...13 is used
  57 {
  58     return profile >= sizeof versionNames / sizeof *versionNames ? na : versionNames[(int)profile];
  59 }
  60 */
  61 /* rockbox: not used
  62 static void
  63 mpc_get_encoder_string(mpc_streaminfo* si)
  64 {
  65     int ver = si->encoder_version;
  66     if (si->stream_version >= 8)
  67         ver = (si->encoder_version >> 24) * 100 + ((si->encoder_version >> 16) & 0xFF);
  68     if (ver <= 116) {
  69         if (ver == 0) {
  70             sprintf(si->encoder, "Buschmann 1.7.0...9, Klemm 0.90...1.05");
  71         } else {
  72             switch (ver % 10) {
  73                 case 0:
  74                     sprintf(si->encoder, "Release %u.%u", ver / 100,
  75                             ver / 10 % 10);
  76                     break;
  77                 case 2: case 4: case 6: case 8:
  78                     sprintf(si->encoder, "Beta %u.%02u", ver / 100,
  79                             ver % 100);
  80                     break;
  81                 default:
  82                     sprintf(si->encoder, "--Alpha-- %u.%02u",
  83                             ver / 100, ver % 100);
  84                     break;
  85             }
  86         }
  87     } else {
  88         int major = si->encoder_version >> 24;
  89         int minor = (si->encoder_version >> 16) & 0xFF;
  90         int build = (si->encoder_version >> 8) & 0xFF;
  91         char * tmp = "--Stable--";
  92
  93         if (minor & 1)
  94             tmp = "--Unstable--";
  95
  96         sprintf(si->encoder, "%s %u.%u.%u", tmp, major, minor, build);
  97     }
  98 }
  99 */
 100
 101 static mpc_status check_streaminfo(mpc_streaminfo * si)
 102 {
 103     if (si->max_band == 0 || si->max_band >= 32
 104         || si->channels > 2)
 105         return MPC_STATUS_FILE;
 106     return MPC_STATUS_OK;
 107 }
 108
 109 /// Reads streaminfo from SV7 header.
 110 mpc_status
 111 streaminfo_read_header_sv7(mpc_streaminfo* si, mpc_bits_reader * r)
 112 {
 113     mpc_uint32_t frames, last_frame_samples;
 114
 115     si->bitrate            = 0;
 116     frames                 = (mpc_bits_read(r, 16) << 16) | mpc_bits_read(r, 16);
 117     mpc_bits_read(r, 1); // intensity stereo : should be 0
 118     si->ms                 = mpc_bits_read(r, 1);
 119     si->max_band           = mpc_bits_read(r, 6);
 120     si->profile            = mpc_bits_read(r, 4);
 121 /* rockbox: not used
 122     si->profile_name       = mpc_get_version_string(si->profile);
 123 */
 124     mpc_bits_read(r, 2); // Link ?
 125     si->sample_freq        = samplefreqs[mpc_bits_read(r, 2)];
 126     mpc_bits_read(r, 16); // Estimatedpeak_title
 127     si->gain_title         = (mpc_uint16_t) mpc_bits_read(r, 16);
 128     si->peak_title         = (mpc_uint16_t) mpc_bits_read(r, 16);
 129     si->gain_album         = (mpc_uint16_t) mpc_bits_read(r, 16);
 130     si->peak_album         = (mpc_uint16_t) mpc_bits_read(r, 16);
 131     si->is_true_gapless    = mpc_bits_read(r, 1); // true gapless: used?
 132     last_frame_samples     = mpc_bits_read(r, 11); // true gapless: valid samples for last frame
 133     si->fast_seek          = mpc_bits_read(r, 1); // fast seeking
 134     mpc_bits_read(r, 19); // unused
 135     si->encoder_version    = mpc_bits_read(r, 8);
 136     si->channels           = 2;
 137     si->block_pwr          = 0;
 138
 139 /* rockbox: not used
 140     // convert gain info
 141     if (si->gain_title != 0) {
 142         int tmp = (int)((MPC_OLD_GAIN_REF - (mpc_int16_t)si->gain_title / 100.) * 256. + .5);
 143         if (tmp >= (1 << 16) || tmp < 0) tmp = 0;
 144         si->gain_title = (mpc_int16_t) tmp;
 145     }
 146
 147     if (si->gain_album != 0) {
 148         int tmp = (int)((MPC_OLD_GAIN_REF - (mpc_int16_t)si->gain_album / 100.) * 256. + .5);
 149         if (tmp >= (1 << 16) || tmp < 0) tmp = 0;
 150         si->gain_album = (mpc_int16_t) tmp;
 151     }
 152
 153     if (si->peak_title != 0)
 154         si->peak_title = (mpc_uint16_t) (log10(si->peak_title) * 20 * 256 + .5);
 155
 156     if (si->peak_album != 0)
 157         si->peak_album = (mpc_uint16_t) (log10(si->peak_album) * 20 * 256 + .5);
 158
 159     mpc_get_encoder_string(si);
 160 */
 161
 162     if (last_frame_samples == 0) last_frame_samples = MPC_FRAME_LENGTH;
 163     si->samples = (mpc_int64_t) frames * MPC_FRAME_LENGTH;
 164     if (si->is_true_gapless)
 165         si->samples -= (MPC_FRAME_LENGTH - last_frame_samples);
 166     else
 167         si->samples -= MPC_DECODER_SYNTH_DELAY;
 168
 169     si->average_bitrate = (si->tag_offset  - si->header_position) * 8.0
 170             *  si->sample_freq / si->samples;
 171
 172     return check_streaminfo(si);
 173 }
 174
 175 /// Reads replay gain datas
 176 void  streaminfo_gain(mpc_streaminfo* si, const mpc_bits_reader * r_in)
 177 {
 178     mpc_bits_reader r = *r_in;
 179
 180     int version = mpc_bits_read(&r, 8); // gain version
 181     if (version != 1) // we only know ver 1
 182         return;
 183     si->gain_title         = (mpc_uint16_t) mpc_bits_read(&r, 16);
 184     si->peak_title         = (mpc_uint16_t) mpc_bits_read(&r, 16);
 185     si->gain_album         = (mpc_uint16_t) mpc_bits_read(&r, 16);
 186     si->peak_album         = (mpc_uint16_t) mpc_bits_read(&r, 16);
 187 }
 188
 189 /// Reads streaminfo from SV8 header.
 190 mpc_status
 191 streaminfo_read_header_sv8(mpc_streaminfo* si, const mpc_bits_reader * r_in,
 192                            mpc_size_t block_size)
 193 {
 194     mpc_uint32_t CRC;
 195     mpc_bits_reader r = *r_in;
 196
 197     CRC = (mpc_bits_read(&r, 16) << 16) | mpc_bits_read(&r, 16);
 198     if (CRC != mpc_crc32(r.buff + 1 - (r.count >> 3), (int)block_size - 4))
 199         return MPC_STATUS_FILE;
 200
 201     si->stream_version = mpc_bits_read(&r, 8);
 202     if (si->stream_version != 8)
 203         return MPC_STATUS_INVALIDSV;
 204
 205     mpc_bits_get_size(&r, &si->samples);
 206     mpc_bits_get_size(&r, &si->beg_silence);
 207
 208     si->is_true_gapless = 1;
 209     si->sample_freq = samplefreqs[mpc_bits_read(&r, 3)];
 210     si->max_band = mpc_bits_read(&r, 5) + 1;
 211     si->channels = mpc_bits_read(&r, 4) + 1;
 212     si->ms = mpc_bits_read(&r, 1);
 213     si->block_pwr = mpc_bits_read(&r, 3) * 2;
 214
 215     si->bitrate = 0;
 216
 217     if ((si->samples - si->beg_silence) != 0)
 218         si->average_bitrate = (si->tag_offset - si->header_position) * 8.0
 219                 *  si->sample_freq / (si->samples - si->beg_silence);
 220
 221     return check_streaminfo(si);
 222 }
 223
 224 /// Reads encoder informations
 225 void  streaminfo_encoder_info(mpc_streaminfo* si, const mpc_bits_reader * r_in)
 226 {
 227     mpc_bits_reader r = *r_in;
 228
 229     si->profile            = mpc_bits_read(&r, 7) / 8.;
 230 /* rockbox: not used
 231     si->profile_name       = mpc_get_version_string(si->profile);
 232 */
 233     si->pns                = mpc_bits_read(&r, 1);
 234     si->encoder_version = mpc_bits_read(&r, 8) << 24; // major
 235     si->encoder_version |= mpc_bits_read(&r, 8) << 16; // minor
 236     si->encoder_version |= mpc_bits_read(&r, 8) << 8; // build
 237
 238 /* rockbox: not used
 239     mpc_get_encoder_string(si);
 240 */
 241 }
 242
 243 /* rockbox: not used
 244 double
 245 mpc_streaminfo_get_length(mpc_streaminfo * si)
 246 {
 247     return (double) (si->samples - si->beg_silence) / si->sample_freq;
 248 }
 249
 250 mpc_int64_t mpc_streaminfo_get_length_samples(mpc_streaminfo *si)
 251 {
 252     return si->samples - si->beg_silence;
 253 }
 254 */