devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity

Musepack support, complete with mpc2wav plugin. Thanks go out to rasher for initiating the port.

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@6276 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Thom Johansen 2005-04-12 21:29:48 +00:00
parent 34e2f722f7
commit ad17fd4747
31 changed files with 4397 additions and 4 deletions
Download patch file Download diff file Expand all files Collapse all files

1
apps/FILES
View file

@ -46,3 +46,4 @@ codecs/dumb/src/allegro/*
codecs/dumb/src/core/* codecs/dumb/src/core/*
codecs/dumb/src/helpers/* codecs/dumb/src/helpers/*
codecs/dumb/src/it/* codecs/dumb/src/it/*
codecs/libmusepack/*

10
apps/codecs/Makefile
View file

@ -16,7 +16,7 @@ ifdef APPEXTRA
INCLUDES += -I$(APPSDIR)/$(APPEXTRA) INCLUDES += -I$(APPSDIR)/$(APPEXTRA)
endif endif
.PHONY: libmad liba52 libFLAC libTremor libwavpack dumb .PHONY: libmad liba52 libFLAC libTremor libwavpack dumb libmusepack
OUTPUT = $(SOFTWARECODECS) OUTPUT = $(SOFTWARECODECS)
@ -55,11 +55,17 @@ dumb:
@mkdir -p $(OBJDIR)/dumb @mkdir -p $(OBJDIR)/dumb
@$(MAKE) -C dumb TARGET=$(TARGET) DEBUG=$(DEBUG) OBJDIR=$(OBJDIR)/dumb VERSION=$(VERSION) EXTRA_DEFINES="$(EXTRA_DEFINES)" MEM=${MEMORYSIZE} LIBDIR=$(OBJDIR) OFLAGS="$(CFLAGS)" @$(MAKE) -C dumb TARGET=$(TARGET) DEBUG=$(DEBUG) OBJDIR=$(OBJDIR)/dumb VERSION=$(VERSION) EXTRA_DEFINES="$(EXTRA_DEFINES)" MEM=${MEMORYSIZE} LIBDIR=$(OBJDIR) OFLAGS="$(CFLAGS)"
libmusepack:
@echo "MAKE in libmusepack"
@mkdir -p $(OBJDIR)/libmusepack
@$(MAKE) -C libmusepack TARGET=$(TARGET) DEBUG=$(DEBUG) OBJDIR=$(OBJDIR)/libmusepack VERSION=$(VERSION) EXTRA_DEFINES="$(EXTRA_DEFINES)" MEM=${MEMORYSIZE} OUTPUT=$(OBJDIR)/libmusepack.a
clean: clean:
@echo "cleaning codecs" @echo "cleaning codecs"
@rm -fr $(OBJDIR)/libmad $(OBJDIR)/libmad.a $(OBJDIR)/liba52 $(OBJDIR)/libFLAC $(OBJDIR)/Tremor $(OBJDIR)/libwavpack $(OBJDIR)/dumb $(OBJDIR)/libdumb.a $(OBJDIR)/libdumbd.a @rm -fr $(OBJDIR)/libmad $(OBJDIR)/libmad.a $(OBJDIR)/liba52 $(OBJDIR)/libFLAC $(OBJDIR)/Tremor $(OBJDIR)/libwavpack $(OBJDIR)/dumb $(OBJDIR)/libdumb.a $(OBJDIR)/libdumbd.a $(OBJDIR)/libmusepack $(OBJDIR)/libmusepack.a
@$(MAKE) -C libmad clean @$(MAKE) -C libmad clean
@$(MAKE) -C liba52 clean @$(MAKE) -C liba52 clean
@$(MAKE) -C libFLAC clean @$(MAKE) -C libFLAC clean
@$(MAKE) -C Tremor clean @$(MAKE) -C Tremor clean
@$(MAKE) -C libwavpack clean @$(MAKE) -C libwavpack clean
@$(MAKE) -C libmusepack clean

10
apps/codecs/libmusepack/AUTHORS Normal file
View file

@ -0,0 +1,10 @@
libmusepack is the result of the work of many people:
* Andree Buschmann and Frank Klemm
Original implementation and core development.
* Peter Pawlowski and Benoit Amiaux
Portability and further optimizations.
* Miles Egan
Port to pure C, documentation, and api refinements.

31
apps/codecs/libmusepack/COPYING Normal file
View file

@ -0,0 +1,31 @@
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

12
apps/codecs/libmusepack/ChangeLog Normal file
View file

@ -0,0 +1,12 @@
1.1
* add compliance & cleanup patches from Michael Roitzsch of xine project
* switch to BSD license
* port to pure C
* add doxygen documentation
* revise API somewhat
1.0.3
* autotools build process
* sample binary added
* floating-point mode by default

47
apps/codecs/libmusepack/Makefile Normal file
View file

@ -0,0 +1,47 @@
# __________ __ ___.
# Open \______ \ ____ ____ | | _\_ |__ _______ ___
# Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
# Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
# Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
# \/ \/ \/ \/ \/
# $Id$
#
INCLUDES=-I$(APPSDIR) -I.. -I. -I$(FIRMDIR)/include -I$(FIRMDIR)/export \
-I$(FIRMDIR)/common -I$(FIRMDIR)/drivers
ifdef APPEXTRA
INCLUDES += -I$(APPSDIR)/$(APPEXTRA)
endif
CFLAGS = $(GCCOPTS) \
$(INCLUDES) $(TARGET) $(EXTRA_DEFINES) -DMEM=${MEMORYSIZE}
# This sets up 'SRC' based on the files mentioned in SOURCES
include $(TOOLSDIR)/makesrc.inc
SOURCES = $(SRC)
OBJS2 := $(SRC:%.c=$(OBJDIR)/%.o)
OBJS = $(patsubst %.S, $(OBJDIR)/%.o, $(OBJS2))
DEPFILE = $(OBJDIR)/dep-libmusepack
DIRS =
OUTPUT = $(OBJDIR)/libmusepack.a
all: $(OUTPUT)
$(OUTPUT): $(OBJS)
@echo "AR $@"
@$(AR) ruv $@ $+ >/dev/null 2>&1
$(OBJDIR)/libmusepack/%.o: $(APPSDIR)/codecs/libmusepack/%.c
@echo "CC $<"
@$(CC) -c -O2 $(CFLAGS) -I$(APPSDIR)/codecs/libmusepack/ $< -o $@
include $(TOOLSDIR)/make.inc
clean:
@echo "cleaning libmusepack"
@rm -f $(OBJS) $(OUTPUT) $(DEPFILE)
-include $(DEPFILE)

6
apps/codecs/libmusepack/README Normal file
View file

@ -0,0 +1,6 @@
Musepack Decoder Library 1.1:
run "./configure; make"
To create a sample app using the musepack decoder library in src/
Check src/sample.cpp for more details.

27
apps/codecs/libmusepack/README.rockbox Normal file
View file

@ -0,0 +1,27 @@
Library: libmusepack-1.1 (Released 2005-01-22 (I think))
Imported: 2005-04-12 by Thom Johansen
This directory contains a local version of libmusepack for use by Rockbox
for software decoding and encoding of Musepack files.
LICENSING INFORMATION
libmusepack is distributed under a modified BSD license - see the files AUTHORS
and COPYING in this directory for details.
IMPORT DETAILS
The base version first imported into Rockbox was the libmusepack included
in the libmusepack-1.1.tar.bz2 distribution, downloaded on 2005-04-11 from
www.musepack.net.
The contents of the libmusepack-1.1/, libmusepack-1.1/src/ and
libmusepack-1.1/include/ were all put in one directory for simplicity, and
the sample decoder and automake/autoconf stuff were removed. The default
FILE* based IO handlers in mpc_reader.c were also removed. Some small
modifications to make the library compilable and compatible with Rockbox
was made.

8
apps/codecs/libmusepack/SOURCES Normal file
View file

@ -0,0 +1,8 @@
huffsv46.c
huffsv7.c
idtag.c
mpc_decoder.c
requant.c
streaminfo.c
synth_filter.c

105
apps/codecs/libmusepack/config.h Normal file
View file

@ -0,0 +1,105 @@
/* include/config.h. Generated by configure. */
/* include/config.h.in. Generated from configure.in by autoheader. */
/* Define to 1 if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1
/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1
/* Define to 1 if you have the `memmove' function. */
#define HAVE_MEMMOVE 1
/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1
/* Define to 1 if you have the `memset' function. */
#define HAVE_MEMSET 1
/* Define to 1 if the system has the type `ptrdiff_t'. */
#define HAVE_PTRDIFF_T 1
/* Define to 1 if you have the `sqrt' function. */
/* #undef HAVE_SQRT */
/* Define to 1 if stdbool.h conforms to C99. */
#define HAVE_STDBOOL_H 1
/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1
/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1
/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1
/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1
/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1
/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1
/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1
/* Define to 1 if the system has the type `_Bool'. */
#define HAVE__BOOL 1
/* Name of package */
#define PACKAGE "libmusepack"
/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT ""
/* Define to the full name of this package. */
#define PACKAGE_NAME ""
/* Define to the full name and version of this package. */
#define PACKAGE_STRING ""
/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME ""
/* Define to the version of this package. */
#define PACKAGE_VERSION ""
/* The size of a `int', as computed by sizeof. */
#define SIZEOF_INT 4
/* The size of a `long', as computed by sizeof. */
#define SIZEOF_LONG 4
/* The size of a `long long', as computed by sizeof. */
#define SIZEOF_LONG_LONG 8
/* The size of a `short', as computed by sizeof. */
#define SIZEOF_SHORT 2
/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Version number of package */
#define VERSION "1.1"
/* Define to 1 if your processor stores words with the most significant byte
first (like Motorola and SPARC, unlike Intel and VAX). */
/* #undef WORDS_BIGENDIAN */
/* Define to empty if `const' does not conform to ANSI C. */
/* #undef const */
/* Define to `__inline__' or `__inline' if that's what the C compiler
calls it, or to nothing if 'inline' is not supported under any name. */
#ifndef __cplusplus
/* #undef inline */
#endif
/* Define to `long' if <sys/types.h> does not define. */
/* #undef off_t */
/* Define to `unsigned' if <sys/types.h> does not define. */
/* #undef size_t */

49
apps/codecs/libmusepack/config_types.h Normal file
View file

@ -0,0 +1,49 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __MUSEPACK_CONFIG_TYPES_H__
#define __MUSEPACK_CONFIG_TYPES_H__
// typedef unsigned char BOOL;
// #define TRUE 1
// #define FALSE 0
/* these are filled in by configure */
typedef short mpc_int16_t;
typedef unsigned short mpc_uint16_t;
typedef int mpc_int32_t;
typedef unsigned int mpc_uint32_t;
typedef long long mpc_int64_t;
#endif // __MUSEPACK_CONFIG_TYPES_H__

148
apps/codecs/libmusepack/decoder.h Normal file
View file

@ -0,0 +1,148 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file decoder.h
#ifndef _musepack_decoder_h_
#define _musepack_decoder_h_
#include "huffman.h"
#include "math.h"
#include "musepack.h"
#include "reader.h"
#include "streaminfo.h"
enum {
MPC_V_MEM = 2304,
MPC_DECODER_MEMSIZE = 16384, // overall buffer size
};
typedef struct {
mpc_int32_t L [36];
mpc_int32_t R [36];
} QuantTyp;
typedef struct mpc_decoder_t {
mpc_reader *r;
/// @name internal state variables
//@{
mpc_uint32_t dword; /// actually decoded 32bit-word
mpc_uint32_t pos; /// bit-position within dword
mpc_uint32_t Speicher[MPC_DECODER_MEMSIZE]; /// read-buffer
mpc_uint32_t Zaehler; /// actual index within read-buffer
mpc_uint32_t samples_to_skip;
mpc_uint32_t FwdJumpInfo;
mpc_uint32_t ActDecodePos;
mpc_uint32_t FrameWasValid;
mpc_uint32_t DecodedFrames;
mpc_uint32_t OverallFrames;
mpc_int32_t SampleRate; // Sample frequency
mpc_uint32_t StreamVersion; // version of bitstream
mpc_uint32_t MS_used; // MS-coding used ?
mpc_int32_t Max_Band;
mpc_uint32_t MPCHeaderPos; // AB: needed to support ID3v2
mpc_uint32_t LastValidSamples;
mpc_uint32_t TrueGaplessPresent;
mpc_uint32_t EQ_activated;
mpc_uint32_t WordsRead; // counts amount of decoded dwords
// randomizer state variables
mpc_uint32_t __r1;
mpc_uint32_t __r2;
mpc_uint32_t Q_bit [32];
mpc_uint32_t Q_res [32][16];
// huffman table stuff
HuffmanTyp HuffHdr [10];
HuffmanTyp HuffSCFI [ 4];
HuffmanTyp HuffDSCF [16];
HuffmanTyp* HuffQ [2] [8];
HuffmanTyp HuffQ1 [2] [3*3*3];
HuffmanTyp HuffQ2 [2] [5*5];
HuffmanTyp HuffQ3 [2] [ 7];
HuffmanTyp HuffQ4 [2] [ 9];
HuffmanTyp HuffQ5 [2] [15];
HuffmanTyp HuffQ6 [2] [31];
HuffmanTyp HuffQ7 [2] [63];
const HuffmanTyp* SampleHuff [18];
HuffmanTyp SCFI_Bundle [ 8];
HuffmanTyp DSCF_Entropie [13];
HuffmanTyp Region_A [16];
HuffmanTyp Region_B [ 8];
HuffmanTyp Region_C [ 4];
HuffmanTyp Entropie_1 [ 3];
HuffmanTyp Entropie_2 [ 5];
HuffmanTyp Entropie_3 [ 7];
HuffmanTyp Entropie_4 [ 9];
HuffmanTyp Entropie_5 [15];
HuffmanTyp Entropie_6 [31];
HuffmanTyp Entropie_7 [63];
mpc_int32_t SCF_Index_L [32] [3];
mpc_int32_t SCF_Index_R [32] [3]; // holds scalefactor-indices
QuantTyp Q [32]; // holds quantized samples
mpc_int32_t Res_L [32];
mpc_int32_t Res_R [32]; // holds the chosen quantizer for each subband
mpc_int32_t DSCF_Flag_L [32];
mpc_int32_t DSCF_Flag_R [32]; // differential SCF used?
mpc_int32_t SCFI_L [32];
mpc_int32_t SCFI_R [32]; // describes order of transmitted SCF
mpc_int32_t DSCF_Reference_L [32];
mpc_int32_t DSCF_Reference_R [32]; // holds last frames SCF
mpc_int32_t MS_Flag[32]; // MS used?
#ifdef MPC_FIXED_POINT
unsigned char SCF_shift[256];
#endif
MPC_SAMPLE_FORMAT V_L[MPC_V_MEM + 960];
MPC_SAMPLE_FORMAT V_R[MPC_V_MEM + 960];
MPC_SAMPLE_FORMAT Y_L[36][32];
MPC_SAMPLE_FORMAT Y_R[36][32];
MPC_SAMPLE_FORMAT SCF[256]; ///< holds adapted scalefactors (for clipping prevention)
//@}
} mpc_decoder;
#endif // _mpc_decoder_h

75
apps/codecs/libmusepack/huffman.h Normal file
View file

@ -0,0 +1,75 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file huffman.h
/// Data structures and functions for huffman coding.
#ifndef _musepack_huffman_h_
#define _musepack_huffman_h_
#include "config_types.h"
#include "decoder.h"
struct mpc_decoder_t; // forward declare to break circular dependencies
/// Huffman table entry.
typedef struct huffman_type_t {
mpc_uint32_t Code;
mpc_uint32_t Length;
mpc_int32_t Value;
} HuffmanTyp;
//! \brief Sorts huffman-tables by codeword.
//!
//! offset resulting value.
//! \param elements
//! \param Table table to sort
//! \param offset offset of resulting sort
void
mpc_decoder_resort_huff_tables(
const mpc_uint32_t elements, HuffmanTyp *Table, const mpc_int32_t offset);
/// Initializes sv6 huffman decoding structures.
void mpc_decoder_init_huffman_sv6(struct mpc_decoder_t *d);
/// Initializes sv6 huffman decoding tables.
void mpc_decoder_init_huffman_sv6_tables(struct mpc_decoder_t *d);
/// Initializes sv7 huffman decoding structures.
void mpc_decoder_init_huffman_sv7(struct mpc_decoder_t *d);
/// Initializes sv7 huffman decoding tables.
void mpc_decoder_init_huffman_sv7_tables(struct mpc_decoder_t *d);
#endif // _musepack_huffman_h_

268
apps/codecs/libmusepack/huffsv46.c Normal file
View file

@ -0,0 +1,268 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file huffsv46.c
/// Implementations of huffman decoding for streamversions < 7.
#include "musepack.h"
#include "requant.h"
#include "huffman.h"
void
mpc_decoder_init_huffman_sv6(mpc_decoder *d)
{
mpc_decoder_init_huffman_sv6_tables(d);
mpc_decoder_resort_huff_tables(16, d->Region_A , 0);
mpc_decoder_resort_huff_tables( 8, d->Region_B , 0);
mpc_decoder_resort_huff_tables( 4, d->Region_C , 0);
mpc_decoder_resort_huff_tables( 8, d->SCFI_Bundle , 0);
mpc_decoder_resort_huff_tables(13, d->DSCF_Entropie , 6);
mpc_decoder_resort_huff_tables( 3, d->Entropie_1 , Dc[1]);
mpc_decoder_resort_huff_tables( 5, d->Entropie_2 , Dc[2]);
mpc_decoder_resort_huff_tables( 7, d->Entropie_3 , Dc[3]);
mpc_decoder_resort_huff_tables( 9, d->Entropie_4 , Dc[4]);
mpc_decoder_resort_huff_tables(15, d->Entropie_5 , Dc[5]);
mpc_decoder_resort_huff_tables(31, d->Entropie_6 , Dc[6]);
mpc_decoder_resort_huff_tables(63, d->Entropie_7 , Dc[7]);
}
void
mpc_decoder_init_huffman_sv6_tables(mpc_decoder *d)
{
// SCFI-bundle
d->SCFI_Bundle[7].Code= 1; d->SCFI_Bundle[7].Length= 1;
d->SCFI_Bundle[3].Code= 1; d->SCFI_Bundle[3].Length= 2;
d->SCFI_Bundle[5].Code= 0; d->SCFI_Bundle[5].Length= 3;
d->SCFI_Bundle[1].Code= 7; d->SCFI_Bundle[1].Length= 5;
d->SCFI_Bundle[2].Code= 6; d->SCFI_Bundle[2].Length= 5;
d->SCFI_Bundle[4].Code= 4; d->SCFI_Bundle[4].Length= 5;
d->SCFI_Bundle[0].Code= 11; d->SCFI_Bundle[0].Length= 6;
d->SCFI_Bundle[6].Code= 10; d->SCFI_Bundle[6].Length= 6;
// region A (subbands 0..10)
d->Region_A[ 1].Code= 1; d->Region_A[ 1].Length= 1;
d->Region_A[ 2].Code= 0; d->Region_A[ 2].Length= 2;
d->Region_A[ 0].Code= 2; d->Region_A[ 0].Length= 3;
d->Region_A[ 3].Code= 15; d->Region_A[ 3].Length= 5;
d->Region_A[ 5].Code= 13; d->Region_A[ 5].Length= 5;
d->Region_A[ 6].Code= 12; d->Region_A[ 6].Length= 5;
d->Region_A[ 4].Code= 29; d->Region_A[ 4].Length= 6;
d->Region_A[ 7].Code= 57; d->Region_A[ 7].Length= 7;
d->Region_A[ 8].Code= 113; d->Region_A[ 8].Length= 8;
d->Region_A[ 9].Code= 225; d->Region_A[ 9].Length= 9;
d->Region_A[10].Code= 449; d->Region_A[10].Length= 10;
d->Region_A[11].Code= 897; d->Region_A[11].Length= 11;
d->Region_A[12].Code= 1793; d->Region_A[12].Length= 12;
d->Region_A[13].Code= 3585; d->Region_A[13].Length= 13;
d->Region_A[14].Code= 7169; d->Region_A[14].Length= 14;
d->Region_A[15].Code= 7168; d->Region_A[15].Length= 14;
// region B (subbands 11..22)
d->Region_B[1].Code= 1; d->Region_B[1].Length= 1;
d->Region_B[0].Code= 1; d->Region_B[0].Length= 2;
d->Region_B[2].Code= 1; d->Region_B[2].Length= 3;
d->Region_B[3].Code= 1; d->Region_B[3].Length= 4;
d->Region_B[4].Code= 1; d->Region_B[4].Length= 5;
d->Region_B[5].Code= 1; d->Region_B[5].Length= 6;
d->Region_B[6].Code= 1; d->Region_B[6].Length= 7;
d->Region_B[7].Code= 0; d->Region_B[7].Length= 7;
// region C (subbands 23..31)
d->Region_C[0].Code= 1; d->Region_C[0].Length= 1;
d->Region_C[1].Code= 1; d->Region_C[1].Length= 2;
d->Region_C[2].Code= 1; d->Region_C[2].Length= 3;
d->Region_C[3].Code= 0; d->Region_C[3].Length= 3;
// DSCF
d->DSCF_Entropie[ 6].Code= 0; d->DSCF_Entropie[ 6].Length= 2;
d->DSCF_Entropie[ 7].Code= 7; d->DSCF_Entropie[ 7].Length= 3;
d->DSCF_Entropie[ 5].Code= 4; d->DSCF_Entropie[ 5].Length= 3;
d->DSCF_Entropie[ 8].Code= 3; d->DSCF_Entropie[ 8].Length= 3;
d->DSCF_Entropie[ 9].Code= 13; d->DSCF_Entropie[ 9].Length= 4;
d->DSCF_Entropie[ 4].Code= 11; d->DSCF_Entropie[ 4].Length= 4;
d->DSCF_Entropie[10].Code= 10; d->DSCF_Entropie[10].Length= 4;
d->DSCF_Entropie[ 2].Code= 4; d->DSCF_Entropie[ 2].Length= 4;
d->DSCF_Entropie[11].Code= 25; d->DSCF_Entropie[11].Length= 5;
d->DSCF_Entropie[ 3].Code= 24; d->DSCF_Entropie[ 3].Length= 5;
d->DSCF_Entropie[ 1].Code= 11; d->DSCF_Entropie[ 1].Length= 5;
d->DSCF_Entropie[12].Code= 21; d->DSCF_Entropie[12].Length= 6;
d->DSCF_Entropie[ 0].Code= 20; d->DSCF_Entropie[ 0].Length= 6;
// first quantizer
d->Entropie_1[1].Code= 1; d->Entropie_1[1].Length= 1;
d->Entropie_1[0].Code= 1; d->Entropie_1[0].Length= 2;
d->Entropie_1[2].Code= 0; d->Entropie_1[2].Length= 2;
// second quantizer
d->Entropie_2[2].Code= 3; d->Entropie_2[2].Length= 2;
d->Entropie_2[3].Code= 1; d->Entropie_2[3].Length= 2;
d->Entropie_2[1].Code= 0; d->Entropie_2[1].Length= 2;
d->Entropie_2[4].Code= 5; d->Entropie_2[4].Length= 3;
d->Entropie_2[0].Code= 4; d->Entropie_2[0].Length= 3;
// third quantizer
d->Entropie_3[3].Code= 3; d->Entropie_3[3].Length= 2;
d->Entropie_3[2].Code= 1; d->Entropie_3[2].Length= 2;
d->Entropie_3[4].Code= 0; d->Entropie_3[4].Length= 2;
d->Entropie_3[1].Code= 5; d->Entropie_3[1].Length= 3;
d->Entropie_3[5].Code= 9; d->Entropie_3[5].Length= 4;
d->Entropie_3[0].Code= 17; d->Entropie_3[0].Length= 5;
d->Entropie_3[6].Code= 16; d->Entropie_3[6].Length= 5;
// forth quantizer
d->Entropie_4[4].Code= 0; d->Entropie_4[4].Length= 2;
d->Entropie_4[5].Code= 6; d->Entropie_4[5].Length= 3;
d->Entropie_4[3].Code= 5; d->Entropie_4[3].Length= 3;
d->Entropie_4[6].Code= 4; d->Entropie_4[6].Length= 3;
d->Entropie_4[2].Code= 3; d->Entropie_4[2].Length= 3;
d->Entropie_4[7].Code= 15; d->Entropie_4[7].Length= 4;
d->Entropie_4[1].Code= 14; d->Entropie_4[1].Length= 4;
d->Entropie_4[0].Code= 5; d->Entropie_4[0].Length= 4;
d->Entropie_4[8].Code= 4; d->Entropie_4[8].Length= 4;
// fifth quantizer
d->Entropie_5[7 ].Code= 4; d->Entropie_5[7 ].Length= 3;
d->Entropie_5[8 ].Code= 3; d->Entropie_5[8 ].Length= 3;
d->Entropie_5[6 ].Code= 2; d->Entropie_5[6 ].Length= 3;
d->Entropie_5[9 ].Code= 0; d->Entropie_5[9 ].Length= 3;
d->Entropie_5[5 ].Code= 15; d->Entropie_5[5 ].Length= 4;
d->Entropie_5[4 ].Code= 13; d->Entropie_5[4 ].Length= 4;
d->Entropie_5[10].Code= 12; d->Entropie_5[10].Length= 4;
d->Entropie_5[11].Code= 10; d->Entropie_5[11].Length= 4;
d->Entropie_5[3 ].Code= 3; d->Entropie_5[3 ].Length= 4;
d->Entropie_5[12].Code= 2; d->Entropie_5[12].Length= 4;
d->Entropie_5[2 ].Code= 29; d->Entropie_5[2 ].Length= 5;
d->Entropie_5[1 ].Code= 23; d->Entropie_5[1 ].Length= 5;
d->Entropie_5[13].Code= 22; d->Entropie_5[13].Length= 5;
d->Entropie_5[0 ].Code= 57; d->Entropie_5[0 ].Length= 6;
d->Entropie_5[14].Code= 56; d->Entropie_5[14].Length= 6;
// sixth quantizer
d->Entropie_6[15].Code= 9; d->Entropie_6[15].Length= 4;
d->Entropie_6[16].Code= 8; d->Entropie_6[16].Length= 4;
d->Entropie_6[14].Code= 7; d->Entropie_6[14].Length= 4;
d->Entropie_6[18].Code= 6; d->Entropie_6[18].Length= 4;
d->Entropie_6[17].Code= 5; d->Entropie_6[17].Length= 4;
d->Entropie_6[12].Code= 3; d->Entropie_6[12].Length= 4;
d->Entropie_6[13].Code= 2; d->Entropie_6[13].Length= 4;
d->Entropie_6[19].Code= 0; d->Entropie_6[19].Length= 4;
d->Entropie_6[11].Code= 31; d->Entropie_6[11].Length= 5;
d->Entropie_6[20].Code= 30; d->Entropie_6[20].Length= 5;
d->Entropie_6[10].Code= 29; d->Entropie_6[10].Length= 5;
d->Entropie_6[9 ].Code= 27; d->Entropie_6[9 ].Length= 5;
d->Entropie_6[21].Code= 26; d->Entropie_6[21].Length= 5;
d->Entropie_6[22].Code= 25; d->Entropie_6[22].Length= 5;
d->Entropie_6[8 ].Code= 24; d->Entropie_6[8 ].Length= 5;
d->Entropie_6[7 ].Code= 23; d->Entropie_6[7 ].Length= 5;
d->Entropie_6[23].Code= 21; d->Entropie_6[23].Length= 5;
d->Entropie_6[6 ].Code= 9; d->Entropie_6[6 ].Length= 5;
d->Entropie_6[24].Code= 3; d->Entropie_6[24].Length= 5;
d->Entropie_6[25].Code= 57; d->Entropie_6[25].Length= 6;
d->Entropie_6[5 ].Code= 56; d->Entropie_6[5 ].Length= 6;
d->Entropie_6[4 ].Code= 45; d->Entropie_6[4 ].Length= 6;
d->Entropie_6[26].Code= 41; d->Entropie_6[26].Length= 6;
d->Entropie_6[2 ].Code= 40; d->Entropie_6[2 ].Length= 6;
d->Entropie_6[27].Code= 17; d->Entropie_6[27].Length= 6;
d->Entropie_6[28].Code= 16; d->Entropie_6[28].Length= 6;
d->Entropie_6[3 ].Code= 5; d->Entropie_6[3 ].Length= 6;
d->Entropie_6[29].Code= 89; d->Entropie_6[29].Length= 7;
d->Entropie_6[1 ].Code= 88; d->Entropie_6[1 ].Length= 7;
d->Entropie_6[30].Code= 9; d->Entropie_6[30].Length= 7;
d->Entropie_6[0 ].Code= 8; d->Entropie_6[0 ].Length= 7;
// seventh quantizer
d->Entropie_7[25].Code= 0; d->Entropie_7[25].Length= 5;
d->Entropie_7[37].Code= 1; d->Entropie_7[37].Length= 5;
d->Entropie_7[62].Code= 16; d->Entropie_7[62].Length= 8;
d->Entropie_7[ 0].Code= 17; d->Entropie_7[ 0].Length= 8;
d->Entropie_7[ 3].Code= 9; d->Entropie_7[ 3].Length= 7;
d->Entropie_7[ 5].Code= 10; d->Entropie_7[ 5].Length= 7;
d->Entropie_7[ 6].Code= 11; d->Entropie_7[ 6].Length= 7;
d->Entropie_7[38].Code= 3; d->Entropie_7[38].Length= 5;
d->Entropie_7[35].Code= 4; d->Entropie_7[35].Length= 5;
d->Entropie_7[33].Code= 5; d->Entropie_7[33].Length= 5;
d->Entropie_7[24].Code= 6; d->Entropie_7[24].Length= 5;
d->Entropie_7[27].Code= 7; d->Entropie_7[27].Length= 5;
d->Entropie_7[26].Code= 8; d->Entropie_7[26].Length= 5;
d->Entropie_7[12].Code= 18; d->Entropie_7[12].Length= 6;
d->Entropie_7[50].Code= 19; d->Entropie_7[50].Length= 6;
d->Entropie_7[29].Code= 10; d->Entropie_7[29].Length= 5;
d->Entropie_7[31].Code= 11; d->Entropie_7[31].Length= 5;
d->Entropie_7[36].Code= 12; d->Entropie_7[36].Length= 5;
d->Entropie_7[34].Code= 13; d->Entropie_7[34].Length= 5;
d->Entropie_7[28].Code= 14; d->Entropie_7[28].Length= 5;
d->Entropie_7[49].Code= 30; d->Entropie_7[49].Length= 6;
d->Entropie_7[56].Code= 62; d->Entropie_7[56].Length= 7;
d->Entropie_7[ 7].Code= 63; d->Entropie_7[ 7].Length= 7;
d->Entropie_7[32].Code= 16; d->Entropie_7[32].Length= 5;
d->Entropie_7[30].Code= 17; d->Entropie_7[30].Length= 5;
d->Entropie_7[13].Code= 36; d->Entropie_7[13].Length= 6;
d->Entropie_7[55].Code= 74; d->Entropie_7[55].Length= 7;
d->Entropie_7[61].Code= 150; d->Entropie_7[61].Length= 8;
d->Entropie_7[ 1].Code= 151; d->Entropie_7[ 1].Length= 8;
d->Entropie_7[14].Code= 38; d->Entropie_7[14].Length= 6;
d->Entropie_7[48].Code= 39; d->Entropie_7[48].Length= 6;
d->Entropie_7[ 4].Code= 80; d->Entropie_7[ 4].Length= 7;
d->Entropie_7[58].Code= 81; d->Entropie_7[58].Length= 7;
d->Entropie_7[47].Code= 41; d->Entropie_7[47].Length= 6;
d->Entropie_7[15].Code= 42; d->Entropie_7[15].Length= 6;
d->Entropie_7[16].Code= 43; d->Entropie_7[16].Length= 6;
d->Entropie_7[54].Code= 88; d->Entropie_7[54].Length= 7;
d->Entropie_7[ 8].Code= 89; d->Entropie_7[ 8].Length= 7;
d->Entropie_7[17].Code= 45; d->Entropie_7[17].Length= 6;
d->Entropie_7[46].Code= 46; d->Entropie_7[46].Length= 6;
d->Entropie_7[45].Code= 47; d->Entropie_7[45].Length= 6;
d->Entropie_7[53].Code= 96; d->Entropie_7[53].Length= 7;
d->Entropie_7[ 9].Code= 97; d->Entropie_7[ 9].Length= 7;
d->Entropie_7[43].Code= 49; d->Entropie_7[43].Length= 6;
d->Entropie_7[19].Code= 50; d->Entropie_7[19].Length= 6;
d->Entropie_7[18].Code= 51; d->Entropie_7[18].Length= 6;
d->Entropie_7[44].Code= 52; d->Entropie_7[44].Length= 6;
d->Entropie_7[ 2].Code= 212; d->Entropie_7[ 2].Length= 8;
d->Entropie_7[60].Code= 213; d->Entropie_7[60].Length= 8;
d->Entropie_7[10].Code= 107; d->Entropie_7[10].Length= 7;
d->Entropie_7[42].Code= 54; d->Entropie_7[42].Length= 6;
d->Entropie_7[41].Code= 55; d->Entropie_7[41].Length= 6;
d->Entropie_7[20].Code= 56; d->Entropie_7[20].Length= 6;
d->Entropie_7[21].Code= 57; d->Entropie_7[21].Length= 6;
d->Entropie_7[52].Code= 116; d->Entropie_7[52].Length= 7;
d->Entropie_7[51].Code= 117; d->Entropie_7[51].Length= 7;
d->Entropie_7[40].Code= 59; d->Entropie_7[40].Length= 6;
d->Entropie_7[22].Code= 60; d->Entropie_7[22].Length= 6;
d->Entropie_7[23].Code= 61; d->Entropie_7[23].Length= 6;
d->Entropie_7[39].Code= 62; d->Entropie_7[39].Length= 6;
d->Entropie_7[11].Code= 126; d->Entropie_7[11].Length= 7;
d->Entropie_7[57].Code= 254; d->Entropie_7[57].Length= 8;
d->Entropie_7[59].Code= 255; d->Entropie_7[59].Length= 8;
}

500
apps/codecs/libmusepack/huffsv7.c Normal file
View file

@ -0,0 +1,500 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file huffsv7.c
/// Implementations of sv7 huffman decoding functions.
#include "musepack.h"
#include "huffman.h"
#include "requant.h"
void
mpc_decoder_init_huffman_sv7(mpc_decoder *d)
{
mpc_decoder_init_huffman_sv7_tables(d);
mpc_decoder_resort_huff_tables(10, &(d->HuffHdr[0]) , 5);
mpc_decoder_resort_huff_tables( 4, &(d->HuffSCFI[0]) , 0);
mpc_decoder_resort_huff_tables(16, &(d->HuffDSCF[0]) , 7);
mpc_decoder_resort_huff_tables(27, &(d->HuffQ1[0][0]) , 0);
mpc_decoder_resort_huff_tables(27, &(d->HuffQ1[1][0]) , 0);
mpc_decoder_resort_huff_tables(25, &(d->HuffQ2[0][0]) , 0);
mpc_decoder_resort_huff_tables(25, &(d->HuffQ2[1][0]) , 0);
mpc_decoder_resort_huff_tables( 7, &(d->HuffQ3[0][0]) , Dc[3]);
mpc_decoder_resort_huff_tables( 7, &(d->HuffQ3[1][0]) , Dc[3]);
mpc_decoder_resort_huff_tables( 9, &(d->HuffQ4[0][0]) , Dc[4]);
mpc_decoder_resort_huff_tables( 9, &(d->HuffQ4[1][0]) , Dc[4]);
mpc_decoder_resort_huff_tables(15, &(d->HuffQ5[0][0]) , Dc[5]);
mpc_decoder_resort_huff_tables(15, &(d->HuffQ5[1][0]) , Dc[5]);
mpc_decoder_resort_huff_tables(31, &(d->HuffQ6[0][0]) , Dc[6]);
mpc_decoder_resort_huff_tables(31, &(d->HuffQ6[1][0]) , Dc[6]);
mpc_decoder_resort_huff_tables(63, &(d->HuffQ7[0][0]) , Dc[7]);
mpc_decoder_resort_huff_tables(63, &(d->HuffQ7[1][0]) , Dc[7]);
}
void
mpc_decoder_init_huffman_sv7_tables(mpc_decoder *d)
{
/***************************** SCFI *******************************/
d->HuffSCFI[0].Code = 2; d->HuffSCFI[0].Length = 3;
d->HuffSCFI[1].Code = 1; d->HuffSCFI[1].Length = 1;
d->HuffSCFI[2].Code = 3; d->HuffSCFI[2].Length = 3;
d->HuffSCFI[3].Code = 0; d->HuffSCFI[3].Length = 2;
/***************************** DSCF *******************************/
d->HuffDSCF[ 0].Code = 32; d->HuffDSCF[ 0].Length = 6;
d->HuffDSCF[ 1].Code = 4; d->HuffDSCF[ 1].Length = 5;
d->HuffDSCF[ 2].Code = 17; d->HuffDSCF[ 2].Length = 5;
d->HuffDSCF[ 3].Code = 30; d->HuffDSCF[ 3].Length = 5;
d->HuffDSCF[ 4].Code = 13; d->HuffDSCF[ 4].Length = 4;
d->HuffDSCF[ 5].Code = 0; d->HuffDSCF[ 5].Length = 3;
d->HuffDSCF[ 6].Code = 3; d->HuffDSCF[ 6].Length = 3;
d->HuffDSCF[ 7].Code = 9; d->HuffDSCF[ 7].Length = 4;
d->HuffDSCF[ 8].Code = 5; d->HuffDSCF[ 8].Length = 3;
d->HuffDSCF[ 9].Code = 2; d->HuffDSCF[ 9].Length = 3;
d->HuffDSCF[10].Code = 14; d->HuffDSCF[10].Length = 4;
d->HuffDSCF[11].Code = 3; d->HuffDSCF[11].Length = 4;
d->HuffDSCF[12].Code = 31; d->HuffDSCF[12].Length = 5;
d->HuffDSCF[13].Code = 5; d->HuffDSCF[13].Length = 5;
d->HuffDSCF[14].Code = 33; d->HuffDSCF[14].Length = 6;
d->HuffDSCF[15].Code = 12; d->HuffDSCF[15].Length = 4;
/************************* frame-header ***************************/
/***************** differential quantizer indizes *****************/
d->HuffHdr[0].Code = 92; d->HuffHdr[0].Length = 8;
d->HuffHdr[1].Code = 47; d->HuffHdr[1].Length = 7;
d->HuffHdr[2].Code = 10; d->HuffHdr[2].Length = 5;
d->HuffHdr[3].Code = 4; d->HuffHdr[3].Length = 4;
d->HuffHdr[4].Code = 0; d->HuffHdr[4].Length = 2;
d->HuffHdr[5].Code = 1; d->HuffHdr[5].Length = 1;
d->HuffHdr[6].Code = 3; d->HuffHdr[6].Length = 3;
d->HuffHdr[7].Code = 22; d->HuffHdr[7].Length = 6;
d->HuffHdr[8].Code = 187; d->HuffHdr[8].Length = 9;
d->HuffHdr[9].Code = 186; d->HuffHdr[9].Length = 9;
/********************** 3-step quantizer **************************/
/********************* 3 bundled samples **************************/
//less shaped, book 0
d->HuffQ1[0][ 0].Code = 54; d->HuffQ1[0][ 0].Length = 6;
d->HuffQ1[0][ 1].Code = 9; d->HuffQ1[0][ 1].Length = 5;
d->HuffQ1[0][ 2].Code = 32; d->HuffQ1[0][ 2].Length = 6;
d->HuffQ1[0][ 3].Code = 5; d->HuffQ1[0][ 3].Length = 5;
d->HuffQ1[0][ 4].Code = 10; d->HuffQ1[0][ 4].Length = 4;
d->HuffQ1[0][ 5].Code = 7; d->HuffQ1[0][ 5].Length = 5;
d->HuffQ1[0][ 6].Code = 52; d->HuffQ1[0][ 6].Length = 6;
d->HuffQ1[0][ 7].Code = 0; d->HuffQ1[0][ 7].Length = 5;
d->HuffQ1[0][ 8].Code = 35; d->HuffQ1[0][ 8].Length = 6;
d->HuffQ1[0][ 9].Code = 10; d->HuffQ1[0][ 9].Length = 5;
d->HuffQ1[0][10].Code = 6; d->HuffQ1[0][10].Length = 4;
d->HuffQ1[0][11].Code = 4; d->HuffQ1[0][11].Length = 5;
d->HuffQ1[0][12].Code = 11; d->HuffQ1[0][12].Length = 4;
d->HuffQ1[0][13].Code = 7; d->HuffQ1[0][13].Length = 3;
d->HuffQ1[0][14].Code = 12; d->HuffQ1[0][14].Length = 4;
d->HuffQ1[0][15].Code = 3; d->HuffQ1[0][15].Length = 5;
d->HuffQ1[0][16].Code = 7; d->HuffQ1[0][16].Length = 4;
d->HuffQ1[0][17].Code = 11; d->HuffQ1[0][17].Length = 5;
d->HuffQ1[0][18].Code = 34; d->HuffQ1[0][18].Length = 6;
d->HuffQ1[0][19].Code = 1; d->HuffQ1[0][19].Length = 5;
d->HuffQ1[0][20].Code = 53; d->HuffQ1[0][20].Length = 6;
d->HuffQ1[0][21].Code = 6; d->HuffQ1[0][21].Length = 5;
d->HuffQ1[0][22].Code = 9; d->HuffQ1[0][22].Length = 4;
d->HuffQ1[0][23].Code = 2; d->HuffQ1[0][23].Length = 5;
d->HuffQ1[0][24].Code = 33; d->HuffQ1[0][24].Length = 6;
d->HuffQ1[0][25].Code = 8; d->HuffQ1[0][25].Length = 5;
d->HuffQ1[0][26].Code = 55; d->HuffQ1[0][26].Length = 6;
//more shaped, book 1
d->HuffQ1[1][ 0].Code = 103; d->HuffQ1[1][ 0].Length = 8;
d->HuffQ1[1][ 1].Code = 62; d->HuffQ1[1][ 1].Length = 7;
d->HuffQ1[1][ 2].Code = 225; d->HuffQ1[1][ 2].Length = 9;
d->HuffQ1[1][ 3].Code = 55; d->HuffQ1[1][ 3].Length = 7;
d->HuffQ1[1][ 4].Code = 3; d->HuffQ1[1][ 4].Length = 4;
d->HuffQ1[1][ 5].Code = 52; d->HuffQ1[1][ 5].Length = 7;
d->HuffQ1[1][ 6].Code = 101; d->HuffQ1[1][ 6].Length = 8;
d->HuffQ1[1][ 7].Code = 60; d->HuffQ1[1][ 7].Length = 7;
d->HuffQ1[1][ 8].Code = 227; d->HuffQ1[1][ 8].Length = 9;
d->HuffQ1[1][ 9].Code = 24; d->HuffQ1[1][ 9].Length = 6;
d->HuffQ1[1][10].Code = 0; d->HuffQ1[1][10].Length = 4;
d->HuffQ1[1][11].Code = 61; d->HuffQ1[1][11].Length = 7;
d->HuffQ1[1][12].Code = 4; d->HuffQ1[1][12].Length = 4;
d->HuffQ1[1][13].Code = 1; d->HuffQ1[1][13].Length = 1;
d->HuffQ1[1][14].Code = 5; d->HuffQ1[1][14].Length = 4;
d->HuffQ1[1][15].Code = 63; d->HuffQ1[1][15].Length = 7;
d->HuffQ1[1][16].Code = 1; d->HuffQ1[1][16].Length = 4;
d->HuffQ1[1][17].Code = 59; d->HuffQ1[1][17].Length = 7;
d->HuffQ1[1][18].Code = 226; d->HuffQ1[1][18].Length = 9;
d->HuffQ1[1][19].Code = 57; d->HuffQ1[1][19].Length = 7;
d->HuffQ1[1][20].Code = 100; d->HuffQ1[1][20].Length = 8;
d->HuffQ1[1][21].Code = 53; d->HuffQ1[1][21].Length = 7;
d->HuffQ1[1][22].Code = 2; d->HuffQ1[1][22].Length = 4;
d->HuffQ1[1][23].Code = 54; d->HuffQ1[1][23].Length = 7;
d->HuffQ1[1][24].Code = 224; d->HuffQ1[1][24].Length = 9;
d->HuffQ1[1][25].Code = 58; d->HuffQ1[1][25].Length = 7;
d->HuffQ1[1][26].Code = 102; d->HuffQ1[1][26].Length = 8;
/********************** 5-step quantizer **************************/
/********************* 2 bundled samples **************************/
//less shaped, book 0
d->HuffQ2[0][ 0].Code = 89; d->HuffQ2[0][ 0].Length = 7;
d->HuffQ2[0][ 1].Code = 47; d->HuffQ2[0][ 1].Length = 6;
d->HuffQ2[0][ 2].Code = 15; d->HuffQ2[0][ 2].Length = 5;
d->HuffQ2[0][ 3].Code = 0; d->HuffQ2[0][ 3].Length = 5;
d->HuffQ2[0][ 4].Code = 91; d->HuffQ2[0][ 4].Length = 7;
d->HuffQ2[0][ 5].Code = 4; d->HuffQ2[0][ 5].Length = 5;
d->HuffQ2[0][ 6].Code = 6; d->HuffQ2[0][ 6].Length = 4;
d->HuffQ2[0][ 7].Code = 13; d->HuffQ2[0][ 7].Length = 4;
d->HuffQ2[0][ 8].Code = 4; d->HuffQ2[0][ 8].Length = 4;
d->HuffQ2[0][ 9].Code = 5; d->HuffQ2[0][ 9].Length = 5;
d->HuffQ2[0][10].Code = 20; d->HuffQ2[0][10].Length = 5;
d->HuffQ2[0][11].Code = 12; d->HuffQ2[0][11].Length = 4;
d->HuffQ2[0][12].Code = 4; d->HuffQ2[0][12].Length = 3;
d->HuffQ2[0][13].Code = 15; d->HuffQ2[0][13].Length = 4;
d->HuffQ2[0][14].Code = 14; d->HuffQ2[0][14].Length = 5;
d->HuffQ2[0][15].Code = 3; d->HuffQ2[0][15].Length = 5;
d->HuffQ2[0][16].Code = 3; d->HuffQ2[0][16].Length = 4;
d->HuffQ2[0][17].Code = 14; d->HuffQ2[0][17].Length = 4;
d->HuffQ2[0][18].Code = 5; d->HuffQ2[0][18].Length = 4;
d->HuffQ2[0][19].Code = 1; d->HuffQ2[0][19].Length = 5;
d->HuffQ2[0][20].Code = 90; d->HuffQ2[0][20].Length = 7;
d->HuffQ2[0][21].Code = 2; d->HuffQ2[0][21].Length = 5;
d->HuffQ2[0][22].Code = 21; d->HuffQ2[0][22].Length = 5;
d->HuffQ2[0][23].Code = 46; d->HuffQ2[0][23].Length = 6;
d->HuffQ2[0][24].Code = 88; d->HuffQ2[0][24].Length = 7;
//more shaped, book 1
d->HuffQ2[1][ 0].Code = 921; d->HuffQ2[1][ 0].Length = 10;
d->HuffQ2[1][ 1].Code = 113; d->HuffQ2[1][ 1].Length = 7;
d->HuffQ2[1][ 2].Code = 51; d->HuffQ2[1][ 2].Length = 6;
d->HuffQ2[1][ 3].Code = 231; d->HuffQ2[1][ 3].Length = 8;
d->HuffQ2[1][ 4].Code = 922; d->HuffQ2[1][ 4].Length = 10;
d->HuffQ2[1][ 5].Code = 104; d->HuffQ2[1][ 5].Length = 7;
d->HuffQ2[1][ 6].Code = 30; d->HuffQ2[1][ 6].Length = 5;
d->HuffQ2[1][ 7].Code = 0; d->HuffQ2[1][ 7].Length = 3;
d->HuffQ2[1][ 8].Code = 29; d->HuffQ2[1][ 8].Length = 5;
d->HuffQ2[1][ 9].Code = 105; d->HuffQ2[1][ 9].Length = 7;
d->HuffQ2[1][10].Code = 50; d->HuffQ2[1][10].Length = 6;
d->HuffQ2[1][11].Code = 1; d->HuffQ2[1][11].Length = 3;
d->HuffQ2[1][12].Code = 2; d->HuffQ2[1][12].Length = 2;
d->HuffQ2[1][13].Code = 3; d->HuffQ2[1][13].Length = 3;
d->HuffQ2[1][14].Code = 49; d->HuffQ2[1][14].Length = 6;
d->HuffQ2[1][15].Code = 107; d->HuffQ2[1][15].Length = 7;
d->HuffQ2[1][16].Code = 27; d->HuffQ2[1][16].Length = 5;
d->HuffQ2[1][17].Code = 2; d->HuffQ2[1][17].Length = 3;
d->HuffQ2[1][18].Code = 31; d->HuffQ2[1][18].Length = 5;
d->HuffQ2[1][19].Code = 112; d->HuffQ2[1][19].Length = 7;
d->HuffQ2[1][20].Code = 920; d->HuffQ2[1][20].Length = 10;
d->HuffQ2[1][21].Code = 106; d->HuffQ2[1][21].Length = 7;
d->HuffQ2[1][22].Code = 48; d->HuffQ2[1][22].Length = 6;
d->HuffQ2[1][23].Code = 114; d->HuffQ2[1][23].Length = 7;
d->HuffQ2[1][24].Code = 923; d->HuffQ2[1][24].Length = 10;
/********************** 7-step quantizer **************************/
/*********************** single samples ***************************/
//less shaped, book 0
d->HuffQ3[0][0].Code = 12; d->HuffQ3[0][0].Length = 4;
d->HuffQ3[0][1].Code = 4; d->HuffQ3[0][1].Length = 3;
d->HuffQ3[0][2].Code = 0; d->HuffQ3[0][2].Length = 2;
d->HuffQ3[0][3].Code = 1; d->HuffQ3[0][3].Length = 2;
d->HuffQ3[0][4].Code = 7; d->HuffQ3[0][4].Length = 3;
d->HuffQ3[0][5].Code = 5; d->HuffQ3[0][5].Length = 3;
d->HuffQ3[0][6].Code = 13; d->HuffQ3[0][6].Length = 4;
//more shaped, book 1
d->HuffQ3[1][0].Code = 4; d->HuffQ3[1][0].Length = 5;
d->HuffQ3[1][1].Code = 3; d->HuffQ3[1][1].Length = 4;
d->HuffQ3[1][2].Code = 2; d->HuffQ3[1][2].Length = 2;
d->HuffQ3[1][3].Code = 3; d->HuffQ3[1][3].Length = 2;
d->HuffQ3[1][4].Code = 1; d->HuffQ3[1][4].Length = 2;
d->HuffQ3[1][5].Code = 0; d->HuffQ3[1][5].Length = 3;
d->HuffQ3[1][6].Code = 5; d->HuffQ3[1][6].Length = 5;
/********************** 9-step quantizer **************************/
/*********************** single samples ***************************/
//less shaped, book 0
d->HuffQ4[0][0].Code = 5; d->HuffQ4[0][0].Length = 4;
d->HuffQ4[0][1].Code = 0; d->HuffQ4[0][1].Length = 3;
d->HuffQ4[0][2].Code = 4; d->HuffQ4[0][2].Length = 3;
d->HuffQ4[0][3].Code = 6; d->HuffQ4[0][3].Length = 3;
d->HuffQ4[0][4].Code = 7; d->HuffQ4[0][4].Length = 3;
d->HuffQ4[0][5].Code = 5; d->HuffQ4[0][5].Length = 3;
d->HuffQ4[0][6].Code = 3; d->HuffQ4[0][6].Length = 3;
d->HuffQ4[0][7].Code = 1; d->HuffQ4[0][7].Length = 3;
d->HuffQ4[0][8].Code = 4; d->HuffQ4[0][8].Length = 4;
//more shaped, book 1
d->HuffQ4[1][0].Code = 9; d->HuffQ4[1][0].Length = 5;
d->HuffQ4[1][1].Code = 12; d->HuffQ4[1][1].Length = 4;
d->HuffQ4[1][2].Code = 3; d->HuffQ4[1][2].Length = 3;
d->HuffQ4[1][3].Code = 0; d->HuffQ4[1][3].Length = 2;
d->HuffQ4[1][4].Code = 2; d->HuffQ4[1][4].Length = 2;
d->HuffQ4[1][5].Code = 7; d->HuffQ4[1][5].Length = 3;
d->HuffQ4[1][6].Code = 13; d->HuffQ4[1][6].Length = 4;
d->HuffQ4[1][7].Code = 5; d->HuffQ4[1][7].Length = 4;
d->HuffQ4[1][8].Code = 8; d->HuffQ4[1][8].Length = 5;
/********************* 15-step quantizer **************************/
/*********************** single samples ***************************/
//less shaped, book 0
d->HuffQ5[0][ 0].Code = 57; d->HuffQ5[0][ 0].Length = 6;
d->HuffQ5[0][ 1].Code = 23; d->HuffQ5[0][ 1].Length = 5;
d->HuffQ5[0][ 2].Code = 8; d->HuffQ5[0][ 2].Length = 4;
d->HuffQ5[0][ 3].Code = 10; d->HuffQ5[0][ 3].Length = 4;
d->HuffQ5[0][ 4].Code = 13; d->HuffQ5[0][ 4].Length = 4;
d->HuffQ5[0][ 5].Code = 0; d->HuffQ5[0][ 5].Length = 3;
d->HuffQ5[0][ 6].Code = 2; d->HuffQ5[0][ 6].Length = 3;
d->HuffQ5[0][ 7].Code = 3; d->HuffQ5[0][ 7].Length = 3;
d->HuffQ5[0][ 8].Code = 1; d->HuffQ5[0][ 8].Length = 3;
d->HuffQ5[0][ 9].Code = 15; d->HuffQ5[0][ 9].Length = 4;
d->HuffQ5[0][10].Code = 12; d->HuffQ5[0][10].Length = 4;
d->HuffQ5[0][11].Code = 9; d->HuffQ5[0][11].Length = 4;
d->HuffQ5[0][12].Code = 29; d->HuffQ5[0][12].Length = 5;
d->HuffQ5[0][13].Code = 22; d->HuffQ5[0][13].Length = 5;
d->HuffQ5[0][14].Code = 56; d->HuffQ5[0][14].Length = 6;
//more shaped, book 1
d->HuffQ5[1][ 0].Code = 229; d->HuffQ5[1][ 0].Length = 8;
d->HuffQ5[1][ 1].Code = 56; d->HuffQ5[1][ 1].Length = 6;
d->HuffQ5[1][ 2].Code = 7; d->HuffQ5[1][ 2].Length = 5;
d->HuffQ5[1][ 3].Code = 2; d->HuffQ5[1][ 3].Length = 4;
d->HuffQ5[1][ 4].Code = 0; d->HuffQ5[1][ 4].Length = 3;
d->HuffQ5[1][ 5].Code = 3; d->HuffQ5[1][ 5].Length = 3;
d->HuffQ5[1][ 6].Code = 5; d->HuffQ5[1][ 6].Length = 3;
d->HuffQ5[1][ 7].Code = 6; d->HuffQ5[1][ 7].Length = 3;
d->HuffQ5[1][ 8].Code = 4; d->HuffQ5[1][ 8].Length = 3;
d->HuffQ5[1][ 9].Code = 2; d->HuffQ5[1][ 9].Length = 3;
d->HuffQ5[1][10].Code = 15; d->HuffQ5[1][10].Length = 4;
d->HuffQ5[1][11].Code = 29; d->HuffQ5[1][11].Length = 5;
d->HuffQ5[1][12].Code = 6; d->HuffQ5[1][12].Length = 5;
d->HuffQ5[1][13].Code = 115; d->HuffQ5[1][13].Length = 7;
d->HuffQ5[1][14].Code = 228; d->HuffQ5[1][14].Length = 8;
/********************* 31-step quantizer **************************/
/*********************** single samples ***************************/
//less shaped, book 0
d->HuffQ6[0][ 0].Code = 65; d->HuffQ6[0][ 0].Length = 7;
d->HuffQ6[0][ 1].Code = 6; d->HuffQ6[0][ 1].Length = 6;
d->HuffQ6[0][ 2].Code = 44; d->HuffQ6[0][ 2].Length = 6;
d->HuffQ6[0][ 3].Code = 45; d->HuffQ6[0][ 3].Length = 6;
d->HuffQ6[0][ 4].Code = 59; d->HuffQ6[0][ 4].Length = 6;
d->HuffQ6[0][ 5].Code = 13; d->HuffQ6[0][ 5].Length = 5;
d->HuffQ6[0][ 6].Code = 17; d->HuffQ6[0][ 6].Length = 5;
d->HuffQ6[0][ 7].Code = 19; d->HuffQ6[0][ 7].Length = 5;
d->HuffQ6[0][ 8].Code = 23; d->HuffQ6[0][ 8].Length = 5;
d->HuffQ6[0][ 9].Code = 21; d->HuffQ6[0][ 9].Length = 5;
d->HuffQ6[0][10].Code = 26; d->HuffQ6[0][10].Length = 5;
d->HuffQ6[0][11].Code = 30; d->HuffQ6[0][11].Length = 5;
d->HuffQ6[0][12].Code = 0; d->HuffQ6[0][12].Length = 4;
d->HuffQ6[0][13].Code = 2; d->HuffQ6[0][13].Length = 4;
d->HuffQ6[0][14].Code = 5; d->HuffQ6[0][14].Length = 4;
d->HuffQ6[0][15].Code = 7; d->HuffQ6[0][15].Length = 4;
d->HuffQ6[0][16].Code = 3; d->HuffQ6[0][16].Length = 4;
d->HuffQ6[0][17].Code = 4; d->HuffQ6[0][17].Length = 4;
d->HuffQ6[0][18].Code = 31; d->HuffQ6[0][18].Length = 5;
d->HuffQ6[0][19].Code = 28; d->HuffQ6[0][19].Length = 5;
d->HuffQ6[0][20].Code = 25; d->HuffQ6[0][20].Length = 5;
d->HuffQ6[0][21].Code = 27; d->HuffQ6[0][21].Length = 5;
d->HuffQ6[0][22].Code = 24; d->HuffQ6[0][22].Length = 5;
d->HuffQ6[0][23].Code = 20; d->HuffQ6[0][23].Length = 5;
d->HuffQ6[0][24].Code = 18; d->HuffQ6[0][24].Length = 5;
d->HuffQ6[0][25].Code = 12; d->HuffQ6[0][25].Length = 5;
d->HuffQ6[0][26].Code = 2; d->HuffQ6[0][26].Length = 5;
d->HuffQ6[0][27].Code = 58; d->HuffQ6[0][27].Length = 6;
d->HuffQ6[0][28].Code = 33; d->HuffQ6[0][28].Length = 6;
d->HuffQ6[0][29].Code = 7; d->HuffQ6[0][29].Length = 6;
d->HuffQ6[0][30].Code = 64; d->HuffQ6[0][30].Length = 7;
//more shaped, book 1
d->HuffQ6[1][ 0].Code = 6472; d->HuffQ6[1][ 0].Length = 13;
d->HuffQ6[1][ 1].Code = 6474; d->HuffQ6[1][ 1].Length = 13;
d->HuffQ6[1][ 2].Code = 808; d->HuffQ6[1][ 2].Length = 10;
d->HuffQ6[1][ 3].Code = 405; d->HuffQ6[1][ 3].Length = 9;
d->HuffQ6[1][ 4].Code = 203; d->HuffQ6[1][ 4].Length = 8;
d->HuffQ6[1][ 5].Code = 102; d->HuffQ6[1][ 5].Length = 7;
d->HuffQ6[1][ 6].Code = 49; d->HuffQ6[1][ 6].Length = 6;
d->HuffQ6[1][ 7].Code = 9; d->HuffQ6[1][ 7].Length = 5;
d->HuffQ6[1][ 8].Code = 15; d->HuffQ6[1][ 8].Length = 5;
d->HuffQ6[1][ 9].Code = 31; d->HuffQ6[1][ 9].Length = 5;
d->HuffQ6[1][10].Code = 2; d->HuffQ6[1][10].Length = 4;
d->HuffQ6[1][11].Code = 6; d->HuffQ6[1][11].Length = 4;
d->HuffQ6[1][12].Code = 8; d->HuffQ6[1][12].Length = 4;
d->HuffQ6[1][13].Code = 11; d->HuffQ6[1][13].Length = 4;
d->HuffQ6[1][14].Code = 13; d->HuffQ6[1][14].Length = 4;
d->HuffQ6[1][15].Code = 0; d->HuffQ6[1][15].Length = 3;
d->HuffQ6[1][16].Code = 14; d->HuffQ6[1][16].Length = 4;
d->HuffQ6[1][17].Code = 10; d->HuffQ6[1][17].Length = 4;
d->HuffQ6[1][18].Code = 9; d->HuffQ6[1][18].Length = 4;
d->HuffQ6[1][19].Code = 5; d->HuffQ6[1][19].Length = 4;
d->HuffQ6[1][20].Code = 3; d->HuffQ6[1][20].Length = 4;
d->HuffQ6[1][21].Code = 30; d->HuffQ6[1][21].Length = 5;
d->HuffQ6[1][22].Code = 14; d->HuffQ6[1][22].Length = 5;
d->HuffQ6[1][23].Code = 8; d->HuffQ6[1][23].Length = 5;
d->HuffQ6[1][24].Code = 48; d->HuffQ6[1][24].Length = 6;
d->HuffQ6[1][25].Code = 103; d->HuffQ6[1][25].Length = 7;
d->HuffQ6[1][26].Code = 201; d->HuffQ6[1][26].Length = 8;
d->HuffQ6[1][27].Code = 200; d->HuffQ6[1][27].Length = 8;
d->HuffQ6[1][28].Code = 1619; d->HuffQ6[1][28].Length = 11;
d->HuffQ6[1][29].Code = 6473; d->HuffQ6[1][29].Length = 13;
d->HuffQ6[1][30].Code = 6475; d->HuffQ6[1][30].Length = 13;
/********************* 63-step quantizer **************************/
/*********************** single samples ***************************/
//less shaped, book 0
d->HuffQ7[0][ 0].Code = 103; d->HuffQ7[0][ 0].Length = 8; /* 0.003338 - 01100111 */
d->HuffQ7[0][ 1].Code = 153; d->HuffQ7[0][ 1].Length = 8; /* 0.003766 - 10011001 */
d->HuffQ7[0][ 2].Code = 181; d->HuffQ7[0][ 2].Length = 8; /* 0.004715 - 10110101 */
d->HuffQ7[0][ 3].Code = 233; d->HuffQ7[0][ 3].Length = 8; /* 0.005528 - 11101001 */
d->HuffQ7[0][ 4].Code = 64; d->HuffQ7[0][ 4].Length = 7; /* 0.006677 - 1000000 */
d->HuffQ7[0][ 5].Code = 65; d->HuffQ7[0][ 5].Length = 7; /* 0.007041 - 1000001 */
d->HuffQ7[0][ 6].Code = 77; d->HuffQ7[0][ 6].Length = 7; /* 0.007733 - 1001101 */
d->HuffQ7[0][ 7].Code = 81; d->HuffQ7[0][ 7].Length = 7; /* 0.008296 - 1010001 */
d->HuffQ7[0][ 8].Code = 91; d->HuffQ7[0][ 8].Length = 7; /* 0.009295 - 1011011 */
d->HuffQ7[0][ 9].Code = 113; d->HuffQ7[0][ 9].Length = 7; /* 0.010814 - 1110001 */
d->HuffQ7[0][10].Code = 112; d->HuffQ7[0][10].Length = 7; /* 0.010807 - 1110000 */
d->HuffQ7[0][11].Code = 24; d->HuffQ7[0][11].Length = 6; /* 0.012748 - 011000 */
d->HuffQ7[0][12].Code = 29; d->HuffQ7[0][12].Length = 6; /* 0.013390 - 011101 */
d->HuffQ7[0][13].Code = 35; d->HuffQ7[0][13].Length = 6; /* 0.014224 - 100011 */
d->HuffQ7[0][14].Code = 37; d->HuffQ7[0][14].Length = 6; /* 0.015201 - 100101 */
d->HuffQ7[0][15].Code = 41; d->HuffQ7[0][15].Length = 6; /* 0.016642 - 101001 */
d->HuffQ7[0][16].Code = 44; d->HuffQ7[0][16].Length = 6; /* 0.017292 - 101100 */
d->HuffQ7[0][17].Code = 46; d->HuffQ7[0][17].Length = 6; /* 0.018647 - 101110 */
d->HuffQ7[0][18].Code = 51; d->HuffQ7[0][18].Length = 6; /* 0.020473 - 110011 */
d->HuffQ7[0][19].Code = 49; d->HuffQ7[0][19].Length = 6; /* 0.020152 - 110001 */
d->HuffQ7[0][20].Code = 54; d->HuffQ7[0][20].Length = 6; /* 0.021315 - 110110 */
d->HuffQ7[0][21].Code = 55; d->HuffQ7[0][21].Length = 6; /* 0.021358 - 110111 */
d->HuffQ7[0][22].Code = 57; d->HuffQ7[0][22].Length = 6; /* 0.021700 - 111001 */
d->HuffQ7[0][23].Code = 60; d->HuffQ7[0][23].Length = 6; /* 0.022449 - 111100 */
d->HuffQ7[0][24].Code = 0; d->HuffQ7[0][24].Length = 5; /* 0.023063 - 00000 */
d->HuffQ7[0][25].Code = 2; d->HuffQ7[0][25].Length = 5; /* 0.023854 - 00010 */
d->HuffQ7[0][26].Code = 10; d->HuffQ7[0][26].Length = 5; /* 0.025481 - 01010 */
d->HuffQ7[0][27].Code = 5; d->HuffQ7[0][27].Length = 5; /* 0.024867 - 00101 */
d->HuffQ7[0][28].Code = 9; d->HuffQ7[0][28].Length = 5; /* 0.025352 - 01001 */
d->HuffQ7[0][29].Code = 6; d->HuffQ7[0][29].Length = 5; /* 0.025074 - 00110 */
d->HuffQ7[0][30].Code = 13; d->HuffQ7[0][30].Length = 5; /* 0.025745 - 01101 */
d->HuffQ7[0][31].Code = 7; d->HuffQ7[0][31].Length = 5; /* 0.025195 - 00111 */
d->HuffQ7[0][32].Code = 11; d->HuffQ7[0][32].Length = 5; /* 0.025502 - 01011 */
d->HuffQ7[0][33].Code = 15; d->HuffQ7[0][33].Length = 5; /* 0.026251 - 01111 */
d->HuffQ7[0][34].Code = 8; d->HuffQ7[0][34].Length = 5; /* 0.025260 - 01000 */
d->HuffQ7[0][35].Code = 4; d->HuffQ7[0][35].Length = 5; /* 0.024418 - 00100 */
d->HuffQ7[0][36].Code = 3; d->HuffQ7[0][36].Length = 5; /* 0.023983 - 00011 */
d->HuffQ7[0][37].Code = 1; d->HuffQ7[0][37].Length = 5; /* 0.023697 - 00001 */
d->HuffQ7[0][38].Code = 63; d->HuffQ7[0][38].Length = 6; /* 0.023041 - 111111 */
d->HuffQ7[0][39].Code = 62; d->HuffQ7[0][39].Length = 6; /* 0.022656 - 111110 */
d->HuffQ7[0][40].Code = 61; d->HuffQ7[0][40].Length = 6; /* 0.022549 - 111101 */
d->HuffQ7[0][41].Code = 53; d->HuffQ7[0][41].Length = 6; /* 0.021151 - 110101 */
d->HuffQ7[0][42].Code = 59; d->HuffQ7[0][42].Length = 6; /* 0.022042 - 111011 */
d->HuffQ7[0][43].Code = 52; d->HuffQ7[0][43].Length = 6; /* 0.020837 - 110100 */
d->HuffQ7[0][44].Code = 48; d->HuffQ7[0][44].Length = 6; /* 0.019446 - 110000 */
d->HuffQ7[0][45].Code = 47; d->HuffQ7[0][45].Length = 6; /* 0.019189 - 101111 */
d->HuffQ7[0][46].Code = 43; d->HuffQ7[0][46].Length = 6; /* 0.017177 - 101011 */
d->HuffQ7[0][47].Code = 42; d->HuffQ7[0][47].Length = 6; /* 0.017035 - 101010 */
d->HuffQ7[0][48].Code = 39; d->HuffQ7[0][48].Length = 6; /* 0.015287 - 100111 */
d->HuffQ7[0][49].Code = 36; d->HuffQ7[0][49].Length = 6; /* 0.014559 - 100100 */
d->HuffQ7[0][50].Code = 33; d->HuffQ7[0][50].Length = 6; /* 0.014117 - 100001 */
d->HuffQ7[0][51].Code = 28; d->HuffQ7[0][51].Length = 6; /* 0.012776 - 011100 */
d->HuffQ7[0][52].Code = 117; d->HuffQ7[0][52].Length = 7; /* 0.011107 - 1110101 */
d->HuffQ7[0][53].Code = 101; d->HuffQ7[0][53].Length = 7; /* 0.010636 - 1100101 */
d->HuffQ7[0][54].Code = 100; d->HuffQ7[0][54].Length = 7; /* 0.009751 - 1100100 */
d->HuffQ7[0][55].Code = 80; d->HuffQ7[0][55].Length = 7; /* 0.008132 - 1010000 */
d->HuffQ7[0][56].Code = 69; d->HuffQ7[0][56].Length = 7; /* 0.007091 - 1000101 */
d->HuffQ7[0][57].Code = 68; d->HuffQ7[0][57].Length = 7; /* 0.007084 - 1000100 */
d->HuffQ7[0][58].Code = 50; d->HuffQ7[0][58].Length = 7; /* 0.006277 - 0110010 */
d->HuffQ7[0][59].Code = 232; d->HuffQ7[0][59].Length = 8; /* 0.005386 - 11101000 */
d->HuffQ7[0][60].Code = 180; d->HuffQ7[0][60].Length = 8; /* 0.004408 - 10110100 */
d->HuffQ7[0][61].Code = 152; d->HuffQ7[0][61].Length = 8; /* 0.003759 - 10011000 */
d->HuffQ7[0][62].Code = 102; d->HuffQ7[0][62].Length = 8; /* 0.003160 - 01100110 */
//more shaped, book 1
d->HuffQ7[1][ 0].Code = 14244; d->HuffQ7[1][ 0].Length = 14; /* 0.000059 - 11011110100100 */
d->HuffQ7[1][ 1].Code = 14253; d->HuffQ7[1][ 1].Length = 14; /* 0.000098 - 11011110101101 */
d->HuffQ7[1][ 2].Code = 14246; d->HuffQ7[1][ 2].Length = 14; /* 0.000078 - 11011110100110 */
d->HuffQ7[1][ 3].Code = 14254; d->HuffQ7[1][ 3].Length = 14; /* 0.000111 - 11011110101110 */
d->HuffQ7[1][ 4].Code = 3562; d->HuffQ7[1][ 4].Length = 12; /* 0.000320 - 110111101010 */
d->HuffQ7[1][ 5].Code = 752; d->HuffQ7[1][ 5].Length = 10; /* 0.000920 - 1011110000 */
d->HuffQ7[1][ 6].Code = 753; d->HuffQ7[1][ 6].Length = 10; /* 0.001057 - 1011110001 */
d->HuffQ7[1][ 7].Code = 160; d->HuffQ7[1][ 7].Length = 9; /* 0.001403 - 010100000 */
d->HuffQ7[1][ 8].Code = 162; d->HuffQ7[1][ 8].Length = 9; /* 0.001579 - 010100010 */
d->HuffQ7[1][ 9].Code = 444; d->HuffQ7[1][ 9].Length = 9; /* 0.002486 - 110111100 */
d->HuffQ7[1][10].Code = 122; d->HuffQ7[1][10].Length = 8; /* 0.003772 - 01111010 */
d->HuffQ7[1][11].Code = 223; d->HuffQ7[1][11].Length = 8; /* 0.005710 - 11011111 */
d->HuffQ7[1][12].Code = 60; d->HuffQ7[1][12].Length = 7; /* 0.006858 - 0111100 */
d->HuffQ7[1][13].Code = 73; d->HuffQ7[1][13].Length = 7; /* 0.008033 - 1001001 */
d->HuffQ7[1][14].Code = 110; d->HuffQ7[1][14].Length = 7; /* 0.009827 - 1101110 */
d->HuffQ7[1][15].Code = 14; d->HuffQ7[1][15].Length = 6; /* 0.012601 - 001110 */
d->HuffQ7[1][16].Code = 24; d->HuffQ7[1][16].Length = 6; /* 0.013194 - 011000 */
d->HuffQ7[1][17].Code = 25; d->HuffQ7[1][17].Length = 6; /* 0.013938 - 011001 */
d->HuffQ7[1][18].Code = 34; d->HuffQ7[1][18].Length = 6; /* 0.015693 - 100010 */
d->HuffQ7[1][19].Code = 37; d->HuffQ7[1][19].Length = 6; /* 0.017846 - 100101 */
d->HuffQ7[1][20].Code = 54; d->HuffQ7[1][20].Length = 6; /* 0.020078 - 110110 */
d->HuffQ7[1][21].Code = 3; d->HuffQ7[1][21].Length = 5; /* 0.022975 - 00011 */
d->HuffQ7[1][22].Code = 9; d->HuffQ7[1][22].Length = 5; /* 0.025631 - 01001 */
d->HuffQ7[1][23].Code = 11; d->HuffQ7[1][23].Length = 5; /* 0.027021 - 01011 */
d->HuffQ7[1][24].Code = 16; d->HuffQ7[1][24].Length = 5; /* 0.031465 - 10000 */
d->HuffQ7[1][25].Code = 19; d->HuffQ7[1][25].Length = 5; /* 0.034244 - 10011 */
d->HuffQ7[1][26].Code = 21; d->HuffQ7[1][26].Length = 5; /* 0.035921 - 10101 */
d->HuffQ7[1][27].Code = 24; d->HuffQ7[1][27].Length = 5; /* 0.037938 - 11000 */
d->HuffQ7[1][28].Code = 26; d->HuffQ7[1][28].Length = 5; /* 0.039595 - 11010 */
d->HuffQ7[1][29].Code = 29; d->HuffQ7[1][29].Length = 5; /* 0.041546 - 11101 */
d->HuffQ7[1][30].Code = 31; d->HuffQ7[1][30].Length = 5; /* 0.042623 - 11111 */
d->HuffQ7[1][31].Code = 2; d->HuffQ7[1][31].Length = 4; /* 0.045180 - 0010 */
d->HuffQ7[1][32].Code = 0; d->HuffQ7[1][32].Length = 4; /* 0.043151 - 0000 */
d->HuffQ7[1][33].Code = 30; d->HuffQ7[1][33].Length = 5; /* 0.042538 - 11110 */
d->HuffQ7[1][34].Code = 28; d->HuffQ7[1][34].Length = 5; /* 0.041422 - 11100 */
d->HuffQ7[1][35].Code = 25; d->HuffQ7[1][35].Length = 5; /* 0.039145 - 11001 */
d->HuffQ7[1][36].Code = 22; d->HuffQ7[1][36].Length = 5; /* 0.036691 - 10110 */
d->HuffQ7[1][37].Code = 20; d->HuffQ7[1][37].Length = 5; /* 0.034955 - 10100 */
d->HuffQ7[1][38].Code = 14; d->HuffQ7[1][38].Length = 5; /* 0.029155 - 01110 */
d->HuffQ7[1][39].Code = 13; d->HuffQ7[1][39].Length = 5; /* 0.027921 - 01101 */
d->HuffQ7[1][40].Code = 8; d->HuffQ7[1][40].Length = 5; /* 0.025553 - 01000 */
d->HuffQ7[1][41].Code = 6; d->HuffQ7[1][41].Length = 5; /* 0.023093 - 00110 */
d->HuffQ7[1][42].Code = 2; d->HuffQ7[1][42].Length = 5; /* 0.021200 - 00010 */
d->HuffQ7[1][43].Code = 46; d->HuffQ7[1][43].Length = 6; /* 0.018134 - 101110 */
d->HuffQ7[1][44].Code = 35; d->HuffQ7[1][44].Length = 6; /* 0.015824 - 100011 */
d->HuffQ7[1][45].Code = 31; d->HuffQ7[1][45].Length = 6; /* 0.014701 - 011111 */
d->HuffQ7[1][46].Code = 21; d->HuffQ7[1][46].Length = 6; /* 0.013187 - 010101 */
d->HuffQ7[1][47].Code = 15; d->HuffQ7[1][47].Length = 6; /* 0.012776 - 001111 */
d->HuffQ7[1][48].Code = 95; d->HuffQ7[1][48].Length = 7; /* 0.009664 - 1011111 */
d->HuffQ7[1][49].Code = 72; d->HuffQ7[1][49].Length = 7; /* 0.007922 - 1001000 */
d->HuffQ7[1][50].Code = 41; d->HuffQ7[1][50].Length = 7; /* 0.006838 - 0101001 */
d->HuffQ7[1][51].Code = 189; d->HuffQ7[1][51].Length = 8; /* 0.005024 - 10111101 */
d->HuffQ7[1][52].Code = 123; d->HuffQ7[1][52].Length = 8; /* 0.003830 - 01111011 */
d->HuffQ7[1][53].Code = 377; d->HuffQ7[1][53].Length = 9; /* 0.002232 - 101111001 */
d->HuffQ7[1][54].Code = 161; d->HuffQ7[1][54].Length = 9; /* 0.001566 - 010100001 */
d->HuffQ7[1][55].Code = 891; d->HuffQ7[1][55].Length = 10; /* 0.001383 - 1101111011 */
d->HuffQ7[1][56].Code = 327; d->HuffQ7[1][56].Length = 10; /* 0.000900 - 0101000111 */
d->HuffQ7[1][57].Code = 326; d->HuffQ7[1][57].Length = 10; /* 0.000790 - 0101000110 */
d->HuffQ7[1][58].Code = 3560; d->HuffQ7[1][58].Length = 12; /* 0.000254 - 110111101000 */
d->HuffQ7[1][59].Code = 14255; d->HuffQ7[1][59].Length = 14; /* 0.000117 - 11011110101111 */
d->HuffQ7[1][60].Code = 14247; d->HuffQ7[1][60].Length = 14; /* 0.000085 - 11011110100111 */
d->HuffQ7[1][61].Code = 14252; d->HuffQ7[1][61].Length = 14; /* 0.000085 - 11011110101100 */
d->HuffQ7[1][62].Code = 14245; d->HuffQ7[1][62].Length = 14; /* 0.000065 - 11011110100101 */
}

83
apps/codecs/libmusepack/idtag.c Normal file
View file

@ -0,0 +1,83 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file idtag.c
/// Rudimentary id3tag handling routines, just enough to skip id3v2 tags,
/// if present.
#include "musepack.h"
#include "internal.h"
mpc_int32_t
JumpID3v2 (mpc_reader* r) {
unsigned char tmp [10];
mpc_uint32_t Unsynchronisation; // ID3v2.4-flag
mpc_uint32_t ExtHeaderPresent; // ID3v2.4-flag
mpc_uint32_t ExperimentalFlag; // ID3v2.4-flag
mpc_uint32_t FooterPresent; // ID3v2.4-flag
mpc_int32_t ret;
// seek to first byte of mpc data
if (!r->seek (r->data, 0)) {
return 0;
}
r->read(r->data, tmp, sizeof(tmp));
// check id3-tag
if ( 0 != memcmp ( tmp, "ID3", 3) )
return 0;
// read flags
Unsynchronisation = tmp[5] & 0x80;
ExtHeaderPresent = tmp[5] & 0x40;
ExperimentalFlag = tmp[5] & 0x20;
FooterPresent = tmp[5] & 0x10;
if ( tmp[5] & 0x0F )
return -1; // not (yet???) allowed
if ( (tmp[6] | tmp[7] | tmp[8] | tmp[9]) & 0x80 )
return -1; // not allowed
// read HeaderSize (syncsave: 4 * $0xxxxxxx = 28 significant bits)
ret = tmp[6] << 21;
ret += tmp[7] << 14;
ret += tmp[8] << 7;
ret += tmp[9] ;
ret += 10;
if ( FooterPresent )
ret += 10;
return ret;
}

66
apps/codecs/libmusepack/internal.h Normal file
View file

@ -0,0 +1,66 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file musepack_internal.h
/// Definitions and structures used only internally by the libmusepack.
#ifndef _musepack_internal_h
#define _musepack_internal_h
enum {
MPC_DECODER_SYNTH_DELAY = 481
};
/// Big/little endian 32 bit byte swapping routine.
static inline
mpc_uint32_t swap32(mpc_uint32_t val) {
const unsigned char* src = (const unsigned char*)&val;
return
(mpc_uint32_t)src[0] |
((mpc_uint32_t)src[1] << 8) | ((mpc_uint32_t)src[2] << 16) | ((mpc_uint32_t)src[3] << 24);
}
/// Searches for a ID3v2-tag and reads the length (in bytes) of it.
/// \param reader supplying raw stream data
/// \return size of tag, in bytes
/// \return -1 on errors of any kind
mpc_int32_t JumpID3v2(mpc_reader* fp);
/// helper functions used by multiple files
mpc_uint32_t random_int(mpc_decoder *d); // in synth_filter.c
void mpc_decoder_initialisiere_quantisierungstabellen(mpc_decoder *d, double scale_factor);
void mpc_decoder_synthese_filter_float(mpc_decoder *d, MPC_SAMPLE_FORMAT* OutData);
#endif // _musepack_internal_h

38
apps/codecs/libmusepack/mainpage.h Normal file
View file

@ -0,0 +1,38 @@
/**
\mainpage libmusepack documentation
\section whats what is libmusepack
libmusepack is a library that decodes musepack compressed audio data. Musepack
is a free, high performance, high quality lossy audio compression codec. For
more information on musepack visit http://www.musepack.net.
\section using using libmusepack
Using libmusepack is very straightforward. There are typically four things you must
do to use libmusepack in your application.
\subsection step1 step 1: implement an mpc_reader to provide raw data to the decoder library
The role of the mpc_reader is to provide raw mpc stream data to the mpc decoding library.
This data can come from a file, a network socket, or any other source you wish.
See the documentation of
\link mpc_reader_t mpc_reader \endlink
for more information.
\subsection step2 step2: read the streaminfo properties structure from the stream
This is a simple matter of calling the streaminfo_init() and streaminfo_read() functions,
supplying your mpc_reader as a source of raw data. This reads the stream properties header from the
mpc stream. This information will be used to prime the decoder for decoding in
the next step.
\subsection step3 step 3: initialize an mpc_decoder with your mpc_reader source
This is just a matter of calling the mpc_decoder_setup() and mpc_decoder_initialize()
functions with your mpc_decoder, mpc_reader data source and streaminfo information.
\subsection step4 step 4: iteratively read raw sample data from the mpc decoder
Once you've initialized the decoding library you just iteratively call the
mpc_decoder_decode routine until it indicates that the entire stream has been read.
For a simple example of all of these steps see the sample application distributed with
libmusepack in src/sample.cpp.
*/

144
apps/codecs/libmusepack/math.h Normal file
View file

@ -0,0 +1,144 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file mpc_math.h
/// Libmusepack internal math routines.
#ifndef _musepack_math_h_
#define _musepack_math_h_
#define MPC_FIXED_POINT
#define MPC_FIXED_POINT_SHIFT 16
#ifdef MPC_FIXED_POINT
#ifdef _WIN32_WCE
#include <cmnintrin.h>
#define MPC_HAVE_MULHIGH
#endif
#define MPC_FIXED_POINT_SCALE_SHIFT (MPC_FIXED_POINT_SHIFT + MPC_FIXED_POINT_FRACTPART)
#define MPC_FIXED_POINT_SCALE (1 << (MPC_FIXED_POINT_SCALE_SHIFT - 1))
//in fixedpoint mode, results in decode output buffer are in -MPC_FIXED_POINT_SCALE ... MPC_FIXED_POINT_SCALE range
#define MPC_FIXED_POINT_FRACTPART 14
typedef mpc_int32_t MPC_SAMPLE_FORMAT;
typedef mpc_int64_t MPC_SAMPLE_FORMAT_MULTIPLY;
#define MAKE_MPC_SAMPLE(X) (MPC_SAMPLE_FORMAT)((double)(X) * (double)(((mpc_int64_t)1)<<MPC_FIXED_POINT_FRACTPART))
#define MAKE_MPC_SAMPLE_EX(X,Y) (MPC_SAMPLE_FORMAT)((double)(X) * (double)(((mpc_int64_t)1)<<(Y)))
#define MPC_MULTIPLY_NOTRUNCATE(X,Y) \
(((MPC_SAMPLE_FORMAT_MULTIPLY)(X) * (MPC_SAMPLE_FORMAT_MULTIPLY)(Y)) >> MPC_FIXED_POINT_FRACTPART)
#define MPC_MULTIPLY_EX_NOTRUNCATE(X,Y,Z) \
(((MPC_SAMPLE_FORMAT_MULTIPLY)(X) * (MPC_SAMPLE_FORMAT_MULTIPLY)(Y)) >> (Z))
#ifdef _DEBUG
static inline MPC_SAMPLE_FORMAT MPC_MULTIPLY(MPC_SAMPLE_FORMAT item1,MPC_SAMPLE_FORMAT item2)
{
MPC_SAMPLE_FORMAT_MULTIPLY temp = MPC_MULTIPLY_NOTRUNCATE(item1,item2);
assert(temp == (MPC_SAMPLE_FORMAT_MULTIPLY)(MPC_SAMPLE_FORMAT)temp);
return (MPC_SAMPLE_FORMAT)temp;
}
static inline MPC_SAMPLE_FORMAT MPC_MULTIPLY_EX(MPC_SAMPLE_FORMAT item1,MPC_SAMPLE_FORMAT item2,unsigned shift)
{
MPC_SAMPLE_FORMAT_MULTIPLY temp = MPC_MULTIPLY_EX_NOTRUNCATE(item1,item2,shift);
assert(temp == (MPC_SAMPLE_FORMAT_MULTIPLY)(MPC_SAMPLE_FORMAT)temp);
return (MPC_SAMPLE_FORMAT)temp;
}
#else
#define MPC_MULTIPLY(X,Y) ((MPC_SAMPLE_FORMAT)MPC_MULTIPLY_NOTRUNCATE(X,Y))
#define MPC_MULTIPLY_EX(X,Y,Z) ((MPC_SAMPLE_FORMAT)MPC_MULTIPLY_EX_NOTRUNCATE(X,Y,Z))
#endif
#ifdef MPC_HAVE_MULHIGH
#define MPC_MULTIPLY_FRACT(X,Y) _MulHigh(X,Y)
#else
#define MPC_MULTIPLY_FRACT(X,Y) MPC_MULTIPLY_EX(X,Y,32)
#endif
#define MPC_MAKE_FRACT_CONST(X) (MPC_SAMPLE_FORMAT)((X) * (double)(((mpc_int64_t)1)<<32) )
#define MPC_MULTIPLY_FRACT_CONST(X,Y) MPC_MULTIPLY_FRACT(X,MPC_MAKE_FRACT_CONST(Y))
#define MPC_MULTIPLY_FRACT_CONST_FIX(X,Y,Z) ( MPC_MULTIPLY_FRACT(X,MPC_MAKE_FRACT_CONST( Y / (1<<(Z)) )) << (Z) )
#define MPC_MULTIPLY_FRACT_CONST_SHR(X,Y,Z) MPC_MULTIPLY_FRACT(X,MPC_MAKE_FRACT_CONST( Y / (1<<(Z)) ))
#define MPC_MULTIPLY_FLOAT_INT(X,Y) ((X)*(Y))
#define MPC_SCALE_CONST(X,Y,Z) MPC_MULTIPLY_EX(X,MAKE_MPC_SAMPLE_EX(Y,Z),(Z))
#define MPC_SCALE_CONST_SHL(X,Y,Z,S) MPC_MULTIPLY_EX(X,MAKE_MPC_SAMPLE_EX(Y,Z),(Z)-(S))
#define MPC_SCALE_CONST_SHR(X,Y,Z,S) MPC_MULTIPLY_EX(X,MAKE_MPC_SAMPLE_EX(Y,Z),(Z)+(S))
#define MPC_SHR(X,Y) ((X)>>(Y))
#define MPC_SHL(X,Y) ((X)<<(Y))
#else
//in floating-point mode, decoded samples are in -1...1 range
typedef float MPC_SAMPLE_FORMAT;
#define MAKE_MPC_SAMPLE(X) ((MPC_SAMPLE_FORMAT)(X))
#define MAKE_MPC_SAMPLE_EX(X,Y) ((MPC_SAMPLE_FORMAT)(X))
#define MPC_MULTIPLY_FRACT(X,Y) ((X)*(Y))
#define MPC_MAKE_FRACT_CONST(X) (X)
#define MPC_MULTIPLY_FRACT_CONST(X,Y) MPC_MULTPLY_FRACT(X,MPC_MAKE_FRACT_CONST(Y))
#define MPC_MULTIPLY_FRACT_CONST_SHR(X,Y,Z) MPC_MULTIPLY_FRACT(X,MPC_MAKE_FRACT_CONST( Y ))
#define MPC_MULTIPLY_FRACT_CONST_FIX(X,Y,Z) MPC_MULTIPLY_FRACT(X,MPC_MAKE_FRACT_CONST( Y ))
#define MPC_MULTIPLY_FLOAT_INT(X,Y) ((X)*(Y))
#define MPC_MULTIPLY(X,Y) ((X)*(Y))
#define MPC_MULTIPLY_EX(X,Y,Z) ((X)*(Y))
#define MPC_SCALE_CONST(X,Y,Z) ((X)*(Y))
#define MPC_SCALE_CONST_SHL(X,Y,Z,S) ((X)*(Y))
#define MPC_SCALE_CONST_SHR(X,Y,Z,S) ((X)*(Y))
#define MPC_SHR(X,Y) (X)
#define MPC_SHL(X,Y) (X)
#endif
#endif // _musepack_math_h_

1349
apps/codecs/libmusepack/mpc_decoder.c Normal file
View file

File diff suppressed because it is too large Load diff

127
apps/codecs/libmusepack/musepack.h Normal file
View file

@ -0,0 +1,127 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file musepack.h
/// Top level include file for libmusepack.
#ifndef _musepack_h_
#define _musepack_h_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdbool.h>
#include <stdlib.h>
//#include <string.h>
#include "config_types.h"
#include "decoder.h"
#include "math.h"
#include "reader.h"
#include "streaminfo.h"
enum {
MPC_FRAME_LENGTH = (36 * 32), /// samples per mpc frame
MPC_DECODER_BUFFER_LENGTH = 4 * MPC_FRAME_LENGTH /// required buffer size for decoder
};
// error codes
#define ERROR_CODE_OK 0
#define ERROR_CODE_FILE -1
#define ERROR_CODE_SV7BETA 1
#define ERROR_CODE_CBR 2
#define ERROR_CODE_IS 3
#define ERROR_CODE_BLOCKSIZE 4
#define ERROR_CODE_INVALIDSV 5
/// Initializes a streaminfo structure.
/// \param si streaminfo structure to initialize
void mpc_streaminfo_init(mpc_streaminfo *si);
/// Reads streaminfo header from the mpc stream supplied by r.
/// \param si streaminfo pointer to which info will be written
/// \param r stream reader to supply raw data
/// \return error code
mpc_int32_t mpc_streaminfo_read(mpc_streaminfo *si, mpc_reader *r);
/// Gets length of stream si, in seconds.
/// \return length of stream in seconds
double mpc_streaminfo_get_length(mpc_streaminfo *si);
/// Returns length of stream si, in samples.
/// \return length of stream in samples
mpc_int64_t mpc_streaminfo_get_length_samples(mpc_streaminfo *si);
/// Sets up decoder library.
/// Call this first when preparing to decode an mpc stream.
/// \param r reader that will supply raw data to the decoder
void mpc_decoder_setup(mpc_decoder *d, mpc_reader *r);
/// Initializes mpc decoder with the supplied stream info parameters.
/// Call this next after calling mpc_decoder_setup.
/// \param si streaminfo structure indicating format of source stream
/// \return TRUE if decoder was initalized successfully, FALSE otherwise
bool mpc_decoder_initialize(mpc_decoder *d, mpc_streaminfo *si);
/// Sets decoder sample scaling factor. All decoded samples will be multiplied
/// by this factor.
/// \param scale_factor multiplicative scaling factor
void mpc_decoder_scale_output(mpc_decoder *d, double scale_factor);
/// Actually reads data from previously initialized stream. Call
/// this iteratively to decode the mpc stream.
/// \param buffer destination buffer for decoded samples
/// \param vbr_update_acc \todo document me
/// \param vbr_update_bits \todo document me
/// \return -1 if an error is encountered
/// \return 0 if the stream has been completely decoded successfully and there are no more samples
/// \return > 0 to indicate the number of bytes that were actually read from the stream.
mpc_uint32_t mpc_decoder_decode(
mpc_decoder *d,
MPC_SAMPLE_FORMAT *buffer,
mpc_uint32_t *vbr_update_acc,
mpc_uint32_t *vbr_update_bits);
/// Seeks to the specified sample in the source stream.
bool mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample);
/// Seeks to specified position in seconds in the source stream.
bool mpc_decoder_seek_seconds(mpc_decoder *d, double seconds);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // _musepack_h_

73
apps/codecs/libmusepack/reader.h Normal file
View file

@ -0,0 +1,73 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file reader.h
#ifndef _musepack_reader_h_
#define _musepack_reader_h_
/// \brief Stream reader interface structure.
///
/// This is the structure you must supply to the musepack decoding library
/// to feed it with raw data. Implement the five member functions to provide
/// a functional reader.
typedef struct mpc_reader_t {
/// Reads size bytes of data into buffer at ptr.
mpc_int32_t (*read)(void *t, void *ptr, mpc_int32_t size);
/// Seeks to byte position offset.
bool (*seek)(void *t, mpc_int32_t offset);
/// Returns the current byte offset in the stream.
mpc_int32_t (*tell)(void *t);
/// Returns the total length of the source stream, in bytes.
mpc_int32_t (*get_size)(void *t);
/// True if the stream is a seekable stream.
bool (*canseek)(void *t);
/// Optional field that can be used to identify a particular instance of
/// reader or carry along data associated with that reader.
void *data;
} mpc_reader;
/// Initializes reader with default stdio file reader implementation. Use
/// this if you're just reading from a plain file.
///
/// \param r reader struct to initalize
/// \param input input stream to attach to the reader
// void mpc_reader_setup_file_reader(mpc_reader *r, FILE *input);
#endif // _musepack_reader_h_

152
apps/codecs/libmusepack/requant.c Normal file
View file

@ -0,0 +1,152 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file requant.c
/// Requantization function implementations.
/// \todo document me
#include "musepack.h"
#include "internal.h"
/* C O N S T A N T S */
// bits per sample for chosen quantizer
const mpc_uint32_t Res_bit [18] = {
0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
};
// coefficients for requantization
// 65536/step bzw. 65536/(2*D+1)
#define _(X) MAKE_MPC_SAMPLE_EX(X,14)
const MPC_SAMPLE_FORMAT __Cc [1 + 18] = {
_(111.285962475327f), // 32768/2/255*sqrt(3)
_(65536.000000000000f), _(21845.333333333332f), _(13107.200000000001f), _(9362.285714285713f),
_(7281.777777777777f), _(4369.066666666666f), _(2114.064516129032f), _(1040.253968253968f),
_(516.031496062992f), _(257.003921568627f), _(128.250489236790f), _(64.062561094819f),
_(32.015632633121f), _(16.003907203907f), _(8.000976681723f), _(4.000244155527f),
_(2.000061037018f), _(1.000015259021f)
};
#undef _
// offset for requantization
// 2*D+1 = steps of quantizer
const mpc_int32_t __Dc [1 + 18] = {
2,
0, 1, 2, 3, 4, 7, 15, 31, 63,
127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767
};
#ifdef MPC_FIXED_POINT
static mpc_uint32_t find_shift(double fval)
{
mpc_int64_t val = (mpc_int64_t)fval;
if (val<0) val = -val;
mpc_uint32_t ptr = 0;
while(val) {val>>=1;ptr++;}
return ptr > 31 ? 0 : 31 - ptr;
}
#endif
/* F U N C T I O N S */
#define SET_SCF(N,X) d->SCF[N] = MAKE_MPC_SAMPLE_EX(X,d->SCF_shift[N] = (unsigned char)find_shift(X));
void
mpc_decoder_scale_output(mpc_decoder *d, double factor)
{
mpc_int32_t n;
double f1;
double f2;
#ifndef MPC_FIXED_POINT
factor *= 1.0 / (double)(1<<(MPC_FIXED_POINT_SHIFT-1));
#else
factor *= 1.0 / (double)(1<<(16 - MPC_FIXED_POINT_SHIFT));
#endif
f1 = f2 = factor;
// handles +1.58...-98.41 dB, where's scf[n] / scf[n-1] = 1.20050805774840750476
SET_SCF(1,factor);
f1 *= 0.83298066476582673961;
f2 *= 1/0.83298066476582673961;
for ( n = 1; n <= 128; n++ ) {
SET_SCF((unsigned char)(1+n),f1);
SET_SCF((unsigned char)(1-n),f2);
f1 *= 0.83298066476582673961;
f2 *= 1/0.83298066476582673961;
}
}
static void
mpc_decoder_quantisierungsmodes(mpc_decoder *d) // conversion: index -> quantizer (bitstream reading)
{ // conversion: quantizer -> index (bitstream writing)
mpc_int32_t Band = 0;
mpc_int32_t i;
do {
d->Q_bit [Band] = 4;
for ( i = 0; i < 16-1; i++ )
d->Q_res [Band] [i] = i;
d->Q_res [Band][i] = 17;
Band++;
} while ( Band < 11 );
do {
d->Q_bit [Band] = 3;
for ( i = 0; i < 8-1; i++ )
d->Q_res [Band] [i] = i;
d->Q_res [Band] [i] = 17;
Band++;
} while ( Band < 23 );
do {
d->Q_bit [Band] = 2;
for ( i = 0; i < 4-1; i++ )
d->Q_res [Band] [i] = i;
d->Q_res [Band] [i] = 17;
Band++;
} while ( Band < 32 );
}
void
mpc_decoder_initialisiere_quantisierungstabellen(mpc_decoder *d, double scale_factor)
{
mpc_decoder_quantisierungsmodes(d);
mpc_decoder_scale_output(d, scale_factor);
}

51
apps/codecs/libmusepack/requant.h Normal file
View file

@ -0,0 +1,51 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file requant.h
/// Requantization function definitions.
#ifndef _musepack_requant_h
#define _musepack_requant_h_
#include "musepack.h"
/* C O N S T A N T S */
extern const mpc_uint32_t Res_bit [18]; // bits per sample for chosen quantizer
extern const MPC_SAMPLE_FORMAT __Cc [1 + 18]; // coefficients for requantization
extern const mpc_int32_t __Dc [1 + 18]; // offset for requantization
#define Cc (__Cc + 1)
#define Dc (__Dc + 1)
#endif // _musepack_requant_h_

280
apps/codecs/libmusepack/streaminfo.c Normal file
View file

@ -0,0 +1,280 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file streaminfo.c
/// Implementation of streaminfo reading functions.
#include "musepack.h"
#include "internal.h"
static const char *
Stringify(mpc_uint32_t profile) // profile is 0...15, where 7...13 is used
{
static const char na[] = "n.a.";
static const char *Names[] = {
na, "'Unstable/Experimental'", na, na,
na, "'quality 0'", "'quality 1'", "'Telephone'",
"'Thumb'", "'Radio'", "'Standard'", "'Xtreme'",
"'Insane'", "'BrainDead'", "'quality 9'", "'quality 10'"
};
return profile >= sizeof(Names) / sizeof(*Names) ? na : Names[profile];
}
void
mpc_streaminfo_init(mpc_streaminfo * si)
{
memset(si, 0, sizeof(mpc_streaminfo));
}
// read information from SV8 header
// not yet implemented
static mpc_int32_t
streaminfo_read_header_sv8(mpc_streaminfo * si, mpc_reader * fp)
{
return 0;
}
/// Reads streaminfo from SV7 header.
static mpc_int32_t
streaminfo_read_header_sv7(mpc_streaminfo * si, mpc_uint32_t HeaderData[8])
{
const mpc_int32_t samplefreqs[4] = { 44100, 48000, 37800, 32000 };
//mpc_uint32_t HeaderData [8];
mpc_uint16_t Estimatedpeak_title = 0;
if (si->stream_version > 0x71) {
// Update (si->stream_version);
return 0;
}
/*
if ( !fp->seek ( si->header_position ) ) // seek to header start
return ERROR_CODE_FILE;
if ( fp->read ( HeaderData, sizeof HeaderData) != sizeof HeaderData )
return ERROR_CODE_FILE;
*/
si->bitrate = 0;
si->frames = HeaderData[1];
si->is = 0;
si->ms = (HeaderData[2] >> 30) & 0x0001;
si->max_band = (HeaderData[2] >> 24) & 0x003F;
si->block_size = 1;
si->profile = (HeaderData[2] << 8) >> 28;
si->profile_name = Stringify(si->profile);
si->sample_freq = samplefreqs[(HeaderData[2] >> 16) & 0x0003];
Estimatedpeak_title = (mpc_uint16_t) (HeaderData[2] & 0xFFFF); // read the ReplayGain data
si->gain_title = (mpc_uint16_t) ((HeaderData[3] >> 16) & 0xFFFF);
si->peak_title = (mpc_uint16_t) (HeaderData[3] & 0xFFFF);
si->gain_album = (mpc_uint16_t) ((HeaderData[4] >> 16) & 0xFFFF);
si->peak_album = (mpc_uint16_t) (HeaderData[4] & 0xFFFF);
si->is_true_gapless = (HeaderData[5] >> 31) & 0x0001; // true gapless: used?
si->last_frame_samples = (HeaderData[5] >> 20) & 0x07FF; // true gapless: valid samples for last frame
si->encoder_version = (HeaderData[6] >> 24) & 0x00FF;
if (si->encoder_version == 0) {
//sprintf(si->encoder, "Buschmann 1.7.0...9, Klemm 0.90...1.05");
}
else {
switch (si->encoder_version % 10) {
case 0:
//sprintf(si->encoder, "Release %u.%u", si->encoder_version / 100,
// si->encoder_version / 10 % 10);
break;
case 2:
case 4:
case 6:
case 8:
//sprintf(si->encoder, "Beta %u.%02u", si->encoder_version / 100,
// si->encoder_version % 100);
break;
default:
//sprintf(si->encoder, "--Alpha-- %u.%02u",
// si->encoder_version / 100, si->encoder_version % 100);
break;
}
}
// if ( si->peak_title == 0 ) // there is no correct peak_title contained within header
// si->peak_title = (mpc_uint16_t)(Estimatedpeak_title * 1.18);
// if ( si->peak_album == 0 )
// si->peak_album = si->peak_title; // no correct peak_album, use peak_title
//si->sample_freq = 44100; // AB: used by all files up to SV7
si->channels = 2;
return ERROR_CODE_OK;
}
// read information from SV4-SV6 header
static mpc_int32_t
streaminfo_read_header_sv6(mpc_streaminfo * si, mpc_uint32_t HeaderData[8])
{
//mpc_uint32_t HeaderData [8];
/*
if ( !fp->seek ( si->header_position ) ) // seek to header start
return ERROR_CODE_FILE;
if ( fp->read ( HeaderData, sizeof HeaderData ) != sizeof HeaderData )
return ERROR_CODE_FILE;
*/
si->bitrate = (HeaderData[0] >> 23) & 0x01FF; // read the file-header (SV6 and below)
si->is = (HeaderData[0] >> 22) & 0x0001;
si->ms = (HeaderData[0] >> 21) & 0x0001;
si->stream_version = (HeaderData[0] >> 11) & 0x03FF;
si->max_band = (HeaderData[0] >> 6) & 0x001F;
si->block_size = (HeaderData[0]) & 0x003F;
si->profile = 0;
si->profile_name = Stringify((mpc_uint32_t) (-1));
if (si->stream_version >= 5)
si->frames = HeaderData[1]; // 32 bit
else
si->frames = (HeaderData[1] >> 16); // 16 bit
si->gain_title = 0; // not supported
si->peak_title = 0;
si->gain_album = 0;
si->peak_album = 0;
si->last_frame_samples = 0;
si->is_true_gapless = 0;
si->encoder_version = 0;
si->encoder[0] = '\0';
if (si->stream_version == 7)
return ERROR_CODE_SV7BETA; // are there any unsupported parameters used?
if (si->bitrate != 0)
return ERROR_CODE_CBR;
if (si->is != 0)
return ERROR_CODE_IS;
if (si->block_size != 1)
return ERROR_CODE_BLOCKSIZE;
if (si->stream_version < 6) // Bugfix: last frame was invalid for up to SV5
si->frames -= 1;
si->sample_freq = 44100; // AB: used by all files up to SV7
si->channels = 2;
if (si->stream_version < 4 || si->stream_version > 7)
return ERROR_CODE_INVALIDSV;
return ERROR_CODE_OK;
}
// reads file header and tags
mpc_int32_t
mpc_streaminfo_read(mpc_streaminfo * si, mpc_reader * r)
{
mpc_uint32_t HeaderData[8];
mpc_int32_t Error = 0;
// get header position
if ((si->header_position = JumpID3v2(r)) < 0) {
return ERROR_CODE_FILE;
}
// seek to first byte of mpc data
if (!r->seek(r->data, si->header_position)) {
return ERROR_CODE_FILE;
}
if (r->read(r->data, HeaderData, 8 * 4) != 8 * 4) {
return ERROR_CODE_FILE;
}
if (!r->seek(r->data, si->header_position + 6 * 4)) {
return ERROR_CODE_FILE;
}
si->total_file_length = r->get_size(r->data);
si->tag_offset = si->total_file_length;
if (memcmp(HeaderData, "MP+", 3) == 0) {
#ifndef MPC_LITTLE_ENDIAN
mpc_uint32_t ptr;
for (ptr = 0; ptr < 8; ptr++) {
HeaderData[ptr] = swap32(HeaderData[ptr]);
}
#endif
si->stream_version = HeaderData[0] >> 24;
// stream version 8
if ((si->stream_version & 15) >= 8) {
Error = streaminfo_read_header_sv8(si, r);
}
// stream version 7
else if ((si->stream_version & 15) == 7) {
Error = streaminfo_read_header_sv7(si, HeaderData);
}
}
else {
// stream version 4-6
Error = streaminfo_read_header_sv6(si, HeaderData);
}
// estimation, exact value needs too much time
si->pcm_samples = 1152 * si->frames - 576;
if (si->pcm_samples > 0) {
si->average_bitrate =
(si->tag_offset -
si->header_position) * 8.0 * si->sample_freq / si->pcm_samples;
}
else {
si->average_bitrate = 0;
}
return Error;
}
double
mpc_streaminfo_get_length(mpc_streaminfo * si)
{
return (double)mpc_streaminfo_get_length_samples(si) /
(double)si->sample_freq;
}
mpc_int64_t
mpc_streaminfo_get_length_samples(mpc_streaminfo * si)
{
mpc_int64_t samples = (mpc_int64_t) si->frames * MPC_FRAME_LENGTH;
if (si->is_true_gapless) {
samples -= (MPC_FRAME_LENGTH - si->last_frame_samples);
}
else {
samples -= MPC_DECODER_SYNTH_DELAY;
}
return samples;
}

86
apps/codecs/libmusepack/streaminfo.h Normal file
View file

@ -0,0 +1,86 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file streaminfo.h
#ifndef _musepack_streaminfo_h_
#define _musepack_streaminfo_h_
typedef mpc_int32_t mpc_streaminfo_off_t;
/// \brief mpc stream properties structure
///
/// Structure containing all the properties of an mpc stream. Populated
/// by the streaminfo_read function.
typedef struct mpc_streaminfo {
/// @name core mpc stream properties
//@{
mpc_uint32_t sample_freq; ///< sample frequency of stream
mpc_uint32_t channels; ///< number of channels in stream
mpc_streaminfo_off_t header_position; ///< byte offset of position of header in stream
mpc_uint32_t stream_version; ///< streamversion of stream
mpc_uint32_t bitrate; ///< bitrate of stream file (in bps)
double average_bitrate; ///< average bitrate of stream (in bits/sec)
mpc_uint32_t frames; ///< number of frames in stream
mpc_int64_t pcm_samples;
mpc_uint32_t max_band; ///< maximum band-index used in stream (0...31)
mpc_uint32_t is; ///< intensity stereo (0: off, 1: on)
mpc_uint32_t ms; ///< mid/side stereo (0: off, 1: on)
mpc_uint32_t block_size; ///< only needed for SV4...SV6 -> not supported
mpc_uint32_t profile; ///< quality profile of stream
const char* profile_name; ///< name of profile used by stream
//@}
/// @name replaygain related fields
//@{
mpc_int16_t gain_title; ///< replaygain title value
mpc_int16_t gain_album; ///< replaygain album value
mpc_uint16_t peak_album; ///< peak album loudness level
mpc_uint16_t peak_title; ///< peak title loudness level
//@}
/// @name true gapless support data
//@{
mpc_uint32_t is_true_gapless; ///< true gapless? (0: no, 1: yes)
mpc_uint32_t last_frame_samples; ///< number of valid samples within last frame
mpc_uint32_t encoder_version; ///< version of encoder used
char encoder[256]; ///< encoder name
mpc_streaminfo_off_t tag_offset; ///< offset to file tags
mpc_streaminfo_off_t total_file_length; ///< total length of underlying file
//@}
} mpc_streaminfo;
#endif // _musepack_streaminfo_h_

442
apps/codecs/libmusepack/synth_filter.c Normal file
View file

@ -0,0 +1,442 @@
/*
Copyright (c) 2005, The Musepack Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of the The Musepack Development Team nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/// \file synth_filter.c
/// Synthesis functions.
/// \todo document me
#include "musepack.h"
#include "internal.h"
typedef mpc_int32_t ptrdiff_t;
/* C O N S T A N T S */
#undef _
#define MPC_FIXED_POINT_SYNTH_FIX 2
#ifdef MPC_FIXED_POINT
#define _(value) MPC_MAKE_FRACT_CONST((double)value/(double)(0x40000))
#else
#define _(value) MAKE_MPC_SAMPLE((double)value/(double)(0x10000))
#endif
static const MPC_SAMPLE_FORMAT Di_opt [32] [16] = {
{ _( 0), _( -29), _( 213), _( -459), _( 2037), _(-5153), _( 6574), _(-37489), _(75038), _(37489), _(6574), _( 5153), _(2037), _( 459), _(213), _(29) },
{ _( -1), _( -31), _( 218), _( -519), _( 2000), _(-5517), _( 5959), _(-39336), _(74992), _(35640), _(7134), _( 4788), _(2063), _( 401), _(208), _(26) },
{ _( -1), _( -35), _( 222), _( -581), _( 1952), _(-5879), _( 5288), _(-41176), _(74856), _(33791), _(7640), _( 4425), _(2080), _( 347), _(202), _(24) },
{ _( -1), _( -38), _( 225), _( -645), _( 1893), _(-6237), _( 4561), _(-43006), _(74630), _(31947), _(8092), _( 4063), _(2087), _( 294), _(196), _(21) },
{ _( -1), _( -41), _( 227), _( -711), _( 1822), _(-6589), _( 3776), _(-44821), _(74313), _(30112), _(8492), _( 3705), _(2085), _( 244), _(190), _(19) },
{ _( -1), _( -45), _( 228), _( -779), _( 1739), _(-6935), _( 2935), _(-46617), _(73908), _(28289), _(8840), _( 3351), _(2075), _( 197), _(183), _(17) },
{ _( -1), _( -49), _( 228), _( -848), _( 1644), _(-7271), _( 2037), _(-48390), _(73415), _(26482), _(9139), _( 3004), _(2057), _( 153), _(176), _(16) },
{ _( -2), _( -53), _( 227), _( -919), _( 1535), _(-7597), _( 1082), _(-50137), _(72835), _(24694), _(9389), _( 2663), _(2032), _( 111), _(169), _(14) },
{ _( -2), _( -58), _( 224), _( -991), _( 1414), _(-7910), _( 70), _(-51853), _(72169), _(22929), _(9592), _( 2330), _(2001), _( 72), _(161), _(13) },
{ _( -2), _( -63), _( 221), _(-1064), _( 1280), _(-8209), _( -998), _(-53534), _(71420), _(21189), _(9750), _( 2006), _(1962), _( 36), _(154), _(11) },
{ _( -2), _( -68), _( 215), _(-1137), _( 1131), _(-8491), _( -2122), _(-55178), _(70590), _(19478), _(9863), _( 1692), _(1919), _( 2), _(147), _(10) },
{ _( -3), _( -73), _( 208), _(-1210), _( 970), _(-8755), _( -3300), _(-56778), _(69679), _(17799), _(9935), _( 1388), _(1870), _( -29), _(139), _( 9) },
{ _( -3), _( -79), _( 200), _(-1283), _( 794), _(-8998), _( -4533), _(-58333), _(68692), _(16155), _(9966), _( 1095), _(1817), _( -57), _(132), _( 8) },
{ _( -4), _( -85), _( 189), _(-1356), _( 605), _(-9219), _( -5818), _(-59838), _(67629), _(14548), _(9959), _( 814), _(1759), _( -83), _(125), _( 7) },
{ _( -4), _( -91), _( 177), _(-1428), _( 402), _(-9416), _( -7154), _(-61289), _(66494), _(12980), _(9916), _( 545), _(1698), _(-106), _(117), _( 7) },
{ _( -5), _( -97), _( 163), _(-1498), _( 185), _(-9585), _( -8540), _(-62684), _(65290), _(11455), _(9838), _( 288), _(1634), _(-127), _(111), _( 6) },
{ _( -5), _(-104), _( 146), _(-1567), _( -45), _(-9727), _( -9975), _(-64019), _(64019), _( 9975), _(9727), _( 45), _(1567), _(-146), _(104), _( 5) },
{ _( -6), _(-111), _( 127), _(-1634), _( -288), _(-9838), _(-11455), _(-65290), _(62684), _( 8540), _(9585), _( -185), _(1498), _(-163), _( 97), _( 5) },
{ _( -7), _(-117), _( 106), _(-1698), _( -545), _(-9916), _(-12980), _(-66494), _(61289), _( 7154), _(9416), _( -402), _(1428), _(-177), _( 91), _( 4) },
{ _( -7), _(-125), _( 83), _(-1759), _( -814), _(-9959), _(-14548), _(-67629), _(59838), _( 5818), _(9219), _( -605), _(1356), _(-189), _( 85), _( 4) },
{ _( -8), _(-132), _( 57), _(-1817), _(-1095), _(-9966), _(-16155), _(-68692), _(58333), _( 4533), _(8998), _( -794), _(1283), _(-200), _( 79), _( 3) },
{ _( -9), _(-139), _( 29), _(-1870), _(-1388), _(-9935), _(-17799), _(-69679), _(56778), _( 3300), _(8755), _( -970), _(1210), _(-208), _( 73), _( 3) },
{ _(-10), _(-147), _( -2), _(-1919), _(-1692), _(-9863), _(-19478), _(-70590), _(55178), _( 2122), _(8491), _(-1131), _(1137), _(-215), _( 68), _( 2) },
{ _(-11), _(-154), _( -36), _(-1962), _(-2006), _(-9750), _(-21189), _(-71420), _(53534), _( 998), _(8209), _(-1280), _(1064), _(-221), _( 63), _( 2) },
{ _(-13), _(-161), _( -72), _(-2001), _(-2330), _(-9592), _(-22929), _(-72169), _(51853), _( -70), _(7910), _(-1414), _( 991), _(-224), _( 58), _( 2) },
{ _(-14), _(-169), _(-111), _(-2032), _(-2663), _(-9389), _(-24694), _(-72835), _(50137), _(-1082), _(7597), _(-1535), _( 919), _(-227), _( 53), _( 2) },
{ _(-16), _(-176), _(-153), _(-2057), _(-3004), _(-9139), _(-26482), _(-73415), _(48390), _(-2037), _(7271), _(-1644), _( 848), _(-228), _( 49), _( 1) },
{ _(-17), _(-183), _(-197), _(-2075), _(-3351), _(-8840), _(-28289), _(-73908), _(46617), _(-2935), _(6935), _(-1739), _( 779), _(-228), _( 45), _( 1) },
{ _(-19), _(-190), _(-244), _(-2085), _(-3705), _(-8492), _(-30112), _(-74313), _(44821), _(-3776), _(6589), _(-1822), _( 711), _(-227), _( 41), _( 1) },
{ _(-21), _(-196), _(-294), _(-2087), _(-4063), _(-8092), _(-31947), _(-74630), _(43006), _(-4561), _(6237), _(-1893), _( 645), _(-225), _( 38), _( 1) },
{ _(-24), _(-202), _(-347), _(-2080), _(-4425), _(-7640), _(-33791), _(-74856), _(41176), _(-5288), _(5879), _(-1952), _( 581), _(-222), _( 35), _( 1) },
{ _(-26), _(-208), _(-401), _(-2063), _(-4788), _(-7134), _(-35640), _(-74992), _(39336), _(-5959), _(5517), _(-2000), _( 519), _(-218), _( 31), _( 1) }
};
#undef _
static void Calculate_New_V ( const MPC_SAMPLE_FORMAT * Sample, MPC_SAMPLE_FORMAT * V )
{
// Calculating new V-buffer values for left channel
// calculate new V-values (ISO-11172-3, p. 39)
// based upon fast-MDCT algorithm by Byeong Gi Lee
/*static*/ MPC_SAMPLE_FORMAT A00, A01, A02, A03, A04, A05, A06, A07, A08, A09, A10, A11, A12, A13, A14, A15;
/*static*/ MPC_SAMPLE_FORMAT B00, B01, B02, B03, B04, B05, B06, B07, B08, B09, B10, B11, B12, B13, B14, B15;
MPC_SAMPLE_FORMAT tmp;
A00 = Sample[ 0] + Sample[31];
A01 = Sample[ 1] + Sample[30];
A02 = Sample[ 2] + Sample[29];
A03 = Sample[ 3] + Sample[28];
A04 = Sample[ 4] + Sample[27];
A05 = Sample[ 5] + Sample[26];
A06 = Sample[ 6] + Sample[25];
A07 = Sample[ 7] + Sample[24];
A08 = Sample[ 8] + Sample[23];
A09 = Sample[ 9] + Sample[22];
A10 = Sample[10] + Sample[21];
A11 = Sample[11] + Sample[20];
A12 = Sample[12] + Sample[19];
A13 = Sample[13] + Sample[18];
A14 = Sample[14] + Sample[17];
A15 = Sample[15] + Sample[16];
B00 = A00 + A15;
B01 = A01 + A14;
B02 = A02 + A13;
B03 = A03 + A12;
B04 = A04 + A11;
B05 = A05 + A10;
B06 = A06 + A09;
B07 = A07 + A08;;
B08 = MPC_SCALE_CONST((A00 - A15) , 0.5024192929f , 31);
B09 = MPC_SCALE_CONST((A01 - A14) , 0.5224986076f , 31);
B10 = MPC_SCALE_CONST((A02 - A13) , 0.5669440627f , 31);
B11 = MPC_SCALE_CONST((A03 - A12) , 0.6468217969f , 31);
B12 = MPC_SCALE_CONST((A04 - A11) , 0.7881546021f , 31);
B13 = MPC_SCALE_CONST((A05 - A10) , 1.0606776476f , 30);
B14 = MPC_SCALE_CONST((A06 - A09) , 1.7224471569f , 30);
B15 = MPC_SCALE_CONST((A07 - A08) , 5.1011486053f , 28);
A00 = B00 + B07;
A01 = B01 + B06;
A02 = B02 + B05;
A03 = B03 + B04;
A04 = MPC_SCALE_CONST((B00 - B07) , 0.5097956061f , 31);
A05 = MPC_SCALE_CONST((B01 - B06) , 0.6013448834f , 31);
A06 = MPC_SCALE_CONST((B02 - B05) , 0.8999761939f , 31);
A07 = MPC_SCALE_CONST((B03 - B04) , 2.5629155636f , 29);
A08 = B08 + B15;
A09 = B09 + B14;
A10 = B10 + B13;
A11 = B11 + B12;
A12 = MPC_SCALE_CONST((B08 - B15) , 0.5097956061f , 31);
A13 = MPC_SCALE_CONST((B09 - B14) , 0.6013448834f , 31);
A14 = MPC_SCALE_CONST((B10 - B13) , 0.8999761939f , 31);
A15 = MPC_SCALE_CONST((B11 - B12) , 2.5629155636f , 29);
B00 = A00 + A03;
B01 = A01 + A02;
B02 = MPC_MULTIPLY_FRACT_CONST_FIX((A00 - A03) , 0.5411961079f , 1);
B03 = MPC_MULTIPLY_FRACT_CONST_FIX((A01 - A02) , 1.3065630198f , 2);
B04 = A04 + A07;
B05 = A05 + A06;
B06 = MPC_MULTIPLY_FRACT_CONST_FIX((A04 - A07) , 0.5411961079f , 1);
B07 = MPC_MULTIPLY_FRACT_CONST_FIX((A05 - A06) , 1.3065630198f , 2);
B08 = A08 + A11;
B09 = A09 + A10;
B10 = MPC_MULTIPLY_FRACT_CONST_FIX((A08 - A11) , 0.5411961079f , 1);
B11 = MPC_MULTIPLY_FRACT_CONST_FIX((A09 - A10) , 1.3065630198f , 2);
B12 = A12 + A15;
B13 = A13 + A14;
B14 = MPC_MULTIPLY_FRACT_CONST_FIX((A12 - A15) , 0.5411961079f , 1);
B15 = MPC_MULTIPLY_FRACT_CONST_FIX((A13 - A14) , 1.3065630198f , 2);
A00 = B00 + B01;
A01 = MPC_MULTIPLY_FRACT_CONST_FIX((B00 - B01) , 0.7071067691f , 1);
A02 = B02 + B03;
A03 = MPC_MULTIPLY_FRACT_CONST_FIX((B02 - B03) , 0.7071067691f , 1);
A04 = B04 + B05;
A05 = MPC_MULTIPLY_FRACT_CONST_FIX((B04 - B05) , 0.7071067691f , 1);
A06 = B06 + B07;
A07 = MPC_MULTIPLY_FRACT_CONST_FIX((B06 - B07) , 0.7071067691f , 1);
A08 = B08 + B09;
A09 = MPC_MULTIPLY_FRACT_CONST_FIX((B08 - B09) , 0.7071067691f , 1);
A10 = B10 + B11;
A11 = MPC_MULTIPLY_FRACT_CONST_FIX((B10 - B11) , 0.7071067691f , 1);
A12 = B12 + B13;
A13 = MPC_MULTIPLY_FRACT_CONST_FIX((B12 - B13) , 0.7071067691f , 1);
A14 = B14 + B15;
A15 = MPC_MULTIPLY_FRACT_CONST_FIX((B14 - B15) , 0.7071067691f , 1);
V[48] = -A00;
V[ 0] = A01;
V[40] = -A02 - (V[ 8] = A03);
V[36] = -((V[ 4] = A05 + (V[12] = A07)) + A06);
V[44] = - A04 - A06 - A07;
V[ 6] = (V[10] = A11 + (V[14] = A15)) + A13;
V[38] = (V[34] = -(V[ 2] = A09 + A13 + A15) - A14) + A09 - A10 - A11;
V[46] = (tmp = -(A12 + A14 + A15)) - A08;
V[42] = tmp - A10 - A11;
A00 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 0] - Sample[31]) , 0.5006030202f , MPC_FIXED_POINT_SYNTH_FIX);
A01 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 1] - Sample[30]) , 0.5054709315f , MPC_FIXED_POINT_SYNTH_FIX);
A02 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 2] - Sample[29]) , 0.5154473186f , MPC_FIXED_POINT_SYNTH_FIX);
A03 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 3] - Sample[28]) , 0.5310425758f , MPC_FIXED_POINT_SYNTH_FIX);
A04 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 4] - Sample[27]) , 0.5531039238f , MPC_FIXED_POINT_SYNTH_FIX);
A05 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 5] - Sample[26]) , 0.5829349756f , MPC_FIXED_POINT_SYNTH_FIX);
A06 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 6] - Sample[25]) , 0.6225041151f , MPC_FIXED_POINT_SYNTH_FIX);
A07 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 7] - Sample[24]) , 0.6748083234f , MPC_FIXED_POINT_SYNTH_FIX);
A08 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 8] - Sample[23]) , 0.7445362806f , MPC_FIXED_POINT_SYNTH_FIX);
A09 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 9] - Sample[22]) , 0.8393496275f , MPC_FIXED_POINT_SYNTH_FIX);
A10 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[10] - Sample[21]) , 0.9725682139f , MPC_FIXED_POINT_SYNTH_FIX);
#if MPC_FIXED_POINT_SYNTH_FIX>=2
A11 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[11] - Sample[20]) , 1.1694399118f , MPC_FIXED_POINT_SYNTH_FIX);
A12 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[12] - Sample[19]) , 1.4841645956f , MPC_FIXED_POINT_SYNTH_FIX);
#else
A11 = MPC_SCALE_CONST_SHR ((Sample[11] - Sample[20]) , 1.1694399118f , 30, MPC_FIXED_POINT_SYNTH_FIX);
A12 = MPC_SCALE_CONST_SHR ((Sample[12] - Sample[19]) , 1.4841645956f , 30, MPC_FIXED_POINT_SYNTH_FIX);
#endif
A13 = MPC_SCALE_CONST_SHR ((Sample[13] - Sample[18]) , 2.0577809811f , 29, MPC_FIXED_POINT_SYNTH_FIX);
A14 = MPC_SCALE_CONST_SHR ((Sample[14] - Sample[17]) , 3.4076085091f , 29, MPC_FIXED_POINT_SYNTH_FIX);
A15 = MPC_SCALE_CONST_SHR ((Sample[15] - Sample[16]) , 10.1900081635f, 27 ,MPC_FIXED_POINT_SYNTH_FIX);
B00 = A00 + A15;
B01 = A01 + A14;
B02 = A02 + A13;
B03 = A03 + A12;
B04 = A04 + A11;
B05 = A05 + A10;
B06 = A06 + A09;
B07 = A07 + A08;
B08 = MPC_SCALE_CONST((A00 - A15) , 0.5024192929f , 31);
B09 = MPC_SCALE_CONST((A01 - A14) , 0.5224986076f , 31);
B10 = MPC_SCALE_CONST((A02 - A13) , 0.5669440627f , 31);
B11 = MPC_SCALE_CONST((A03 - A12) , 0.6468217969f , 31);
B12 = MPC_SCALE_CONST((A04 - A11) , 0.7881546021f , 31);
B13 = MPC_SCALE_CONST((A05 - A10) , 1.0606776476f , 30);
B14 = MPC_SCALE_CONST((A06 - A09) , 1.7224471569f , 30);
B15 = MPC_SCALE_CONST((A07 - A08) , 5.1011486053f , 28);
A00 = B00 + B07;
A01 = B01 + B06;
A02 = B02 + B05;
A03 = B03 + B04;
A04 = MPC_SCALE_CONST((B00 - B07) , 0.5097956061f , 31);
A05 = MPC_SCALE_CONST((B01 - B06) , 0.6013448834f , 31);
A06 = MPC_SCALE_CONST((B02 - B05) , 0.8999761939f , 31);
A07 = MPC_SCALE_CONST((B03 - B04) , 2.5629155636f , 29);
A08 = B08 + B15;
A09 = B09 + B14;
A10 = B10 + B13;
A11 = B11 + B12;
A12 = MPC_SCALE_CONST((B08 - B15) , 0.5097956061f , 31);
A13 = MPC_SCALE_CONST((B09 - B14) , 0.6013448834f , 31);
A14 = MPC_SCALE_CONST((B10 - B13) , 0.8999761939f , 31);
A15 = MPC_SCALE_CONST((B11 - B12) , 2.5629155636f , 29);
B00 = A00 + A03;
B01 = A01 + A02;
B02 = MPC_SCALE_CONST((A00 - A03) , 0.5411961079f , 31);
B03 = MPC_SCALE_CONST((A01 - A02) , 1.3065630198f , 30);
B04 = A04 + A07;
B05 = A05 + A06;
B06 = MPC_SCALE_CONST((A04 - A07) , 0.5411961079f , 31);
B07 = MPC_SCALE_CONST((A05 - A06) , 1.3065630198f , 30);
B08 = A08 + A11;
B09 = A09 + A10;
B10 = MPC_SCALE_CONST((A08 - A11) , 0.5411961079f , 31);
B11 = MPC_SCALE_CONST((A09 - A10) , 1.3065630198f , 30);
B12 = A12 + A15;
B13 = A13 + A14;
B14 = MPC_SCALE_CONST((A12 - A15) , 0.5411961079f , 31);
B15 = MPC_SCALE_CONST((A13 - A14) , 1.3065630198f , 30);
A00 = MPC_SHL(B00 + B01, MPC_FIXED_POINT_SYNTH_FIX);
A01 = MPC_SCALE_CONST_SHL((B00 - B01) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
A02 = MPC_SHL(B02 + B03, MPC_FIXED_POINT_SYNTH_FIX);
A03 = MPC_SCALE_CONST_SHL((B02 - B03) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
A04 = MPC_SHL(B04 + B05, MPC_FIXED_POINT_SYNTH_FIX);
A05 = MPC_SCALE_CONST_SHL((B04 - B05) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
A06 = MPC_SHL(B06 + B07, MPC_FIXED_POINT_SYNTH_FIX);
A07 = MPC_SCALE_CONST_SHL((B06 - B07) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
A08 = MPC_SHL(B08 + B09, MPC_FIXED_POINT_SYNTH_FIX);
A09 = MPC_SCALE_CONST_SHL((B08 - B09) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
A10 = MPC_SHL(B10 + B11, MPC_FIXED_POINT_SYNTH_FIX);
A11 = MPC_SCALE_CONST_SHL((B10 - B11) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
A12 = MPC_SHL(B12 + B13, MPC_FIXED_POINT_SYNTH_FIX);
A13 = MPC_SCALE_CONST_SHL((B12 - B13) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
A14 = MPC_SHL(B14 + B15, MPC_FIXED_POINT_SYNTH_FIX);
A15 = MPC_SCALE_CONST_SHL((B14 - B15) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
// mehrfach verwendete Ausdrücke: A04+A06+A07, A09+A13+A15
V[ 5] = (V[11] = (V[13] = A07 + (V[15] = A15)) + A11) + A05 + A13;
V[ 7] = (V[ 9] = A03 + A11 + A15) + A13;
V[33] = -(V[ 1] = A01 + A09 + A13 + A15) - A14;
V[35] = -(V[ 3] = A05 + A07 + A09 + A13 + A15) - A06 - A14;
V[37] = (tmp = -(A10 + A11 + A13 + A14 + A15)) - A05 - A06 - A07;
V[39] = tmp - A02 - A03; // abhängig vom Befehl drüber
V[41] = (tmp += A13 - A12) - A02 - A03; // abhängig vom Befehl 2 drüber
V[43] = tmp - A04 - A06 - A07; // abhängig von Befehlen 1 und 3 drüber
V[47] = (tmp = -(A08 + A12 + A14 + A15)) - A00;
V[45] = tmp - A04 - A06 - A07; // abhängig vom Befehl drüber
V[32] = -V[ 0];
V[31] = -V[ 1];
V[30] = -V[ 2];
V[29] = -V[ 3];
V[28] = -V[ 4];
V[27] = -V[ 5];
V[26] = -V[ 6];
V[25] = -V[ 7];
V[24] = -V[ 8];
V[23] = -V[ 9];
V[22] = -V[10];
V[21] = -V[11];
V[20] = -V[12];
V[19] = -V[13];
V[18] = -V[14];
V[17] = -V[15];
V[63] = V[33];
V[62] = V[34];
V[61] = V[35];
V[60] = V[36];
V[59] = V[37];
V[58] = V[38];
V[57] = V[39];
V[56] = V[40];
V[55] = V[41];
V[54] = V[42];
V[53] = V[43];
V[52] = V[44];
V[51] = V[45];
V[50] = V[46];
V[49] = V[47];
}
static void Synthese_Filter_float_internal(MPC_SAMPLE_FORMAT * OutData,MPC_SAMPLE_FORMAT * V,const MPC_SAMPLE_FORMAT * Y)
{
mpc_uint32_t n;
for ( n = 0; n < 36; n++, Y += 32 ) {
V -= 64;
Calculate_New_V ( Y, V );
{
MPC_SAMPLE_FORMAT * Data = OutData;
const MPC_SAMPLE_FORMAT * D = (const MPC_SAMPLE_FORMAT *) &Di_opt;
mpc_int32_t k;
//mpc_int32_t tmp;
for ( k = 0; k < 32; k++, D += 16, V++ ) {
*Data = MPC_SHL(
MPC_MULTIPLY_FRACT(V[ 0],D[ 0]) + MPC_MULTIPLY_FRACT(V[ 96],D[ 1]) + MPC_MULTIPLY_FRACT(V[128],D[ 2]) + MPC_MULTIPLY_FRACT(V[224],D[ 3])
+ MPC_MULTIPLY_FRACT(V[256],D[ 4]) + MPC_MULTIPLY_FRACT(V[352],D[ 5]) + MPC_MULTIPLY_FRACT(V[384],D[ 6]) + MPC_MULTIPLY_FRACT(V[480],D[ 7])
+ MPC_MULTIPLY_FRACT(V[512],D[ 8]) + MPC_MULTIPLY_FRACT(V[608],D[ 9]) + MPC_MULTIPLY_FRACT(V[640],D[10]) + MPC_MULTIPLY_FRACT(V[736],D[11])
+ MPC_MULTIPLY_FRACT(V[768],D[12]) + MPC_MULTIPLY_FRACT(V[864],D[13]) + MPC_MULTIPLY_FRACT(V[896],D[14]) + MPC_MULTIPLY_FRACT(V[992],D[15])
, 2);
Data += 2;
}
V -= 32;//bleh
OutData+=64;
}
}
}
void
mpc_decoder_synthese_filter_float(mpc_decoder *d, MPC_SAMPLE_FORMAT* OutData)
{
/********* left channel ********/
memmove(d->V_L + MPC_V_MEM, d->V_L, 960 * sizeof(MPC_SAMPLE_FORMAT) );
Synthese_Filter_float_internal(
OutData,
(MPC_SAMPLE_FORMAT *)(d->V_L + MPC_V_MEM),
(MPC_SAMPLE_FORMAT *)(d->Y_L [0]));
/******** right channel ********/
memmove(d->V_R + MPC_V_MEM, d->V_R, 960 * sizeof(MPC_SAMPLE_FORMAT) );
Synthese_Filter_float_internal(
OutData + 1,
(MPC_SAMPLE_FORMAT *)(d->V_R + MPC_V_MEM),
(MPC_SAMPLE_FORMAT *)(d->Y_R [0]));
}
/*******************************************/
/* */
/* dithered synthesis */
/* */
/*******************************************/
static const unsigned char Parity [256] = { // parity
0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0
};
/*
* This is a simple random number generator with good quality for audio purposes.
* It consists of two polycounters with opposite rotation direction and different
* periods. The periods are coprime, so the total period is the product of both.
*
* -------------------------------------------------------------------------------------------------
* +-> |31:30:29:28:27:26:25:24:23:22:21:20:19:18:17:16:15:14:13:12:11:10: 9: 8: 7: 6: 5: 4: 3: 2: 1: 0|
* | -------------------------------------------------------------------------------------------------
* | | | | | | |
* | +--+--+--+-XOR-+--------+
* | |
* +--------------------------------------------------------------------------------------+
*
* -------------------------------------------------------------------------------------------------
* |31:30:29:28:27:26:25:24:23:22:21:20:19:18:17:16:15:14:13:12:11:10: 9: 8: 7: 6: 5: 4: 3: 2: 1: 0| <-+
* ------------------------------------------------------------------------------------------------- |
* | | | | |
* +--+----XOR----+--+ |
* | |
* +----------------------------------------------------------------------------------------+
*
*
* The first has an period of 3*5*17*257*65537, the second of 7*47*73*178481,
* which gives a period of 18.410.713.077.675.721.215. The result is the
* XORed values of both generators.
*/
mpc_uint32_t
random_int(mpc_decoder *d)
{
#if 1
mpc_uint32_t t1, t2, t3, t4;
t3 = t1 = d->__r1; t4 = t2 = d->__r2; // Parity calculation is done via table lookup, this is also available
t1 &= 0xF5; t2 >>= 25; // on CPUs without parity, can be implemented in C and avoid unpredictable
t1 = Parity [t1]; t2 &= 0x63; // jumps and slow rotate through the carry flag operations.
t1 <<= 31; t2 = Parity [t2];
return (d->__r1 = (t3 >> 1) | t1 ) ^ (d->__r2 = (t4 + t4) | t2 );
#else
return (d->__r1 = (d->__r1 >> 1) | ((mpc_uint32_t)Parity [d->__r1 & 0xF5] << 31) ) ^
(d->__r2 = (d->__r2 << 1) | (mpc_uint32_t)Parity [(d->__r2 >> 25) & 0x63] );
#endif
}

2
apps/plugins/Makefile
View file

@ -17,7 +17,7 @@ ifdef APPEXTRA
endif endif
ifdef SOFTWARECODECS ifdef SOFTWARECODECS
CODECLIBS = -lmad -la52 -lFLAC -lTremor -lwavpack CODECLIBS = -lmad -la52 -lFLAC -lTremor -lwavpack -lmusepack
endif endif
LDS := plugin.lds LDS := plugin.lds

1
apps/plugins/SOURCES
View file

@ -73,5 +73,6 @@ a52towav.c
flac2wav.c flac2wav.c
vorbis2wav.c vorbis2wav.c
wv2wav.c wv2wav.c
mpc2wav.c
iriverify.c iriverify.c
#endif #endif

208
apps/plugins/mpc2wav.c Normal file
View file

@ -0,0 +1,208 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2005 Thom Johansen
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
/* This is a lovely mishmash of sample.c from libmusepack and mpa2wav.c,
* but happens to work, so no whining!
*/
#include "plugin.h"
#if (CONFIG_HWCODEC == MASNONE)
/* software codec platforms */
#include <codecs/libmusepack/musepack.h>
#include "lib/xxx2wav.h" /* Helper functions common to test decoders */
static struct plugin_api* rb;
mpc_decoder decoder;
/*
Our implementations of the mpc_reader callback functions.
*/
mpc_int32_t
read_impl(void *data, void *ptr, mpc_int32_t size)
{
file_info_struct *f = (file_info_struct *)data;
mpc_int32_t num = f->filesize - f->curpos;
if (num > size)
num = size;
rb->memcpy(ptr, filebuf + f->curpos, num);
f->curpos += num;
return num;
}
bool
seek_impl(void *data, mpc_int32_t offset)
{
file_info_struct *f = (file_info_struct *)data;
if (offset > f->filesize) {
return 0;
} else {
f->curpos = offset;
return 1;
}
}
mpc_int32_t
tell_impl(void *data)
{
file_info_struct *f = (file_info_struct *)data;
return f->curpos;
}
mpc_int32_t
get_size_impl(void *data)
{
file_info_struct *f = (file_info_struct *)data;
return f->filesize;
}
bool
canseek_impl(void *data)
{
file_info_struct *f = (file_info_struct *)data;
return true;
}
static int
shift_signed(MPC_SAMPLE_FORMAT val, int shift)
{
if (shift > 0)
val <<= shift;
else if (shift < 0)
val >>= -shift;
return (int)val;
}
#define OUTPUT_BUFFER_SIZE 65536 /* Must be an integer multiple of 4. */
unsigned char OutputBuffer[OUTPUT_BUFFER_SIZE];
MPC_SAMPLE_FORMAT sample_buffer[MPC_DECODER_BUFFER_LENGTH];
unsigned char *OutputPtr=OutputBuffer;
const unsigned char *OutputBufferEnd=OutputBuffer+OUTPUT_BUFFER_SIZE;
#ifdef USE_IRAM
extern char iramcopy[];
extern char iramstart[];
extern char iramend[];
#endif
/* this is the plugin entry point */
enum plugin_status plugin_start(struct plugin_api* api, void* file)
{
file_info_struct file_info;
unsigned short Sample;
unsigned status = 1;
int i;
mpc_reader reader;
/* Generic plugin inititialisation */
TEST_PLUGIN_API(api);
rb = api;
#ifdef USE_IRAM
rb->memcpy(iramstart, iramcopy, iramend-iramstart);
#endif
reader.read = read_impl;
reader.seek = seek_impl;
reader.tell = tell_impl;
reader.get_size = get_size_impl;
reader.canseek = canseek_impl;
reader.data = &file_info;
/* This function sets up the buffers and reads the file into RAM */
if (local_init(file, "/libmusepacktest.wav", &file_info, api)) {
return PLUGIN_ERROR;
}
/* read file's streaminfo data */
mpc_streaminfo info;
mpc_streaminfo_init(&info);
if (mpc_streaminfo_read(&info, &reader) != ERROR_CODE_OK) {
rb->splash(HZ, true, "Not an MPC file.");
return PLUGIN_ERROR;
}
file_info.samplerate=info.sample_freq;
/* instantiate a decoder with our file reader */
mpc_decoder_setup(&decoder, &reader);
if (!mpc_decoder_initialize(&decoder, &info)) {
rb->splash(HZ, true, "Error in init.");
return PLUGIN_ERROR;
}
file_info.frames_decoded = 0;
file_info.start_tick = *(rb->current_tick);
rb->button_clear_queue();
/* This is the decoding loop. */
while (status != 0) {
status = mpc_decoder_decode(&decoder, sample_buffer, 0, 0);
if (status == (unsigned)(-1)) {
//decode error
rb->splash(HZ, true, "Error decoding file.");
break;
}
else //status>0
{
file_info.current_sample += status;
file_info.frames_decoded++;
/* Convert musepack's numbers to an array of 16-bit LE signed integers */
#if 1 /* uncomment to time without byte swapping and disk writing */
for(i = 0; i < status*info.channels; i += info.channels)
{
/* Left channel */
Sample=shift_signed(sample_buffer[i], 16 - MPC_FIXED_POINT_SCALE_SHIFT);
*(OutputPtr++)=Sample&0xff;
*(OutputPtr++)=Sample>>8;
/* Right channel. If the decoded stream is monophonic then
* the right output channel is the same as the left one.
*/
if(info.channels==2)
Sample=shift_signed(sample_buffer[i + 1], 16 - MPC_FIXED_POINT_SCALE_SHIFT);
*(OutputPtr++)=Sample&0xff;
*(OutputPtr++)=Sample>>8;
/* Flush the buffer if it is full. */
if(OutputPtr==OutputBufferEnd)
{
rb->write(file_info.outfile,OutputBuffer,OUTPUT_BUFFER_SIZE);
OutputPtr=OutputBuffer;
}
}
#endif
}
display_status(&file_info);
if (rb->button_get(false)!=BUTTON_NONE) {
close_wav(&file_info);
return PLUGIN_OK;
}
}
close_wav(&file_info);
rb->splash(HZ*2, true, "FINISHED!");
return PLUGIN_OK;
}
#endif /* CONFIG_HWCODEC == MASNONE */

2
tools/configure vendored
View file

@ -407,7 +407,7 @@ if [ -z "$archos" ]; then
archosrom="" archosrom=""
flash="" flash=""
plugins="yes" plugins="yes"
codecs="libmad liba52 libFLAC libTremor libwavpack dumb" codecs="libmad liba52 libFLAC libTremor libwavpack dumb libmusepack"
;; ;;
*) *)