summaryrefslogtreecommitdiff
path: root/apps/codecs/libwmavoice
diff options
context:
space:
mode:
authorMohamed Tarek <mt@rockbox.org>2010-08-07 13:06:05 +0000
committerMohamed Tarek <mt@rockbox.org>2010-08-07 13:06:05 +0000
commitfb26f52697f1bb215375b4acaa626ff36d8d4208 (patch)
tree8007ecfc48b7a70a866c07fcf0918b9c8f0e57f3 /apps/codecs/libwmavoice
parente3a6610ae7d2dfa5e7a0393938bccec07baf5b75 (diff)
downloadrockbox-fb26f52697f1bb215375b4acaa626ff36d8d4208.zip
rockbox-fb26f52697f1bb215375b4acaa626ff36d8d4208.tar.gz
rockbox-fb26f52697f1bb215375b4acaa626ff36d8d4208.tar.bz2
rockbox-fb26f52697f1bb215375b4acaa626ff36d8d4208.tar.xz
Add missing files from ffmpeg, write a README.rockbox and a makefile.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@27742 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/codecs/libwmavoice')
-rw-r--r--apps/codecs/libwmavoice/Makefile65
-rw-r--r--apps/codecs/libwmavoice/README.rockbox23
-rw-r--r--apps/codecs/libwmavoice/acelp_filters.c2
-rw-r--r--apps/codecs/libwmavoice/acelp_vectors.c270
-rw-r--r--apps/codecs/libwmavoice/acelp_vectors.h264
-rw-r--r--apps/codecs/libwmavoice/avcodec.h14
-rw-r--r--apps/codecs/libwmavoice/bitstream.c2
-rw-r--r--apps/codecs/libwmavoice/dct.c226
-rw-r--r--apps/codecs/libwmavoice/dct32.c267
-rw-r--r--apps/codecs/libwmavoice/fft.c2
-rw-r--r--apps/codecs/libwmavoice/fft.h2
-rw-r--r--apps/codecs/libwmavoice/libavutil/avutil.h8
-rw-r--r--apps/codecs/libwmavoice/libavutil/mathematics.c2
-rw-r--r--apps/codecs/libwmavoice/libavutil/mathematics.h6
-rw-r--r--apps/codecs/libwmavoice/libavutil/mem.c2
-rw-r--r--apps/codecs/libwmavoice/lsp.c2
-rw-r--r--apps/codecs/libwmavoice/mathops.h182
-rw-r--r--apps/codecs/libwmavoice/mdct.c2
-rw-r--r--apps/codecs/libwmavoice/mdct_tablegen.h60
-rw-r--r--apps/codecs/libwmavoice/rdft.c133
-rw-r--r--apps/codecs/libwmavoice/utils.c1188
-rw-r--r--apps/codecs/libwmavoice/wmavoice.c8
22 files changed, 2709 insertions, 21 deletions
diff --git a/apps/codecs/libwmavoice/Makefile b/apps/codecs/libwmavoice/Makefile
new file mode 100644
index 0000000..f1d987f
--- /dev/null
+++ b/apps/codecs/libwmavoice/Makefile
@@ -0,0 +1,65 @@
+CC = gcc -o
+INC = -I.
+OUTPUT = wmavoice
+STD = c99
+LIBS = -lm
+CFLAGS = -Wall -ggdb -std=$(STD) $(INC)
+
+SOURCES = \
+acelp_filters.c\
+acelp_vectors.c\
+avfft.c\
+bitstream.c\
+celp_filters.c\
+celp_math.c\
+dct.c\
+fft.c\
+lsp.c\
+mdct.c\
+rdft.c\
+utils.c\
+wmavoice.c\
+libavutil/log.c\
+libavutil/lzo.c\
+libavutil/mem.c\
+libavutil/mathematics.c
+
+HEADERS = \
+acelp_vectors.h\
+celp_math.h\
+get_bits.h\
+wmavoice_data.h\
+avcodec.h\
+fft.h\
+dsputil.h\
+acelp_filters.h\
+celp_filters.h\
+put_bits.h\
+lsp.h\
+internal.h\
+avfft.h\
+mathops.h\
+mdct_tablegen.h\
+dct32.c\
+libavutil/avutil.h\
+libavutil/attributes.h\
+libavutil/lzo.h\
+libavutil/mem.h\
+libavutil/log.h\
+libavutil/internal.h\
+libavutil/common.h\
+libavutil/intreadwrite.h\
+libavutil/bswap.h\
+libavutil/mathematics.h
+
+OBJECTS = $(SOURCES:.c=.o)
+
+all:$(OUTPUT)
+
+$(OUTPUT):$(SOURCES) $(HEADERS)
+ $(CC) $@ $(CFLAGS) $(SOURCES) $(LIBS)
+ @echo "Done."
+
+clean:
+ rm -f *.o $(OUTPUT) *~
+
diff --git a/apps/codecs/libwmavoice/README.rockbox b/apps/codecs/libwmavoice/README.rockbox
new file mode 100644
index 0000000..4a21a96
--- /dev/null
+++ b/apps/codecs/libwmavoice/README.rockbox
@@ -0,0 +1,23 @@
+Library: libwmavoice
+Imported: 2010-08-07 by Mohamed Tarek
+
+This set of files form the files needed from ffmpeg's libavcodec and libavutil
+to build a standalone wma voice decoder.
+
+LICENSING INFORMATION
+
+ffmpeg is licensed under the Lesser GNU General Public License and the file
+wmavoice.c is copyright (c) 2009 Ronald S. Bultje.
+
+IMPORT DETAILS
+
+Based on ffmpeg svn r24734 dated 7 August 2010.
+
+As of 7 August 2010, libwmavoice contains just the files from ffmpeg with
+minimum modifications to comile standalone. The decoder isn't still used in
+rockbox in anyway.
+
+COMPILING
+
+the decoder can be compiled by issuing the "make" command from witin the
+libwmavoice directory in any unix-line environment.
diff --git a/apps/codecs/libwmavoice/acelp_filters.c b/apps/codecs/libwmavoice/acelp_filters.c
index 31f0e86..c48c0e7 100644
--- a/apps/codecs/libwmavoice/acelp_filters.c
+++ b/apps/codecs/libwmavoice/acelp_filters.c
@@ -45,7 +45,7 @@ void ff_acelp_interpolate(int16_t* out, const int16_t* in,
{
int n, i;
- assert(frac_pos >= 0 && frac_pos < precision);
+ //assert(frac_pos >= 0 && frac_pos < precision);
for (n = 0; n < length; n++) {
int idx = 0;
diff --git a/apps/codecs/libwmavoice/acelp_vectors.c b/apps/codecs/libwmavoice/acelp_vectors.c
new file mode 100644
index 0000000..e41e5fa
--- /dev/null
+++ b/apps/codecs/libwmavoice/acelp_vectors.c
@@ -0,0 +1,270 @@
+/*
+ * adaptive and fixed codebook vector operations for ACELP-based codecs
+ *
+ * Copyright (c) 2008 Vladimir Voroshilov
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <inttypes.h>
+#include "avcodec.h"
+#include "acelp_vectors.h"
+#include "celp_math.h"
+
+const uint8_t ff_fc_2pulses_9bits_track1[16] =
+{
+ 1, 3,
+ 6, 8,
+ 11, 13,
+ 16, 18,
+ 21, 23,
+ 26, 28,
+ 31, 33,
+ 36, 38
+};
+const uint8_t ff_fc_2pulses_9bits_track1_gray[16] =
+{
+ 1, 3,
+ 8, 6,
+ 18, 16,
+ 11, 13,
+ 38, 36,
+ 31, 33,
+ 21, 23,
+ 28, 26,
+};
+
+const uint8_t ff_fc_2pulses_9bits_track2_gray[32] =
+{
+ 0, 2,
+ 5, 4,
+ 12, 10,
+ 7, 9,
+ 25, 24,
+ 20, 22,
+ 14, 15,
+ 19, 17,
+ 36, 31,
+ 21, 26,
+ 1, 6,
+ 16, 11,
+ 27, 29,
+ 32, 30,
+ 39, 37,
+ 34, 35,
+};
+
+const uint8_t ff_fc_4pulses_8bits_tracks_13[16] =
+{
+ 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75,
+};
+
+const uint8_t ff_fc_4pulses_8bits_track_4[32] =
+{
+ 3, 4,
+ 8, 9,
+ 13, 14,
+ 18, 19,
+ 23, 24,
+ 28, 29,
+ 33, 34,
+ 38, 39,
+ 43, 44,
+ 48, 49,
+ 53, 54,
+ 58, 59,
+ 63, 64,
+ 68, 69,
+ 73, 74,
+ 78, 79,
+};
+
+#if 0
+static uint8_t gray_decode[32] =
+{
+ 0, 1, 3, 2, 7, 6, 4, 5,
+ 15, 14, 12, 13, 8, 9, 11, 10,
+ 31, 30, 28, 29, 24, 25, 27, 26,
+ 16, 17, 19, 18, 23, 22, 20, 21
+};
+#endif
+
+const float ff_pow_0_7[10] = {
+ 0.700000, 0.490000, 0.343000, 0.240100, 0.168070,
+ 0.117649, 0.082354, 0.057648, 0.040354, 0.028248
+};
+
+const float ff_pow_0_75[10] = {
+ 0.750000, 0.562500, 0.421875, 0.316406, 0.237305,
+ 0.177979, 0.133484, 0.100113, 0.075085, 0.056314
+};
+
+const float ff_pow_0_55[10] = {
+ 0.550000, 0.302500, 0.166375, 0.091506, 0.050328,
+ 0.027681, 0.015224, 0.008373, 0.004605, 0.002533
+};
+
+const float ff_b60_sinc[61] = {
+ 0.898529 , 0.865051 , 0.769257 , 0.624054 , 0.448639 , 0.265289 ,
+ 0.0959167 , -0.0412598 , -0.134338 , -0.178986 , -0.178528 , -0.142609 ,
+-0.0849304 , -0.0205078 , 0.0369568 , 0.0773926 , 0.0955200 , 0.0912781 ,
+ 0.0689392 , 0.0357056 , 0. , -0.0305481 , -0.0504150 , -0.0570068 ,
+-0.0508423 , -0.0350037 , -0.0141602 , 0.00665283, 0.0230713 , 0.0323486 ,
+ 0.0335388 , 0.0275879 , 0.0167847 , 0.00411987, -0.00747681, -0.0156860 ,
+-0.0193481 , -0.0183716 , -0.0137634 , -0.00704956, 0. , 0.00582886 ,
+ 0.00939941, 0.0103760 , 0.00903320, 0.00604248, 0.00238037, -0.00109863 ,
+-0.00366211, -0.00497437, -0.00503540, -0.00402832, -0.00241089, -0.000579834,
+ 0.00103760, 0.00222778, 0.00277710, 0.00271606, 0.00213623, 0.00115967 ,
+ 0.
+};
+
+void ff_acelp_fc_pulse_per_track(
+ int16_t* fc_v,
+ const uint8_t *tab1,
+ const uint8_t *tab2,
+ int pulse_indexes,
+ int pulse_signs,
+ int pulse_count,
+ int bits)
+{
+ int mask = (1 << bits) - 1;
+ int i;
+
+ for(i=0; i<pulse_count; i++)
+ {
+ fc_v[i + tab1[pulse_indexes & mask]] +=
+ (pulse_signs & 1) ? 8191 : -8192; // +/-1 in (2.13)
+
+ pulse_indexes >>= bits;
+ pulse_signs >>= 1;
+ }
+
+ fc_v[tab2[pulse_indexes]] += (pulse_signs & 1) ? 8191 : -8192;
+}
+
+void ff_decode_10_pulses_35bits(const int16_t *fixed_index,
+ AMRFixed *fixed_sparse,
+ const uint8_t *gray_decode,
+ int half_pulse_count, int bits)
+{
+ int i;
+ int mask = (1 << bits) - 1;
+
+ fixed_sparse->no_repeat_mask = 0;
+ fixed_sparse->n = 2 * half_pulse_count;
+ for (i = 0; i < half_pulse_count; i++) {
+ const int pos1 = gray_decode[fixed_index[2*i+1] & mask] + i;
+ const int pos2 = gray_decode[fixed_index[2*i ] & mask] + i;
+ const float sign = (fixed_index[2*i+1] & (1 << bits)) ? -1.0 : 1.0;
+ fixed_sparse->x[2*i+1] = pos1;
+ fixed_sparse->x[2*i ] = pos2;
+ fixed_sparse->y[2*i+1] = sign;
+ fixed_sparse->y[2*i ] = pos2 < pos1 ? -sign : sign;
+ }
+}
+
+void ff_acelp_weighted_vector_sum(
+ int16_t* out,
+ const int16_t *in_a,
+ const int16_t *in_b,
+ int16_t weight_coeff_a,
+ int16_t weight_coeff_b,
+ int16_t rounder,
+ int shift,
+ int length)
+{
+ int i;
+
+ // Clipping required here; breaks OVERFLOW test.
+ for(i=0; i<length; i++)
+ out[i] = av_clip_int16((
+ in_a[i] * weight_coeff_a +
+ in_b[i] * weight_coeff_b +
+ rounder) >> shift);
+}
+
+void ff_weighted_vector_sumf(float *out, const float *in_a, const float *in_b,
+ float weight_coeff_a, float weight_coeff_b, int length)
+{
+ int i;
+
+ for(i=0; i<length; i++)
+ out[i] = weight_coeff_a * in_a[i]
+ + weight_coeff_b * in_b[i];
+}
+
+void ff_adaptive_gain_control(float *out, const float *in, float speech_energ,
+ int size, float alpha, float *gain_mem)
+{
+ int i;
+ float postfilter_energ = ff_dot_productf(in, in, size);
+ float gain_scale_factor = 1.0;
+ float mem = *gain_mem;
+
+ if (postfilter_energ)
+ gain_scale_factor = sqrt(speech_energ / postfilter_energ);
+
+ gain_scale_factor *= 1.0 - alpha;
+
+ for (i = 0; i < size; i++) {
+ mem = alpha * mem + gain_scale_factor;
+ out[i] = in[i] * mem;
+ }
+
+ *gain_mem = mem;
+}
+
+void ff_scale_vector_to_given_sum_of_squares(float *out, const float *in,
+ float sum_of_squares, const int n)
+{
+ int i;
+ float scalefactor = ff_dot_productf(in, in, n);
+ if (scalefactor)
+ scalefactor = sqrt(sum_of_squares / scalefactor);
+ for (i = 0; i < n; i++)
+ out[i] = in[i] * scalefactor;
+}
+
+void ff_set_fixed_vector(float *out, const AMRFixed *in, float scale, int size)
+{
+ int i;
+
+ for (i=0; i < in->n; i++) {
+ int x = in->x[i], repeats = !((in->no_repeat_mask >> i) & 1);
+ float y = in->y[i] * scale;
+
+ do {
+ out[x] += y;
+ y *= in->pitch_fac;
+ x += in->pitch_lag;
+ } while (x < size && repeats);
+ }
+}
+
+void ff_clear_fixed_vector(float *out, const AMRFixed *in, int size)
+{
+ int i;
+
+ for (i=0; i < in->n; i++) {
+ int x = in->x[i], repeats = !((in->no_repeat_mask >> i) & 1);
+
+ do {
+ out[x] = 0.0;
+ x += in->pitch_lag;
+ } while (x < size && repeats);
+ }
+}
diff --git a/apps/codecs/libwmavoice/acelp_vectors.h b/apps/codecs/libwmavoice/acelp_vectors.h
new file mode 100644
index 0000000..f3bc781
--- /dev/null
+++ b/apps/codecs/libwmavoice/acelp_vectors.h
@@ -0,0 +1,264 @@
+/*
+ * adaptive and fixed codebook vector operations for ACELP-based codecs
+ *
+ * Copyright (c) 2008 Vladimir Voroshilov
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_ACELP_VECTORS_H
+#define AVCODEC_ACELP_VECTORS_H
+
+#include <stdint.h>
+
+/** Sparse representation for the algebraic codebook (fixed) vector */
+typedef struct {
+ int n;
+ int x[10];
+ float y[10];
+ int no_repeat_mask;
+ int pitch_lag;
+ float pitch_fac;
+} AMRFixed;
+
+/**
+ * Track|Pulse| Positions
+ * -------------------------------------------------------------------------
+ * 1 | 0 | 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75
+ * -------------------------------------------------------------------------
+ * 2 | 1 | 1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76
+ * -------------------------------------------------------------------------
+ * 3 | 2 | 2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52, 57, 62, 67, 72, 77
+ * -------------------------------------------------------------------------
+ *
+ * Table contains only first the pulse indexes.
+ *
+ * Used in G.729 @@8k, G.729 @@4.4k, AMR @@7.95k, AMR @@7.40k
+ */
+extern const uint8_t ff_fc_4pulses_8bits_tracks_13[16];
+
+/**
+ * Track|Pulse| Positions
+ * -------------------------------------------------------------------------
+ * 4 | 3 | 3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53, 58, 63, 68, 73, 78
+ * | | 4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59, 64, 69, 74, 79
+ * -------------------------------------------------------------------------
+ *
+ * @remark Track in the table should be read top-to-bottom, left-to-right.
+ *
+ * Used in G.729 @@8k, G.729 @@4.4k, AMR @@7.95k, AMR @@7.40k
+ */
+extern const uint8_t ff_fc_4pulses_8bits_track_4[32];
+
+/**
+ * Track|Pulse| Positions
+ * -----------------------------------------
+ * 1 | 0 | 1, 6, 11, 16, 21, 26, 31, 36
+ * | | 3, 8, 13, 18, 23, 28, 33, 38
+ * -----------------------------------------
+ *
+ * @remark Track in the table should be read top-to-bottom, left-to-right.
+ *
+ * @note (EE) Reference G.729D code also uses gray decoding for each
+ * pulse index before looking up the value in the table.
+ *
+ * Used in G.729 @@6.4k (with gray coding), AMR @@5.9k (without gray coding)
+ */
+extern const uint8_t ff_fc_2pulses_9bits_track1[16];
+extern const uint8_t ff_fc_2pulses_9bits_track1_gray[16];
+
+/**
+ * Track|Pulse| Positions
+ * -----------------------------------------
+ * 2 | 1 | 0, 7, 14, 20, 27, 34, 1, 21
+ * | | 2, 9, 15, 22, 29, 35, 6, 26
+ * | | 4,10, 17, 24, 30, 37, 11, 31
+ * | | 5,12, 19, 25, 32, 39, 16, 36
+ * -----------------------------------------
+ *
+ * @remark Track in the table should be read top-to-bottom, left-to-right.
+ *
+ * @note (EE.1) This table (from the reference code) does not comply with
+ * the specification.
+ * The specification contains the following table:
+ *
+ * Track|Pulse| Positions
+ * -----------------------------------------
+ * 2 | 1 | 0, 5, 10, 15, 20, 25, 30, 35
+ * | | 1, 6, 11, 16, 21, 26, 31, 36
+ * | | 2, 7, 12, 17, 22, 27, 32, 37
+ * | | 4, 9, 14, 19, 24, 29, 34, 39
+ *
+ * -----------------------------------------
+ *
+ * @note (EE.2) Reference G.729D code also uses gray decoding for each
+ * pulse index before looking up the value in the table.
+ *
+ * Used in G.729 @@6.4k (with gray coding)
+ */
+extern const uint8_t ff_fc_2pulses_9bits_track2_gray[32];
+
+/**
+ * b60 hamming windowed sinc function coefficients
+ */
+extern const float ff_b60_sinc[61];
+
+/**
+ * Table of pow(0.7,n)
+ */
+extern const float ff_pow_0_7[10];
+
+/**
+ * Table of pow(0.75,n)
+ */
+extern const float ff_pow_0_75[10];
+
+/**
+ * Table of pow(0.55,n)
+ */
+extern const float ff_pow_0_55[10];
+
+/**
+ * Decode fixed-codebook vector (3.8 and D.5.8 of G.729, 5.7.1 of AMR).
+ * @param[out] fc_v decoded fixed codebook vector (2.13)
+ * @param tab1 table used for first pulse_count pulses
+ * @param tab2 table used for last pulse
+ * @param pulse_indexes fixed codebook indexes
+ * @param pulse_signs signs of the excitation pulses (0 bit value
+ * means negative sign)
+ * @param bits number of bits per one pulse index
+ * @param pulse_count number of pulses decoded using first table
+ * @param bits length of one pulse index in bits
+ *
+ * Used in G.729 @@8k, G.729 @@4.4k, G.729 @@6.4k, AMR @@7.95k, AMR @@7.40k
+ */
+void ff_acelp_fc_pulse_per_track(int16_t* fc_v,
+ const uint8_t *tab1,
+ const uint8_t *tab2,
+ int pulse_indexes,
+ int pulse_signs,
+ int pulse_count,
+ int bits);
+
+/**
+ * Decode the algebraic codebook index to pulse positions and signs and
+ * construct the algebraic codebook vector for MODE_12k2.
+ *
+ * @note: The positions and signs are explicitly coded in MODE_12k2.
+ *
+ * @param fixed_index positions of the ten pulses
+ * @param fixed_sparse pointer to the algebraic codebook vector
+ * @param gray_decode gray decoding table
+ * @param half_pulse_count number of couples of pulses
+ * @param bits length of one pulse index in bits
+ */
+void ff_decode_10_pulses_35bits(const int16_t *fixed_index,
+ AMRFixed *fixed_sparse,
+ const uint8_t *gray_decode,
+ int half_pulse_count, int bits);
+
+
+/**
+ * weighted sum of two vectors with rounding.
+ * @param[out] out result of addition
+ * @param in_a first vector
+ * @param in_b second vector
+ * @param weight_coeff_a first vector weight coefficient
+ * @param weight_coeff_a second vector weight coefficient
+ * @param rounder this value will be added to the sum of the two vectors
+ * @param shift result will be shifted to right by this value
+ * @param length vectors length
+ *
+ * @note It is safe to pass the same buffer for out and in_a or in_b.
+ *
+ * out[i] = (in_a[i]*weight_a + in_b[i]*weight_b + rounder) >> shift
+ */
+void ff_acelp_weighted_vector_sum(int16_t* out,
+ const int16_t *in_a,
+ const int16_t *in_b,
+ int16_t weight_coeff_a,
+ int16_t weight_coeff_b,
+ int16_t rounder,
+ int shift,
+ int length);
+
+/**
+ * float implementation of weighted sum of two vectors.
+ * @param[out] out result of addition
+ * @param in_a first vector
+ * @param in_b second vector
+ * @param weight_coeff_a first vector weight coefficient
+ * @param weight_coeff_a second vector weight coefficient
+ * @param length vectors length
+ *
+ * @note It is safe to pass the same buffer for out and in_a or in_b.
+ */
+void ff_weighted_vector_sumf(float *out, const float *in_a, const float *in_b,
+ float weight_coeff_a, float weight_coeff_b,
+ int length);
+
+/**
+ * Adaptive gain control (as used in AMR postfiltering)
+ *
+ * @param out output buffer for filtered speech data
+ * @param in the input speech buffer (may be the same as out)
+ * @param speech_energ input energy
+ * @param size the input buffer size
+ * @param alpha exponential filter factor
+ * @param gain_mem a pointer to the filter memory (single float of size)
+ */
+void ff_adaptive_gain_control(float *out, const float *in, float speech_energ,
+ int size, float alpha, float *gain_mem);
+
+/**
+ * Set the sum of squares of a signal by scaling
+ *
+ * @param out output samples
+ * @param in input samples
+ * @param sum_of_squares new sum of squares
+ * @param n number of samples
+ *
+ * @note If the input is zero (or its energy underflows), the output is zero.
+ * This is the behavior of AGC in the AMR reference decoder. The QCELP
+ * reference decoder seems to have undefined behavior.
+ *
+ * TIA/EIA/IS-733 2.4.8.3-2/3/4/5, 2.4.8.6
+ * 3GPP TS 26.090 6.1 (6)
+ */
+void ff_scale_vector_to_given_sum_of_squares(float *out, const float *in,
+ float sum_of_squares, const int n);
+
+/**
+ * Add fixed vector to an array from a sparse representation
+ *
+ * @param out fixed vector with pitch sharpening
+ * @param in sparse fixed vector
+ * @param scale number to multiply the fixed vector by
+ * @param size the output vector size
+ */
+void ff_set_fixed_vector(float *out, const AMRFixed *in, float scale, int size);
+
+/**
+ * Clear array values set by set_fixed_vector
+ *
+ * @param out fixed vector to be cleared
+ * @param in sparse fixed vector
+ * @param size the output vector size
+ */
+void ff_clear_fixed_vector(float *out, const AMRFixed *in, int size);
+
+#endif /* AVCODEC_ACELP_VECTORS_H */
diff --git a/apps/codecs/libwmavoice/avcodec.h b/apps/codecs/libwmavoice/avcodec.h
index 9186bf5..db08ab3 100644
--- a/apps/codecs/libwmavoice/avcodec.h
+++ b/apps/codecs/libwmavoice/avcodec.h
@@ -1114,7 +1114,7 @@ typedef struct AVCodecContext {
* - encoding: MUST be set by user.
* - decoding: Set by libavcodec.
*/
- AVRational time_base;
+ //AVRational time_base;
/* video only */
/**
@@ -1142,7 +1142,7 @@ typedef struct AVCodecContext {
* - encoding: Set by user.
* - decoding: Set by user if known, overridden by libavcodec if known
*/
- enum PixelFormat pix_fmt;
+ //enum PixelFormat pix_fmt;
/**
* Frame rate emulation. If not zero, the lower layer (i.e. format handler)
@@ -1693,7 +1693,7 @@ typedef struct AVCodecContext {
* - encoding: Set by user.
* - decoding: Set by libavcodec.
*/
- AVRational sample_aspect_ratio;
+ //AVRational sample_aspect_ratio;
/**
* the picture in the bitstream
@@ -2738,8 +2738,8 @@ typedef struct AVCodec {
* Will be called when seeking
*/
void (*flush)(AVCodecContext *);
- const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
- const enum PixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
+ //const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
+ //const enum PixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
/**
* Descriptive name for the codec, meant to be more human readable than name.
* You should use the NULL_IF_CONFIG_SMALL() macro to define it.
@@ -2781,7 +2781,7 @@ typedef struct AVHWAccel {
*
* Only hardware accelerated formats are supported here.
*/
- enum PixelFormat pix_fmt;
+ //enum PixelFormat pix_fmt;
/**
* Hardware accelerated codec capabilities.
@@ -3976,7 +3976,7 @@ attribute_deprecated int av_parse_video_frame_size(int *width_ptr, int *height_p
*
* @deprecated Deprecated in favor of av_parse_video_rate().
*/
-attribute_deprecated int av_parse_video_frame_rate(AVRational *frame_rate, const char *str);
+//attribute_deprecated int av_parse_video_frame_rate(AVRational *frame_rate, const char *str);
#endif
/**
diff --git a/apps/codecs/libwmavoice/bitstream.c b/apps/codecs/libwmavoice/bitstream.c
index 83f30f9..d408f66 100644
--- a/apps/codecs/libwmavoice/bitstream.c
+++ b/apps/codecs/libwmavoice/bitstream.c
@@ -66,7 +66,7 @@ void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
if(length==0) return;
- if(CONFIG_SMALL || words < 16 || put_bits_count(pb)&7){
+ if(/*CONFIG_SMALL ||*/ words < 16 || put_bits_count(pb)&7){
for(i=0; i<words; i++) put_bits(pb, 16, AV_RB16(src + 2*i));
}else{
for(i=0; put_bits_count(pb)&31; i++)
diff --git a/apps/codecs/libwmavoice/dct.c b/apps/codecs/libwmavoice/dct.c
new file mode 100644
index 0000000..95aef5a
--- /dev/null
+++ b/apps/codecs/libwmavoice/dct.c
@@ -0,0 +1,226 @@
+/*
+ * (I)DCT Transforms
+ * Copyright (c) 2009 Peter Ross <pross@xvid.org>
+ * Copyright (c) 2010 Alex Converse <alex.converse@gmail.com>
+ * Copyright (c) 2010 Vitor Sessak
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * (Inverse) Discrete Cosine Transforms. These are also known as the
+ * type II and type III DCTs respectively.
+ */
+
+#include <math.h>
+#include "libavutil/mathematics.h"
+#include "fft.h"
+//#include "x86/fft.h"
+
+#define DCT32_FLOAT
+#include "dct32.c"
+
+/* sin((M_PI * x / (2*n)) */
+#define SIN(s,n,x) (s->costab[(n) - (x)])
+
+/* cos((M_PI * x / (2*n)) */
+#define COS(s,n,x) (s->costab[x])
+
+static void ff_dst_calc_I_c(DCTContext *ctx, FFTSample *data)
+{
+ int n = 1 << ctx->nbits;
+ int i;
+
+ data[0] = 0;
+ for(i = 1; i < n/2; i++) {
+ float tmp1 = data[i ];
+ float tmp2 = data[n - i];
+ float s = SIN(ctx, n, 2*i);
+
+ s *= tmp1 + tmp2;
+ tmp1 = (tmp1 - tmp2) * 0.5f;
+ data[i ] = s + tmp1;
+ data[n - i] = s - tmp1;
+ }
+
+ data[n/2] *= 2;
+ ff_rdft_calc(&ctx->rdft, data);
+
+ data[0] *= 0.5f;
+
+ for(i = 1; i < n-2; i += 2) {
+ data[i + 1] += data[i - 1];
+ data[i ] = -data[i + 2];
+ }
+
+ data[n-1] = 0;
+}
+
+static void ff_dct_calc_I_c(DCTContext *ctx, FFTSample *data)
+{
+ int n = 1 << ctx->nbits;
+ int i;
+ float next = -0.5f * (data[0] - data[n]);
+
+ for(i = 0; i < n/2; i++) {
+ float tmp1 = data[i ];
+ float tmp2 = data[n - i];
+ float s = SIN(ctx, n, 2*i);
+ float c = COS(ctx, n, 2*i);
+
+ c *= tmp1 - tmp2;
+ s *= tmp1 - tmp2;
+
+ next += c;
+
+ tmp1 = (tmp1 + tmp2) * 0.5f;
+ data[i ] = tmp1 - s;
+ data[n - i] = tmp1 + s;
+ }
+
+ ff_rdft_calc(&ctx->rdft, data);
+ data[n] = data[1];
+ data[1] = next;
+
+ for(i = 3; i <= n; i += 2)
+ data[i] = data[i - 2] - data[i];
+}
+
+static void ff_dct_calc_III_c(DCTContext *ctx, FFTSample *data)
+{
+ int n = 1 << ctx->nbits;
+ int i;
+
+ float next = data[n - 1];
+ float inv_n = 1.0f / n;
+
+ for (i = n - 2; i >= 2; i -= 2) {
+ float val1 = data[i ];
+ float val2 = data[i - 1] - data[i + 1];
+ float c = COS(ctx, n, i);
+ float s = SIN(ctx, n, i);
+
+ data[i ] = c * val1 + s * val2;
+ data[i + 1] = s * val1 - c * val2;
+ }
+
+ data[1] = 2 * next;
+
+ ff_rdft_calc(&ctx->rdft, data);
+
+ for (i = 0; i < n / 2; i++) {
+ float tmp1 = data[i ] * inv_n;
+ float tmp2 = data[n - i - 1] * inv_n;
+ float csc = ctx->csc2[i] * (tmp1 - tmp2);
+
+ tmp1 += tmp2;
+ data[i ] = tmp1 + csc;
+ data[n - i - 1] = tmp1 - csc;
+ }
+}
+
+static void ff_dct_calc_II_c(DCTContext *ctx, FFTSample *data)
+{
+ int n = 1 << ctx->nbits;
+ int i;
+ float next;
+
+ for (i=0; i < n/2; i++) {
+ float tmp1 = data[i ];
+ float tmp2 = data[n - i - 1];
+ float s = SIN(ctx, n, 2*i + 1);
+
+ s *= tmp1 - tmp2;
+ tmp1 = (tmp1 + tmp2) * 0.5f;
+
+ data[i ] = tmp1 + s;
+ data[n-i-1] = tmp1 - s;
+ }
+
+ ff_rdft_calc(&ctx->rdft, data);
+
+ next = data[1] * 0.5;
+ data[1] *= -1;
+
+ for (i = n - 2; i >= 0; i -= 2) {
+ float inr = data[i ];
+ float ini = data[i + 1];
+ float c = COS(ctx, n, i);
+ float s = SIN(ctx, n, i);
+
+ data[i ] = c * inr + s * ini;
+
+ data[i+1] = next;
+
+ next += s * inr - c * ini;
+ }
+}
+
+static void dct32_func(DCTContext *ctx, FFTSample *data)
+{
+ ctx->dct32(data, data);
+}
+
+void ff_dct_calc(DCTContext *s, FFTSample *data)
+{
+ s->dct_calc(s, data);
+}
+
+av_cold int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType inverse)
+{
+ int n = 1 << nbits;
+ int i;
+
+ s->nbits = nbits;
+ s->inverse = inverse;
+
+ ff_init_ff_cos_tabs(nbits+2);
+
+ s->costab = ff_cos_tabs[nbits+2];
+
+ s->csc2 = av_malloc(n/2 * sizeof(FFTSample));
+
+ if (ff_rdft_init(&s->rdft, nbits, inverse == DCT_III) < 0) {
+ av_free(s->csc2);
+ return -1;
+ }
+
+ for (i = 0; i < n/2; i++)
+ s->csc2[i] = 0.5 / sin((M_PI / (2*n) * (2*i + 1)));
+
+ switch(inverse) {
+ case DCT_I : s->dct_calc = ff_dct_calc_I_c; break;
+ case DCT_II : s->dct_calc = ff_dct_calc_II_c ; break;
+ case DCT_III: s->dct_calc = ff_dct_calc_III_c; break;
+ case DST_I : s->dct_calc = ff_dst_calc_I_c; break;
+ }
+
+ if (inverse == DCT_II && nbits == 5)
+ s->dct_calc = dct32_func;
+
+ s->dct32 = dct32;
+ //if (HAVE_MMX) ff_dct_init_mmx(s);
+
+ return 0;
+}
+
+av_cold void ff_dct_end(DCTContext *s)
+{
+ ff_rdft_end(&s->rdft);
+ av_free(s->csc2);
+}
diff --git a/apps/codecs/libwmavoice/dct32.c b/apps/codecs/libwmavoice/dct32.c
new file mode 100644
index 0000000..4e843ee
--- /dev/null
+++ b/apps/codecs/libwmavoice/dct32.c
@@ -0,0 +1,267 @@
+/*
+ * Template for the Discrete Cosine Transform for 32 samples
+ * Copyright (c) 2001, 2002 Fabrice Bellard
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifdef DCT32_FLOAT
+# define FIXHR(x) ((float)(x))
+# define MULH3(x, y, s) ((s)*(y)*(x))
+# define INTFLOAT float
+#endif
+
+
+/* tab[i][j] = 1.0 / (2.0 * cos(pi*(2*k+1) / 2^(6 - j))) */
+
+/* cos(i*pi/64) */
+
+#define COS0_0 FIXHR(0.50060299823519630134/2)
+#define COS0_1 FIXHR(0.50547095989754365998/2)
+#define COS0_2 FIXHR(0.51544730992262454697/2)
+#define COS0_3 FIXHR(0.53104259108978417447/2)
+#define COS0_4 FIXHR(0.55310389603444452782/2)
+#define COS0_5 FIXHR(0.58293496820613387367/2)
+#define COS0_6 FIXHR(0.62250412303566481615/2)
+#define COS0_7 FIXHR(0.67480834145500574602/2)
+#define COS0_8 FIXHR(0.74453627100229844977/2)
+#define COS0_9 FIXHR(0.83934964541552703873/2)
+#define COS0_10 FIXHR(0.97256823786196069369/2)
+#define COS0_11 FIXHR(1.16943993343288495515/4)
+#define COS0_12 FIXHR(1.48416461631416627724/4)
+#define COS0_13 FIXHR(2.05778100995341155085/8)
+#define COS0_14 FIXHR(3.40760841846871878570/8)
+#define COS0_15 FIXHR(10.19000812354805681150/32)
+
+#define COS1_0 FIXHR(0.50241928618815570551/2)
+#define COS1_1 FIXHR(0.52249861493968888062/2)
+#define COS1_2 FIXHR(0.56694403481635770368/2)
+#define COS1_3 FIXHR(0.64682178335999012954/2)
+#define COS1_4 FIXHR(0.78815462345125022473/2)
+#define COS1_5 FIXHR(1.06067768599034747134/4)
+#define COS1_6 FIXHR(1.72244709823833392782/4)
+#define COS1_7 FIXHR(5.10114861868916385802/16)
+
+#define COS2_0 FIXHR(0.50979557910415916894/2)
+#define COS2_1 FIXHR(0.60134488693504528054/2)
+#define COS2_2 FIXHR(0.89997622313641570463/2)
+#define COS2_3 FIXHR(2.56291544774150617881/8)
+
+#define COS3_0 FIXHR(0.54119610014619698439/2)
+#define COS3_1 FIXHR(1.30656296487637652785/4)
+
+#define COS4_0 FIXHR(0.70710678118654752439/2)
+
+/* butterfly operator */
+#define BF(a, b, c, s)\
+{\
+ tmp0 = val##a + val##b;\
+ tmp1 = val##a - val##b;\
+ val##a = tmp0;\
+ val##b = MULH3(tmp1, c, 1<<(s));\
+}
+
+#define BF0(a, b, c, s)\
+{\
+ tmp0 = tab[a] + tab[b];\
+ tmp1 = tab[a] - tab[b];\
+ val##a = tmp0;\
+ val##b = MULH3(tmp1, c, 1<<(s));\
+}
+
+#define BF1(a, b, c, d)\
+{\
+ BF(a, b, COS4_0, 1);\
+ BF(c, d,-COS4_0, 1);\
+ val##c += val##d;\
+}
+
+#define BF2(a, b, c, d)\
+{\
+ BF(a, b, COS4_0, 1);\
+ BF(c, d,-COS4_0, 1);\
+ val##c += val##d;\
+ val##a += val##c;\
+ val##c += val##b;\
+ val##b += val##d;\
+}
+
+#define ADD(a, b) val##a += val##b
+
+/* DCT32 without 1/sqrt(2) coef zero scaling. */
+static void dct32(INTFLOAT *out, const INTFLOAT *tab)
+{
+ INTFLOAT tmp0, tmp1;
+
+ INTFLOAT val0 , val1 , val2 , val3 , val4 , val5 , val6 , val7 ,
+ val8 , val9 , val10, val11, val12, val13, val14, val15,
+ val16, val17, val18, val19, val20, val21, val22, val23,
+ val24, val25, val26, val27, val28, val29, val30, val31;
+
+ /* pass 1 */
+ BF0( 0, 31, COS0_0 , 1);
+ BF0(15, 16, COS0_15, 5);
+ /* pass 2 */
+ BF( 0, 15, COS1_0 , 1);
+ BF(16, 31,-COS1_0 , 1);
+ /* pass 1 */
+ BF0( 7, 24, COS0_7 , 1);
+ BF0( 8, 23, COS0_8 , 1);
+ /* pass 2 */
+ BF( 7, 8, COS1_7 , 4);
+ BF(23, 24,-COS1_7 , 4);
+ /* pass 3 */
+ BF( 0, 7, COS2_0 , 1);
+ BF( 8, 15,-COS2_0 , 1);
+ BF(16, 23, COS2_0 , 1);
+ BF(24, 31,-COS2_0 , 1);
+ /* pass 1 */
+ BF0( 3, 28, COS0_3 , 1);
+ BF0(12, 19, COS0_12, 2);
+ /* pass 2 */
+ BF( 3, 12, COS1_3 , 1);
+ BF(19, 28,-COS1_3 , 1);
+ /* pass 1 */
+ BF0( 4, 27, COS0_4 , 1);
+ BF0(11, 20, COS0_11, 2);
+ /* pass 2 */
+ BF( 4, 11, COS1_4 , 1);
+ BF(20, 27,-COS1_4 , 1);
+ /* pass 3 */
+ BF( 3, 4, COS2_3 , 3);
+ BF(11, 12,-COS2_3 , 3);
+ BF(19, 20, COS2_3 , 3);
+ BF(27, 28,-COS2_3 , 3);
+ /* pass 4 */
+ BF( 0, 3, COS3_0 , 1);
+ BF( 4, 7,-COS3_0 , 1);
+ BF( 8, 11, COS3_0 , 1);
+ BF(12, 15,-COS3_0 , 1);
+ BF(16, 19, COS3_0 , 1);
+ BF(20, 23,-COS3_0 , 1);
+ BF(24, 27, COS3_0 , 1);
+ BF(28, 31,-COS3_0 , 1);
+
+
+
+ /* pass 1 */
+ BF0( 1, 30, COS0_1 , 1);
+ BF0(14, 17, COS0_14, 3);
+ /* pass 2 */
+ BF( 1, 14, COS1_1 , 1);
+ BF(17, 30,-COS1_1 , 1);
+ /* pass 1 */
+ BF0( 6, 25, COS0_6 , 1);
+ BF0( 9, 22, COS0_9 , 1);
+ /* pass 2 */
+ BF( 6, 9, COS1_6 , 2);
+ BF(22, 25,-COS1_6 , 2);
+ /* pass 3 */
+ BF( 1, 6, COS2_1 , 1);
+ BF( 9, 14,-COS2_1 , 1);
+ BF(17, 22, COS2_1 , 1);
+ BF(25, 30,-COS2_1 , 1);
+
+ /* pass 1 */
+ BF0( 2, 29, COS0_2 , 1);
+ BF0(13, 18, COS0_13, 3);
+ /* pass 2 */
+ BF( 2, 13, COS1_2 , 1);
+ BF(18, 29,-COS1_2 , 1);
+ /* pass 1 */
+ BF0( 5, 26, COS0_5 , 1);
+ BF0(10, 21, COS0_10, 1);
+ /* pass 2 */
+ BF( 5, 10, COS1_5 , 2);
+ BF(21, 26,-COS1_5 , 2);
+ /* pass 3 */
+ BF( 2, 5, COS2_2 , 1);
+ BF(10, 13,-COS2_2 , 1);
+ BF(18, 21, COS2_2 , 1);
+ BF(26, 29,-COS2_2 , 1);
+ /* pass 4 */
+ BF( 1, 2, COS3_1 , 2);
+ BF( 5, 6,-COS3_1 , 2);
+ BF( 9, 10, COS3_1 , 2);
+ BF(13, 14,-COS3_1 , 2);
+ BF(17, 18, COS3_1 , 2);
+ BF(21, 22,-COS3_1 , 2);
+ BF(25, 26, COS3_1 , 2);
+ BF(29, 30,-COS3_1 , 2);
+
+ /* pass 5 */
+ BF1( 0, 1, 2, 3);
+ BF2( 4, 5, 6, 7);
+ BF1( 8, 9, 10, 11);
+ BF2(12, 13, 14, 15);
+ BF1(16, 17, 18, 19);
+ BF2(20, 21, 22, 23);
+ BF1(24, 25, 26, 27);
+ BF2(28, 29, 30, 31);
+
+ /* pass 6 */
+
+ ADD( 8, 12);
+ ADD(12, 10);
+ ADD(10, 14);
+ ADD(14, 9);
+ ADD( 9, 13);
+ ADD(13, 11);
+ ADD(11, 15);
+
+ out[ 0] = val0;
+ out[16] = val1;
+ out[ 8] = val2;
+ out[24] = val3;
+ out[ 4] = val4;
+ out[20] = val5;
+ out[12] = val6;
+ out[28] = val7;
+ out[ 2] = val8;
+ out[18] = val9;
+ out[10] = val10;
+ out[26] = val11;
+ out[ 6] = val12;
+ out[22] = val13;
+ out[14] = val14;
+ out[30] = val15;
+
+ ADD(24, 28);
+ ADD(28, 26);
+ ADD(26, 30);
+ ADD(30, 25);
+ ADD(25, 29);
+ ADD(29, 27);
+ ADD(27, 31);
+
+ out[ 1] = val16 + val24;
+ out[17] = val17 + val25;
+ out[ 9] = val18 + val26;
+ out[25] = val19 + val27;
+ out[ 5] = val20 + val28;
+ out[21] = val21 + val29;
+ out[13] = val22 + val30;
+ out[29] = val23 + val31;
+ out[ 3] = val24 + val20;
+ out[19] = val25 + val21;
+ out[11] = val26 + val22;
+ out[27] = val27 + val23;
+ out[ 7] = val28 + val18;
+ out[23] = val29 + val19;
+ out[15] = val30 + val17;
+ out[31] = val31;
+}
diff --git a/apps/codecs/libwmavoice/fft.c b/apps/codecs/libwmavoice/fft.c
index 8176551..a030534 100644
--- a/apps/codecs/libwmavoice/fft.c
+++ b/apps/codecs/libwmavoice/fft.c
@@ -103,9 +103,11 @@ av_cold int ff_fft_init(FFTContext *s, int nbits, int inverse)
s->mdct_calc = ff_mdct_calc_c;
#endif
+#if 0
if (ARCH_ARM) ff_fft_init_arm(s);
if (HAVE_ALTIVEC) ff_fft_init_altivec(s);
if (HAVE_MMX) ff_fft_init_mmx(s);
+#endif
for(j=4; j<=nbits; j++) {
ff_init_ff_cos_tabs(j);
diff --git a/apps/codecs/libwmavoice/fft.h b/apps/codecs/libwmavoice/fft.h
index eb6714f..2c54b56 100644
--- a/apps/codecs/libwmavoice/fft.h
+++ b/apps/codecs/libwmavoice/fft.h
@@ -23,7 +23,7 @@
#define AVCODEC_FFT_H
#include <stdint.h>
-#include "config.h"
+//#include "config.h"
#include "libavutil/mem.h"
#include "avfft.h"
diff --git a/apps/codecs/libwmavoice/libavutil/avutil.h b/apps/codecs/libwmavoice/libavutil/avutil.h
index 50b29fc..457829a 100644
--- a/apps/codecs/libwmavoice/libavutil/avutil.h
+++ b/apps/codecs/libwmavoice/libavutil/avutil.h
@@ -79,11 +79,11 @@ enum AVMediaType {
};
#include "common.h"
-#include "error.h"
+//#include "error.h"
#include "mathematics.h"
-#include "rational.h"
-#include "intfloat_readwrite.h"
+//#include "rational.h"
+//#include "intfloat_readwrite.h"
#include "log.h"
-#include "pixfmt.h"
+//#include "pixfmt.h"
#endif /* AVUTIL_AVUTIL_H */
diff --git a/apps/codecs/libwmavoice/libavutil/mathematics.c b/apps/codecs/libwmavoice/libavutil/mathematics.c
index c6851cb..c4fbe3b 100644
--- a/apps/codecs/libwmavoice/libavutil/mathematics.c
+++ b/apps/codecs/libwmavoice/libavutil/mathematics.c
@@ -130,6 +130,7 @@ int64_t av_rescale(int64_t a, int64_t b, int64_t c){
return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
}
+#if 0
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq){
int64_t b= bq.num * (int64_t)cq.den;
int64_t c= cq.num * (int64_t)bq.den;
@@ -143,6 +144,7 @@ int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b){
if (av_rescale_rnd(ts_b, b, a, AV_ROUND_DOWN) < ts_a) return 1;
return 0;
}
+#endif
int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod){
int64_t c= (a-b) & (mod-1);
diff --git a/apps/codecs/libwmavoice/libavutil/mathematics.h b/apps/codecs/libwmavoice/libavutil/mathematics.h
index 882a516..e07d4fe 100644
--- a/apps/codecs/libwmavoice/libavutil/mathematics.h
+++ b/apps/codecs/libwmavoice/libavutil/mathematics.h
@@ -24,7 +24,7 @@
#include <stdint.h>
#include <math.h>
#include "attributes.h"
-#include "rational.h"
+//#include "rational.h"
#ifndef M_E
#define M_E 2.7182818284590452354 /* e */
@@ -87,7 +87,7 @@ int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding) av_cons
/**
* Rescale a 64-bit integer by 2 rational numbers.
*/
-int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
+//int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
/**
* Compare 2 timestamps each in its own timebases.
@@ -95,7 +95,7 @@ int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
* is outside the int64_t range when represented in the others timebase.
* @return -1 if ts_a is before ts_b, 1 if ts_a is after ts_b or 0 if they represent the same position
*/
-int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
+//int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
/**
* Compare 2 integers modulo mod.
diff --git a/apps/codecs/libwmavoice/libavutil/mem.c b/apps/codecs/libwmavoice/libavutil/mem.c
index 8cad089..a9a3283 100644
--- a/apps/codecs/libwmavoice/libavutil/mem.c
+++ b/apps/codecs/libwmavoice/libavutil/mem.c
@@ -24,7 +24,7 @@
* default memory allocator for libavutil
*/
-#include "config.h"
+//#include "config.h"
#include <limits.h>
#include <stdlib.h>
diff --git a/apps/codecs/libwmavoice/lsp.c b/apps/codecs/libwmavoice/lsp.c
index 7112492..4dba9c1 100644
--- a/apps/codecs/libwmavoice/lsp.c
+++ b/apps/codecs/libwmavoice/lsp.c
@@ -150,7 +150,7 @@ void ff_acelp_lspd2lpc(const double *lsp, float *lpc, int lp_half_order)
double pa[MAX_LP_HALF_ORDER+1], qa[MAX_LP_HALF_ORDER+1];
float *lpc2 = lpc + (lp_half_order << 1) - 1;
- assert(lp_half_order <= MAX_LP_HALF_ORDER);
+ //assert(lp_half_order <= MAX_LP_HALF_ORDER);
ff_lsp2polyf(lsp, pa, lp_half_order);
ff_lsp2polyf(lsp + 1, qa, lp_half_order);
diff --git a/apps/codecs/libwmavoice/mathops.h b/apps/codecs/libwmavoice/mathops.h
new file mode 100644
index 0000000..4d88ed1
--- /dev/null
+++ b/apps/codecs/libwmavoice/mathops.h
@@ -0,0 +1,182 @@
+/*
+ * simple math operations
+ * Copyright (c) 2001, 2002 Fabrice Bellard
+ * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> et al
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#ifndef AVCODEC_MATHOPS_H
+#define AVCODEC_MATHOPS_H
+
+#include "libavutil/common.h"
+
+#if ARCH_ARM
+# include "arm/mathops.h"
+#elif ARCH_AVR32
+# include "avr32/mathops.h"
+#elif ARCH_BFIN
+# include "bfin/mathops.h"
+#elif ARCH_MIPS
+# include "mips/mathops.h"
+#elif ARCH_PPC
+# include "ppc/mathops.h"
+#elif ARCH_X86
+# include "x86/mathops.h"
+#endif
+
+/* generic implementation */
+
+#ifndef MULL
+# define MULL(a,b,s) (((int64_t)(a) * (int64_t)(b)) >> (s))
+#endif
+
+#ifndef MULH
+//gcc 3.4 creates an incredibly bloated mess out of this
+//# define MULH(a,b) (((int64_t)(a) * (int64_t)(b))>>32)
+
+static av_always_inline int MULH(int a, int b){
+ return ((int64_t)(a) * (int64_t)(b))>>32;
+}
+#endif
+
+#ifndef UMULH
+static av_always_inline unsigned UMULH(unsigned a, unsigned b){
+ return ((uint64_t)(a) * (uint64_t)(b))>>32;
+}
+#endif
+
+#ifndef MUL64
+# define MUL64(a,b) ((int64_t)(a) * (int64_t)(b))
+#endif
+
+#ifndef MAC64
+# define MAC64(d, a, b) ((d) += MUL64(a, b))
+#endif
+
+#ifndef MLS64
+# define MLS64(d, a, b) ((d) -= MUL64(a, b))
+#endif
+
+/* signed 16x16 -> 32 multiply add accumulate */
+#ifndef MAC16
+# define MAC16(rt, ra, rb) rt += (ra) * (rb)
+#endif
+
+/* signed 16x16 -> 32 multiply */
+#ifndef MUL16
+# define MUL16(ra, rb) ((ra) * (rb))
+#endif
+
+#ifndef MLS16
+# define MLS16(rt, ra, rb) ((rt) -= (ra) * (rb))
+#endif
+
+/* median of 3 */
+#ifndef mid_pred
+#define mid_pred mid_pred
+static inline av_const int mid_pred(int a, int b, int c)
+{
+#if 0
+ int t= (a-b)&((a-b)>>31);
+ a-=t;
+ b+=t;
+ b-= (b-c)&((b-c)>>31);
+ b+= (a-b)&((a-b)>>31);
+
+ return b;
+#else
+ if(a>b){
+ if(c>b){
+ if(c>a) b=a;
+ else b=c;
+ }
+ }else{
+ if(b>c){
+ if(c>a) b=c;
+ else b=a;
+ }
+ }
+ return b;
+#endif
+}
+#endif
+
+#ifndef sign_extend
+static inline av_const int sign_extend(int val, unsigned bits)
+{
+ return (val << ((8 * sizeof(int)) - bits)) >> ((8 * sizeof(int)) - bits);
+}
+#endif
+
+#ifndef zero_extend
+static inline av_const unsigned zero_extend(unsigned val, unsigned bits)
+{
+ return (val << ((8 * sizeof(int)) - bits)) >> ((8 * sizeof(int)) - bits);
+}
+#endif
+
+#ifndef COPY3_IF_LT
+#define COPY3_IF_LT(x, y, a, b, c, d)\
+if ((y) < (x)) {\
+ (x) = (y);\
+ (a) = (b);\
+ (c) = (d);\
+}
+#endif
+
+#ifndef NEG_SSR32
+# define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
+#endif
+
+#ifndef NEG_USR32
+# define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
+#endif
+
+#if HAVE_BIGENDIAN
+# ifndef PACK_2U8
+# define PACK_2U8(a,b) (((a) << 8) | (b))
+# endif
+# ifndef PACK_4U8
+# define PACK_4U8(a,b,c,d) (((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
+# endif
+# ifndef PACK_2U16
+# define PACK_2U16(a,b) (((a) << 16) | (b))
+# endif
+#else
+# ifndef PACK_2U8
+# define PACK_2U8(a,b) (((b) << 8) | (a))
+# endif
+# ifndef PACK_4U2
+# define PACK_4U8(a,b,c,d) (((d) << 24) | ((c) << 16) | ((b) << 8) | (a))
+# endif
+# ifndef PACK_2U16
+# define PACK_2U16(a,b) (((b) << 16) | (a))
+# endif
+#endif
+
+#ifndef PACK_2S8
+# define PACK_2S8(a,b) PACK_2U8((a)&255, (b)&255)
+#endif
+#ifndef PACK_4S8
+# define PACK_4S8(a,b,c,d) PACK_4U8((a)&255, (b)&255, (c)&255, (d)&255)
+#endif
+#ifndef PACK_2S16
+# define PACK_2S16(a,b) PACK_2U16((a)&0xffff, (b)&0xffff)
+#endif
+
+#endif /* AVCODEC_MATHOPS_H */
+
diff --git a/apps/codecs/libwmavoice/mdct.c b/apps/codecs/libwmavoice/mdct.c
index c511188..58bff35 100644
--- a/apps/codecs/libwmavoice/mdct.c
+++ b/apps/codecs/libwmavoice/mdct.c
@@ -39,7 +39,7 @@ av_cold void ff_kbd_window_init(float *window, float alpha, int n)
double local_window[FF_KBD_WINDOW_MAX];
double alpha2 = (alpha * M_PI / n) * (alpha * M_PI / n);
- assert(n <= FF_KBD_WINDOW_MAX);
+ //assert(n <= FF_KBD_WINDOW_MAX);
for (i = 0; i < n; i++) {
tmp = i * (n - i) * alpha2;
diff --git a/apps/codecs/libwmavoice/mdct_tablegen.h b/apps/codecs/libwmavoice/mdct_tablegen.h
new file mode 100644
index 0000000..51a0094
--- /dev/null
+++ b/apps/codecs/libwmavoice/mdct_tablegen.h
@@ -0,0 +1,60 @@
+/*
+ * Header file for hardcoded MDCT tables
+ *
+ * Copyright (c) 2009 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <assert.h>
+// do not use libavutil/libm.h since this is compiled both
+// for the host and the target and config.h is only valid for the target
+#include <math.h>
+#include "libavutil/attributes.h"
+
+#if !CONFIG_HARDCODED_TABLES
+SINETABLE( 32);
+SINETABLE( 64);
+SINETABLE( 128);
+SINETABLE( 256);
+SINETABLE( 512);
+SINETABLE(1024);
+SINETABLE(2048);
+SINETABLE(4096);
+#else
+#include "libavcodec/mdct_tables.h"
+#endif
+
+SINETABLE_CONST float * const ff_sine_windows[] = {
+ NULL, NULL, NULL, NULL, NULL, // unused
+ ff_sine_32 , ff_sine_64 ,
+ ff_sine_128, ff_sine_256, ff_sine_512, ff_sine_1024, ff_sine_2048, ff_sine_4096
+};
+
+// Generate a sine window.
+av_cold void ff_sine_window_init(float *window, int n) {
+ int i;
+ for(i = 0; i < n; i++)
+ window[i] = sinf((i + 0.5) * (M_PI / (2.0 * n)));
+}
+
+av_cold void ff_init_ff_sine_windows(int index) {
+ assert(index >= 0 && index < FF_ARRAY_ELEMS(ff_sine_windows));
+#if !CONFIG_HARDCODED_TABLES
+ ff_sine_window_init(ff_sine_windows[index], 1 << index);
+#endif
+}
diff --git a/apps/codecs/libwmavoice/rdft.c b/apps/codecs/libwmavoice/rdft.c
new file mode 100644
index 0000000..bc44f5a
--- /dev/null
+++ b/apps/codecs/libwmavoice/rdft.c
@@ -0,0 +1,133 @@
+/*
+ * (I)RDFT transforms
+ * Copyright (c) 2009 Alex Converse <alex dot converse at gmail dot com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <stdlib.h>
+#include <math.h>
+#include "libavutil/mathematics.h"
+#include "fft.h"
+
+/**
+ * @file
+ * (Inverse) Real Discrete Fourier Transforms.
+ */
+
+/* sin(2*pi*x/n) for 0<=x<n/4, followed by n/2<=x<3n/4 */
+#if !CONFIG_HARDCODED_TABLES
+SINTABLE(16);
+SINTABLE(32);
+SINTABLE(64);
+SINTABLE(128);
+SINTABLE(256);
+SINTABLE(512);
+SINTABLE(1024);
+SINTABLE(2048);
+SINTABLE(4096);
+SINTABLE(8192);
+SINTABLE(16384);
+SINTABLE(32768);
+SINTABLE(65536);
+#endif
+SINTABLE_CONST FFTSample * const ff_sin_tabs[] = {
+ NULL, NULL, NULL, NULL,
+ ff_sin_16, ff_sin_32, ff_sin_64, ff_sin_128, ff_sin_256, ff_sin_512, ff_sin_1024,
+ ff_sin_2048, ff_sin_4096, ff_sin_8192, ff_sin_16384, ff_sin_32768, ff_sin_65536,
+};
+
+/** Map one real FFT into two parallel real even and odd FFTs. Then interleave
+ * the two real FFTs into one complex FFT. Unmangle the results.
+ * ref: http://www.engineeringproductivitytools.com/stuff/T0001/PT10.HTM
+ */
+static void ff_rdft_calc_c(RDFTContext* s, FFTSample* data)
+{
+ int i, i1, i2;
+ FFTComplex ev, od;
+ const int n = 1 << s->nbits;
+ const float k1 = 0.5;
+ const float k2 = 0.5 - s->inverse;
+ const FFTSample *tcos = s->tcos;
+ const FFTSample *tsin = s->tsin;
+
+ if (!s->inverse) {
+ ff_fft_permute(&s->fft, (FFTComplex*)data);
+ ff_fft_calc(&s->fft, (FFTComplex*)data);
+ }
+ /* i=0 is a special case because of packing, the DC term is real, so we
+ are going to throw the N/2 term (also real) in with it. */
+ ev.re = data[0];
+ data[0] = ev.re+data[1];
+ data[1] = ev.re-data[1];
+ for (i = 1; i < (n>>2); i++) {
+ i1 = 2*i;
+ i2 = n-i1;
+ /* Separate even and odd FFTs */
+ ev.re = k1*(data[i1 ]+data[i2 ]);
+ od.im = -k2*(data[i1 ]-data[i2 ]);
+ ev.im = k1*(data[i1+1]-data[i2+1]);
+ od.re = k2*(data[i1+1]+data[i2+1]);
+ /* Apply twiddle factors to the odd FFT and add to the even FFT */
+ data[i1 ] = ev.re + od.re*tcos[i] - od.im*tsin[i];
+ data[i1+1] = ev.im + od.im*tcos[i] + od.re*tsin[i];
+ data[i2 ] = ev.re - od.re*tcos[i] + od.im*tsin[i];
+ data[i2+1] = -ev.im + od.im*tcos[i] + od.re*tsin[i];
+ }
+ data[2*i+1]=s->sign_convention*data[2*i+1];
+ if (s->inverse) {
+ data[0] *= k1;
+ data[1] *= k1;
+ ff_fft_permute(&s->fft, (FFTComplex*)data);
+ ff_fft_calc(&s->fft, (FFTComplex*)data);
+ }
+}
+
+av_cold int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans)
+{
+ int n = 1 << nbits;
+ int i;
+ const double theta = (trans == DFT_R2C || trans == DFT_C2R ? -1 : 1)*2*M_PI/n;
+
+ s->nbits = nbits;
+ s->inverse = trans == IDFT_C2R || trans == DFT_C2R;
+ s->sign_convention = trans == IDFT_R2C || trans == DFT_C2R ? 1 : -1;
+
+ if (nbits < 4 || nbits > 16)
+ return -1;
+
+ if (ff_fft_init(&s->fft, nbits-1, trans == IDFT_C2R || trans == IDFT_R2C) < 0)
+ return -1;
+
+ ff_init_ff_cos_tabs(nbits);
+ s->tcos = ff_cos_tabs[nbits];
+ s->tsin = ff_sin_tabs[nbits]+(trans == DFT_R2C || trans == DFT_C2R)*(n>>2);
+#if !CONFIG_HARDCODED_TABLES
+ for (i = 0; i < (n>>2); i++) {
+ s->tsin[i] = sin(i*theta);
+ }
+#endif
+ s->rdft_calc = ff_rdft_calc_c;
+
+ //if (ARCH_ARM) ff_rdft_init_arm(s);
+
+ return 0;
+}
+
+av_cold void ff_rdft_end(RDFTContext *s)
+{
+ ff_fft_end(&s->fft);
+}
diff --git a/apps/codecs/libwmavoice/utils.c b/apps/codecs/libwmavoice/utils.c
new file mode 100644
index 0000000..ad098f4
--- /dev/null
+++ b/apps/codecs/libwmavoice/utils.c
@@ -0,0 +1,1188 @@
+/*
+ * utils for libavcodec
+ * Copyright (c) 2001 Fabrice Bellard
+ * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * utils.
+ */
+
+//#include "libavutil/avstring.h"
+//#include "libavutil/integer.h"
+//#include "libavutil/crc.h"
+//#include "libavutil/pixdesc.h"
+//#include "libavcore/imgutils.h"
+#include "avcodec.h"
+//#include "dsputil.h"
+//#include "opt.h"
+//#include "imgconvert.h"
+//#include "audioconvert.h"
+#include "internal.h"
+#include <stdlib.h>
+#include <stdarg.h>
+#include <limits.h>
+#include <float.h>
+
+#if 0
+static int volatile entangled_thread_counter=0;
+int (*ff_lockmgr_cb)(void **mutex, enum AVLockOp op);
+static void *codec_mutex;
+
+void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size)
+{
+ if(min_size < *size)
+ return ptr;
+
+ *size= FFMAX(17*min_size/16 + 32, min_size);
+
+ ptr= av_realloc(ptr, *size);
+ if(!ptr) //we could set this to the unmodified min_size but this is safer if the user lost the ptr and uses NULL now
+ *size= 0;
+
+ return ptr;
+}
+
+void av_fast_malloc(void *ptr, unsigned int *size, unsigned int min_size)
+{
+ void **p = ptr;
+ if (min_size < *size)
+ return;
+ *size= FFMAX(17*min_size/16 + 32, min_size);
+ av_free(*p);
+ *p = av_malloc(*size);
+ if (!*p) *size = 0;
+}
+
+/* encoder management */
+static AVCodec *first_avcodec = NULL;
+
+AVCodec *av_codec_next(AVCodec *c){
+ if(c) return c->next;
+ else return first_avcodec;
+}
+
+void avcodec_register(AVCodec *codec)
+{
+ AVCodec **p;
+ avcodec_init();
+ p = &first_avcodec;
+ while (*p != NULL) p = &(*p)->next;
+ *p = codec;
+ codec->next = NULL;
+}
+
+#if LIBAVCODEC_VERSION_MAJOR < 53
+void register_avcodec(AVCodec *codec)
+{
+ avcodec_register(codec);
+}
+#endif
+
+unsigned avcodec_get_edge_width(void)
+{
+ return EDGE_WIDTH;
+}
+
+void avcodec_set_dimensions(AVCodecContext *s, int width, int height){
+ s->coded_width = width;
+ s->coded_height= height;
+ s->width = -((-width )>>s->lowres);
+ s->height= -((-height)>>s->lowres);
+}
+
+typedef struct InternalBuffer{
+ int last_pic_num;
+ uint8_t *base[4];
+ uint8_t *data[4];
+ int linesize[4];
+ int width, height;
+ enum PixelFormat pix_fmt;
+}InternalBuffer;
+
+#define INTERNAL_BUFFER_SIZE 32
+
+void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[4]){
+ int w_align= 1;
+ int h_align= 1;
+
+ switch(s->pix_fmt){
+ case PIX_FMT_YUV420P:
+ case PIX_FMT_YUYV422:
+ case PIX_FMT_UYVY422:
+ case PIX_FMT_YUV422P:
+ case PIX_FMT_YUV440P:
+ case PIX_FMT_YUV444P:
+ case PIX_FMT_GRAY8:
+ case PIX_FMT_GRAY16BE:
+ case PIX_FMT_GRAY16LE:
+ case PIX_FMT_YUVJ420P:
+ case PIX_FMT_YUVJ422P:
+ case PIX_FMT_YUVJ440P:
+ case PIX_FMT_YUVJ444P:
+ case PIX_FMT_YUVA420P:
+ w_align= 16; //FIXME check for non mpeg style codecs and use less alignment
+ h_align= 16;
+ if(s->codec_id == CODEC_ID_MPEG2VIDEO || s->codec_id == CODEC_ID_MJPEG || s->codec_id == CODEC_ID_AMV || s->codec_id == CODEC_ID_THP)
+ h_align= 32; // interlaced is rounded up to 2 MBs
+ break;
+ case PIX_FMT_YUV411P:
+ case PIX_FMT_UYYVYY411:
+ w_align=32;
+ h_align=8;
+ break;
+ case PIX_FMT_YUV410P:
+ if(s->codec_id == CODEC_ID_SVQ1){
+ w_align=64;
+ h_align=64;
+ }
+ case PIX_FMT_RGB555:
+ if(s->codec_id == CODEC_ID_RPZA){
+ w_align=4;
+ h_align=4;
+ }
+ case PIX_FMT_PAL8:
+ case PIX_FMT_BGR8:
+ case PIX_FMT_RGB8:
+ if(s->codec_id == CODEC_ID_SMC){
+ w_align=4;
+ h_align=4;
+ }
+ break;
+ case PIX_FMT_BGR24:
+ if((s->codec_id == CODEC_ID_MSZH) || (s->codec_id == CODEC_ID_ZLIB)){
+ w_align=4;
+ h_align=4;
+ }
+ break;
+ default:
+ w_align= 1;
+ h_align= 1;
+ break;
+ }
+
+ *width = FFALIGN(*width , w_align);
+ *height= FFALIGN(*height, h_align);
+ if(s->codec_id == CODEC_ID_H264)
+ *height+=2; // some of the optimized chroma MC reads one line too much
+
+ linesize_align[0] =
+ linesize_align[1] =
+ linesize_align[2] =
+ linesize_align[3] = STRIDE_ALIGN;
+//STRIDE_ALIGN is 8 for SSE* but this does not work for SVQ1 chroma planes
+//we could change STRIDE_ALIGN to 16 for x86/sse but it would increase the
+//picture size unneccessarily in some cases. The solution here is not
+//pretty and better ideas are welcome!
+#if HAVE_MMX
+ if(s->codec_id == CODEC_ID_SVQ1 || s->codec_id == CODEC_ID_VP5 ||
+ s->codec_id == CODEC_ID_VP6 || s->codec_id == CODEC_ID_VP6F ||
+ s->codec_id == CODEC_ID_VP6A) {
+ linesize_align[0] =
+ linesize_align[1] =
+ linesize_align[2] = 16;
+ }
+#endif
+}
+
+void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){
+ int chroma_shift = av_pix_fmt_descriptors[s->pix_fmt].log2_chroma_w;
+ int linesize_align[4];
+ int align;
+ avcodec_align_dimensions2(s, width, height, linesize_align);
+ align = FFMAX(linesize_align[0], linesize_align[3]);
+ linesize_align[1] <<= chroma_shift;
+ linesize_align[2] <<= chroma_shift;
+ align = FFMAX3(align, linesize_align[1], linesize_align[2]);
+ *width=FFALIGN(*width, align);
+}
+
+#if LIBAVCODEC_VERSION_MAJOR < 53
+int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h){
+ return av_check_image_size(w, h, 0, av_log_ctx);
+}
+#endif
+
+int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
+ int i;
+ int w= s->width;
+ int h= s->height;
+ InternalBuffer *buf;
+ int *picture_number;
+
+ if(pic->data[0]!=NULL) {
+ av_log(s, AV_LOG_ERROR, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
+ return -1;
+ }
+ if(s->internal_buffer_count >= INTERNAL_BUFFER_SIZE) {
+ av_log(s, AV_LOG_ERROR, "internal_buffer_count overflow (missing release_buffer?)\n");
+ return -1;
+ }
+
+ if(av_check_image_size(w, h, 0, s))
+ return -1;
+
+ if(s->internal_buffer==NULL){
+ s->internal_buffer= av_mallocz((INTERNAL_BUFFER_SIZE+1)*sizeof(InternalBuffer));
+ }
+#if 0
+ s->internal_buffer= av_fast_realloc(
+ s->internal_buffer,
+ &s->internal_buffer_size,
+ sizeof(InternalBuffer)*FFMAX(99, s->internal_buffer_count+1)/*FIXME*/
+ );
+#endif
+
+ buf= &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
+ picture_number= &(((InternalBuffer*)s->internal_buffer)[INTERNAL_BUFFER_SIZE]).last_pic_num; //FIXME ugly hack
+ (*picture_number)++;
+
+ if(buf->base[0] && (buf->width != w || buf->height != h || buf->pix_fmt != s->pix_fmt)){
+ for(i=0; i<4; i++){
+ av_freep(&buf->base[i]);
+ buf->data[i]= NULL;
+ }
+ }
+
+ if(buf->base[0]){
+ pic->age= *picture_number - buf->last_pic_num;
+ buf->last_pic_num= *picture_number;
+ }else{
+ int h_chroma_shift, v_chroma_shift;
+ int size[4] = {0};
+ int tmpsize;
+ int unaligned;
+ AVPicture picture;
+ int stride_align[4];
+
+ avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
+
+ avcodec_align_dimensions2(s, &w, &h, stride_align);
+
+ if(!(s->flags&CODEC_FLAG_EMU_EDGE)){
+ w+= EDGE_WIDTH*2;
+ h+= EDGE_WIDTH*2;
+ }
+
+ do {
+ // NOTE: do not align linesizes individually, this breaks e.g. assumptions
+ // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
+ av_fill_image_linesizes(picture.linesize, s->pix_fmt, w);
+ // increase alignment of w for next try (rhs gives the lowest bit set in w)
+ w += w & ~(w-1);
+
+ unaligned = 0;
+ for (i=0; i<4; i++){
+ unaligned |= picture.linesize[i] % stride_align[i];
+ }
+ } while (unaligned);
+
+ tmpsize = av_fill_image_pointers(picture.data, s->pix_fmt, h, NULL, picture.linesize);
+ if (tmpsize < 0)
+ return -1;
+
+ for (i=0; i<3 && picture.data[i+1]; i++)
+ size[i] = picture.data[i+1] - picture.data[i];
+ size[i] = tmpsize - (picture.data[i] - picture.data[0]);
+
+ buf->last_pic_num= -256*256*256*64;
+ memset(buf->base, 0, sizeof(buf->base));
+ memset(buf->data, 0, sizeof(buf->data));
+
+ for(i=0; i<4 && size[i]; i++){
+ const int h_shift= i==0 ? 0 : h_chroma_shift;
+ const int v_shift= i==0 ? 0 : v_chroma_shift;
+
+ buf->linesize[i]= picture.linesize[i];
+
+ buf->base[i]= av_malloc(size[i]+16); //FIXME 16
+ if(buf->base[i]==NULL) return -1;
+ memset(buf->base[i], 128, size[i]);
+
+ // no edge if EDGE EMU or not planar YUV
+ if((s->flags&CODEC_FLAG_EMU_EDGE) || !size[2])
+ buf->data[i] = buf->base[i];
+ else
+ buf->data[i] = buf->base[i] + FFALIGN((buf->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift), stride_align[i]);
+ }
+ if(size[1] && !size[2])
+ ff_set_systematic_pal((uint32_t*)buf->data[1], s->pix_fmt);
+ buf->width = s->width;
+ buf->height = s->height;
+ buf->pix_fmt= s->pix_fmt;
+ pic->age= 256*256*256*64;
+ }
+ pic->type= FF_BUFFER_TYPE_INTERNAL;
+
+ for(i=0; i<4; i++){
+ pic->base[i]= buf->base[i];
+ pic->data[i]= buf->data[i];
+ pic->linesize[i]= buf->linesize[i];
+ }
+ s->internal_buffer_count++;
+
+ pic->reordered_opaque= s->reordered_opaque;
+
+ if(s->debug&FF_DEBUG_BUFFERS)
+ av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p, %d buffers used\n", pic, s->internal_buffer_count);
+
+ return 0;
+}
+
+void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
+ int i;
+ InternalBuffer *buf, *last;
+
+ assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
+ assert(s->internal_buffer_count);
+
+ buf = NULL; /* avoids warning */
+ for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize
+ buf= &((InternalBuffer*)s->internal_buffer)[i];
+ if(buf->data[0] == pic->data[0])
+ break;
+ }
+ assert(i < s->internal_buffer_count);
+ s->internal_buffer_count--;
+ last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
+
+ FFSWAP(InternalBuffer, *buf, *last);
+
+ for(i=0; i<4; i++){
+ pic->data[i]=NULL;
+// pic->base[i]=NULL;
+ }
+//printf("R%X\n", pic->opaque);
+
+ if(s->debug&FF_DEBUG_BUFFERS)
+ av_log(s, AV_LOG_DEBUG, "default_release_buffer called on pic %p, %d buffers used\n", pic, s->internal_buffer_count);
+}
+
+int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic){
+ AVFrame temp_pic;
+ int i;
+
+ /* If no picture return a new buffer */
+ if(pic->data[0] == NULL) {
+ /* We will copy from buffer, so must be readable */
+ pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;
+ return s->get_buffer(s, pic);
+ }
+
+ /* If internal buffer type return the same buffer */
+ if(pic->type == FF_BUFFER_TYPE_INTERNAL) {
+ pic->reordered_opaque= s->reordered_opaque;
+ return 0;
+ }
+
+ /*
+ * Not internal type and reget_buffer not overridden, emulate cr buffer
+ */
+ temp_pic = *pic;
+ for(i = 0; i < 4; i++)
+ pic->data[i] = pic->base[i] = NULL;
+ pic->opaque = NULL;
+ /* Allocate new frame */
+ if (s->get_buffer(s, pic))
+ return -1;
+ /* Copy image data from old buffer to new buffer */
+ av_picture_copy((AVPicture*)pic, (AVPicture*)&temp_pic, s->pix_fmt, s->width,
+ s->height);
+ s->release_buffer(s, &temp_pic); // Release old frame
+ return 0;
+}
+
+int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size){
+ int i;
+
+ for(i=0; i<count; i++){
+ int r= func(c, (char*)arg + i*size);
+ if(ret) ret[i]= r;
+ }
+ return 0;
+}
+
+int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr),void *arg, int *ret, int count){
+ int i;
+
+ for(i=0; i<count; i++){
+ int r= func(c, arg, i, 0);
+ if(ret) ret[i]= r;
+ }
+ return 0;
+}
+
+enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat *fmt){
+ while (*fmt != PIX_FMT_NONE && ff_is_hwaccel_pix_fmt(*fmt))
+ ++fmt;
+ return fmt[0];
+}
+
+void avcodec_get_frame_defaults(AVFrame *pic){
+ memset(pic, 0, sizeof(AVFrame));
+
+ pic->pts= AV_NOPTS_VALUE;
+ pic->key_frame= 1;
+}
+
+AVFrame *avcodec_alloc_frame(void){
+ AVFrame *pic= av_malloc(sizeof(AVFrame));
+
+ if(pic==NULL) return NULL;
+
+ avcodec_get_frame_defaults(pic);
+
+ return pic;
+}
+
+int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
+{
+ int ret= -1;
+
+ /* If there is a user-supplied mutex locking routine, call it. */
+ if (ff_lockmgr_cb) {
+ if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
+ return -1;
+ }
+
+ entangled_thread_counter++;
+ if(entangled_thread_counter != 1){
+ av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
+ goto end;
+ }
+
+ if(avctx->codec || !codec)
+ goto end;
+
+ if (codec->priv_data_size > 0) {
+ avctx->priv_data = av_mallocz(codec->priv_data_size);
+ if (!avctx->priv_data) {
+ ret = AVERROR(ENOMEM);
+ goto end;
+ }
+ } else {
+ avctx->priv_data = NULL;
+ }
+
+ if(avctx->coded_width && avctx->coded_height)
+ avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
+ else if(avctx->width && avctx->height)
+ avcodec_set_dimensions(avctx, avctx->width, avctx->height);
+
+#define SANE_NB_CHANNELS 128U
+ if (((avctx->coded_width || avctx->coded_height)
+ && av_check_image_size(avctx->coded_width, avctx->coded_height, 0, avctx))
+ || avctx->channels > SANE_NB_CHANNELS) {
+ ret = AVERROR(EINVAL);
+ goto free_and_end;
+ }
+
+ avctx->codec = codec;
+ if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
+ avctx->codec_id == CODEC_ID_NONE) {
+ avctx->codec_type = codec->type;
+ avctx->codec_id = codec->id;
+ }
+ if(avctx->codec_id != codec->id || avctx->codec_type != codec->type){
+ av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
+ goto free_and_end;
+ }
+ avctx->frame_number = 0;
+ if(avctx->codec->init){
+ if(avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
+ avctx->codec->max_lowres < avctx->lowres){
+ av_log(avctx, AV_LOG_ERROR, "The maximum value for lowres supported by the decoder is %d\n",
+ avctx->codec->max_lowres);
+ goto free_and_end;
+ }
+
+ ret = avctx->codec->init(avctx);
+ if (ret < 0) {
+ goto free_and_end;
+ }
+ }
+ ret=0;
+end:
+ entangled_thread_counter--;
+
+ /* Release any user-supplied mutex. */
+ if (ff_lockmgr_cb) {
+ (*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
+ }
+ return ret;
+free_and_end:
+ av_freep(&avctx->priv_data);
+ avctx->codec= NULL;
+ goto end;
+}
+
+int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
+ const short *samples)
+{
+ if(buf_size < FF_MIN_BUFFER_SIZE && 0){
+ av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n");
+ return -1;
+ }
+ if((avctx->codec->capabilities & CODEC_CAP_DELAY) || samples){
+ int ret = avctx->codec->encode(avctx, buf, buf_size, samples);
+ avctx->frame_number++;
+ return ret;
+ }else
+ return 0;
+}
+
+int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
+ const AVFrame *pict)
+{
+ if(buf_size < FF_MIN_BUFFER_SIZE){
+ av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n");
+ return -1;
+ }
+ if(av_check_image_size(avctx->width, avctx->height, 0, avctx))
+ return -1;
+ if((avctx->codec->capabilities & CODEC_CAP_DELAY) || pict){
+ int ret = avctx->codec->encode(avctx, buf, buf_size, pict);
+ avctx->frame_number++;
+ emms_c(); //needed to avoid an emms_c() call before every return;
+
+ return ret;
+ }else
+ return 0;
+}
+
+int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
+ const AVSubtitle *sub)
+{
+ int ret;
+ if(sub->start_display_time) {
+ av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
+ return -1;
+ }
+ if(sub->num_rects == 0 || !sub->rects)
+ return -1;
+ ret = avctx->codec->encode(avctx, buf, buf_size, sub);
+ avctx->frame_number++;
+ return ret;
+}
+
+#if LIBAVCODEC_VERSION_MAJOR < 53
+int attribute_align_arg avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
+ int *got_picture_ptr,
+ const uint8_t *buf, int buf_size)
+{
+ AVPacket avpkt;
+ av_init_packet(&avpkt);
+ avpkt.data = buf;
+ avpkt.size = buf_size;
+ // HACK for CorePNG to decode as normal PNG by default
+ avpkt.flags = AV_PKT_FLAG_KEY;
+
+ return avcodec_decode_video2(avctx, picture, got_picture_ptr, &avpkt);
+}
+#endif
+
+int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
+ int *got_picture_ptr,
+ AVPacket *avpkt)
+{
+ int ret;
+
+ *got_picture_ptr= 0;
+ if((avctx->coded_width||avctx->coded_height) && av_check_image_size(avctx->coded_width, avctx->coded_height, 0, avctx))
+ return -1;
+ if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size){
+ ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
+ avpkt);
+
+ emms_c(); //needed to avoid an emms_c() call before every return;
+
+ if (*got_picture_ptr)
+ avctx->frame_number++;
+ }else
+ ret= 0;
+
+ return ret;
+}
+
+#if LIBAVCODEC_VERSION_MAJOR < 53
+int attribute_align_arg avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
+ int *frame_size_ptr,
+ const uint8_t *buf, int buf_size)
+{
+ AVPacket avpkt;
+ av_init_packet(&avpkt);
+ avpkt.data = buf;
+ avpkt.size = buf_size;
+
+ return avcodec_decode_audio3(avctx, samples, frame_size_ptr, &avpkt);
+}
+#endif
+
+int attribute_align_arg avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
+ int *frame_size_ptr,
+ AVPacket *avpkt)
+{
+ int ret;
+
+ if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size){
+ //FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
+ if(*frame_size_ptr < AVCODEC_MAX_AUDIO_FRAME_SIZE){
+ av_log(avctx, AV_LOG_ERROR, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");
+ return -1;
+ }
+ if(*frame_size_ptr < FF_MIN_BUFFER_SIZE ||
+ *frame_size_ptr < avctx->channels * avctx->frame_size * sizeof(int16_t)){
+ av_log(avctx, AV_LOG_ERROR, "buffer %d too small\n", *frame_size_ptr);
+ return -1;
+ }
+
+ ret = avctx->codec->decode(avctx, samples, frame_size_ptr, avpkt);
+ avctx->frame_number++;
+ }else{
+ ret= 0;
+ *frame_size_ptr=0;
+ }
+ return ret;
+}
+
+#if LIBAVCODEC_VERSION_MAJOR < 53
+int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub,
+ int *got_sub_ptr,
+ const uint8_t *buf, int buf_size)
+{
+ AVPacket avpkt;
+ av_init_packet(&avpkt);
+ avpkt.data = buf;
+ avpkt.size = buf_size;
+
+ return avcodec_decode_subtitle2(avctx, sub, got_sub_ptr, &avpkt);
+}
+#endif
+
+int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
+ int *got_sub_ptr,
+ AVPacket *avpkt)
+{
+ int ret;
+
+ *got_sub_ptr = 0;
+ ret = avctx->codec->decode(avctx, sub, got_sub_ptr, avpkt);
+ if (*got_sub_ptr)
+ avctx->frame_number++;
+ return ret;
+}
+
+void avsubtitle_free(AVSubtitle *sub)
+{
+ int i;
+
+ for (i = 0; i < sub->num_rects; i++)
+ {
+ av_freep(&sub->rects[i]->pict.data[0]);
+ av_freep(&sub->rects[i]->pict.data[1]);
+ av_freep(&sub->rects[i]->pict.data[2]);
+ av_freep(&sub->rects[i]->pict.data[3]);
+ av_freep(&sub->rects[i]->text);
+ av_freep(&sub->rects[i]->ass);
+ av_freep(&sub->rects[i]);
+ }
+
+ av_freep(&sub->rects);
+
+ memset(sub, 0, sizeof(AVSubtitle));
+}
+
+av_cold int avcodec_close(AVCodecContext *avctx)
+{
+ /* If there is a user-supplied mutex locking routine, call it. */
+ if (ff_lockmgr_cb) {
+ if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
+ return -1;
+ }
+
+ entangled_thread_counter++;
+ if(entangled_thread_counter != 1){
+ av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
+ entangled_thread_counter--;
+ return -1;
+ }
+
+ if (HAVE_THREADS && avctx->thread_opaque)
+ avcodec_thread_free(avctx);
+ if (avctx->codec && avctx->codec->close)
+ avctx->codec->close(avctx);
+ avcodec_default_free_buffers(avctx);
+ avctx->coded_frame = NULL;
+ av_freep(&avctx->priv_data);
+ if(avctx->codec && avctx->codec->encode)
+ av_freep(&avctx->extradata);
+ avctx->codec = NULL;
+ entangled_thread_counter--;
+
+ /* Release any user-supplied mutex. */
+ if (ff_lockmgr_cb) {
+ (*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
+ }
+ return 0;
+}
+
+AVCodec *avcodec_find_encoder(enum CodecID id)
+{
+ AVCodec *p, *experimental=NULL;
+ p = first_avcodec;
+ while (p) {
+ if (p->encode != NULL && p->id == id) {
+ if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
+ experimental = p;
+ } else
+ return p;
+ }
+ p = p->next;
+ }
+ return experimental;
+}
+
+AVCodec *avcodec_find_encoder_by_name(const char *name)
+{
+ AVCodec *p;
+ if (!name)
+ return NULL;
+ p = first_avcodec;
+ while (p) {
+ if (p->encode != NULL && strcmp(name,p->name) == 0)
+ return p;
+ p = p->next;
+ }
+ return NULL;
+}
+
+AVCodec *avcodec_find_decoder(enum CodecID id)
+{
+ AVCodec *p;
+ p = first_avcodec;
+ while (p) {
+ if (p->decode != NULL && p->id == id)
+ return p;
+ p = p->next;
+ }
+ return NULL;
+}
+
+AVCodec *avcodec_find_decoder_by_name(const char *name)
+{
+ AVCodec *p;
+ if (!name)
+ return NULL;
+ p = first_avcodec;
+ while (p) {
+ if (p->decode != NULL && strcmp(name,p->name) == 0)
+ return p;
+ p = p->next;
+ }
+ return NULL;
+}
+
+static int get_bit_rate(AVCodecContext *ctx)
+{
+ int bit_rate;
+ int bits_per_sample;
+
+ switch(ctx->codec_type) {
+ case AVMEDIA_TYPE_VIDEO:
+ case AVMEDIA_TYPE_DATA:
+ case AVMEDIA_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_ATTACHMENT:
+ bit_rate = ctx->bit_rate;
+ break;
+ case AVMEDIA_TYPE_AUDIO:
+ bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
+ bit_rate = bits_per_sample ? ctx->sample_rate * ctx->channels * bits_per_sample : ctx->bit_rate;
+ break;
+ default:
+ bit_rate = 0;
+ break;
+ }
+ return bit_rate;
+}
+
+size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
+{
+ int i, len, ret = 0;
+
+ for (i = 0; i < 4; i++) {
+ len = snprintf(buf, buf_size,
+ isprint(codec_tag&0xFF) ? "%c" : "[%d]", codec_tag&0xFF);
+ buf += len;
+ buf_size = buf_size > len ? buf_size - len : 0;
+ ret += len;
+ codec_tag>>=8;
+ }
+ return ret;
+}
+
+void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
+{
+ const char *codec_name;
+ AVCodec *p;
+ char buf1[32];
+ int bitrate;
+ AVRational display_aspect_ratio;
+
+ if (encode)
+ p = avcodec_find_encoder(enc->codec_id);
+ else
+ p = avcodec_find_decoder(enc->codec_id);
+
+ if (p) {
+ codec_name = p->name;
+ } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
+ /* fake mpeg2 transport stream codec (currently not
+ registered) */
+ codec_name = "mpeg2ts";
+ } else if (enc->codec_name[0] != '\0') {
+ codec_name = enc->codec_name;
+ } else {
+ /* output avi tags */
+ char tag_buf[32];
+ av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
+ snprintf(buf1, sizeof(buf1), "%s / 0x%04X", tag_buf, enc->codec_tag);
+ codec_name = buf1;
+ }
+
+ switch(enc->codec_type) {
+ case AVMEDIA_TYPE_VIDEO:
+ snprintf(buf, buf_size,
+ "Video: %s%s",
+ codec_name, enc->mb_decision ? " (hq)" : "");
+ if (enc->pix_fmt != PIX_FMT_NONE) {
+ snprintf(buf + strlen(buf), buf_size - strlen(buf),
+ ", %s",
+ avcodec_get_pix_fmt_name(enc->pix_fmt));
+ }
+ if (enc->width) {
+ snprintf(buf + strlen(buf), buf_size - strlen(buf),
+ ", %dx%d",
+ enc->width, enc->height);
+ if (enc->sample_aspect_ratio.num) {
+ av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
+ enc->width*enc->sample_aspect_ratio.num,
+ enc->height*enc->sample_aspect_ratio.den,
+ 1024*1024);
+ snprintf(buf + strlen(buf), buf_size - strlen(buf),
+ " [PAR %d:%d DAR %d:%d]",
+ enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
+ display_aspect_ratio.num, display_aspect_ratio.den);
+ }
+ if(av_log_get_level() >= AV_LOG_DEBUG){
+ int g= av_gcd(enc->time_base.num, enc->time_base.den);
+ snprintf(buf + strlen(buf), buf_size - strlen(buf),
+ ", %d/%d",
+ enc->time_base.num/g, enc->time_base.den/g);
+ }
+ }
+ if (encode) {
+ snprintf(buf + strlen(buf), buf_size - strlen(buf),
+ ", q=%d-%d", enc->qmin, enc->qmax);
+ }
+ break;
+ case AVMEDIA_TYPE_AUDIO:
+ snprintf(buf, buf_size,
+ "Audio: %s",
+ codec_name);
+ if (enc->sample_rate) {
+ snprintf(buf + strlen(buf), buf_size - strlen(buf),
+ ", %d Hz", enc->sample_rate);
+ }
+ av_strlcat(buf, ", ", buf_size);
+ avcodec_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
+ if (enc->sample_fmt != SAMPLE_FMT_NONE) {
+ snprintf(buf + strlen(buf), buf_size - strlen(buf),
+ ", %s", avcodec_get_sample_fmt_name(enc->sample_fmt));
+ }
+ break;
+ case AVMEDIA_TYPE_DATA:
+ snprintf(buf, buf_size, "Data: %s", codec_name);
+ break;
+ case AVMEDIA_TYPE_SUBTITLE:
+ snprintf(buf, buf_size, "Subtitle: %s", codec_name);
+ break;
+ case AVMEDIA_TYPE_ATTACHMENT:
+ snprintf(buf, buf_size, "Attachment: %s", codec_name);
+ break;
+ default:
+ snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
+ return;
+ }
+ if (encode) {
+ if (enc->flags & CODEC_FLAG_PASS1)
+ snprintf(buf + strlen(buf), buf_size - strlen(buf),
+ ", pass 1");
+ if (enc->flags & CODEC_FLAG_PASS2)
+ snprintf(buf + strlen(buf), buf_size - strlen(buf),
+ ", pass 2");
+ }
+ bitrate = get_bit_rate(enc);
+ if (bitrate != 0) {
+ snprintf(buf + strlen(buf), buf_size - strlen(buf),
+ ", %d kb/s", bitrate / 1000);
+ }
+}
+
+unsigned avcodec_version( void )
+{
+ return LIBAVCODEC_VERSION_INT;
+}
+
+const char *avcodec_configuration(void)
+{
+ return FFMPEG_CONFIGURATION;
+}
+
+const char *avcodec_license(void)
+{
+#define LICENSE_PREFIX "libavcodec license: "
+ return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
+}
+
+void avcodec_init(void)
+{
+ static int initialized = 0;
+
+ if (initialized != 0)
+ return;
+ initialized = 1;
+
+ dsputil_static_init();
+}
+
+void avcodec_flush_buffers(AVCodecContext *avctx)
+{
+ if(avctx->codec->flush)
+ avctx->codec->flush(avctx);
+}
+
+void avcodec_default_free_buffers(AVCodecContext *s){
+ int i, j;
+
+ if(s->internal_buffer==NULL) return;
+
+ if (s->internal_buffer_count)
+ av_log(s, AV_LOG_WARNING, "Found %i unreleased buffers!\n", s->internal_buffer_count);
+ for(i=0; i<INTERNAL_BUFFER_SIZE; i++){
+ InternalBuffer *buf= &((InternalBuffer*)s->internal_buffer)[i];
+ for(j=0; j<4; j++){
+ av_freep(&buf->base[j]);
+ buf->data[j]= NULL;
+ }
+ }
+ av_freep(&s->internal_buffer);
+
+ s->internal_buffer_count=0;
+}
+
+char av_get_pict_type_char(int pict_type){
+ switch(pict_type){
+ case FF_I_TYPE: return 'I';
+ case FF_P_TYPE: return 'P';
+ case FF_B_TYPE: return 'B';
+ case FF_S_TYPE: return 'S';
+ case FF_SI_TYPE:return 'i';
+ case FF_SP_TYPE:return 'p';
+ case FF_BI_TYPE:return 'b';
+ default: return '?';
+ }
+}
+
+int av_get_bits_per_sample(enum CodecID codec_id){
+ switch(codec_id){
+ case CODEC_ID_ADPCM_SBPRO_2:
+ return 2;
+ case CODEC_ID_ADPCM_SBPRO_3:
+ return 3;
+ case CODEC_ID_ADPCM_SBPRO_4:
+ case CODEC_ID_ADPCM_CT:
+ case CODEC_ID_ADPCM_IMA_WAV:
+ case CODEC_ID_ADPCM_MS:
+ case CODEC_ID_ADPCM_YAMAHA:
+ return 4;
+ case CODEC_ID_PCM_ALAW:
+ case CODEC_ID_PCM_MULAW:
+ case CODEC_ID_PCM_S8:
+ case CODEC_ID_PCM_U8:
+ case CODEC_ID_PCM_ZORK:
+ return 8;
+ case CODEC_ID_PCM_S16BE:
+ case CODEC_ID_PCM_S16LE:
+ case CODEC_ID_PCM_S16LE_PLANAR:
+ case CODEC_ID_PCM_U16BE:
+ case CODEC_ID_PCM_U16LE:
+ return 16;
+ case CODEC_ID_PCM_S24DAUD:
+ case CODEC_ID_PCM_S24BE:
+ case CODEC_ID_PCM_S24LE:
+ case CODEC_ID_PCM_U24BE:
+ case CODEC_ID_PCM_U24LE:
+ return 24;
+ case CODEC_ID_PCM_S32BE:
+ case CODEC_ID_PCM_S32LE:
+ case CODEC_ID_PCM_U32BE:
+ case CODEC_ID_PCM_U32LE:
+ case CODEC_ID_PCM_F32BE:
+ case CODEC_ID_PCM_F32LE:
+ return 32;
+ case CODEC_ID_PCM_F64BE:
+ case CODEC_ID_PCM_F64LE:
+ return 64;
+ default:
+ return 0;
+ }
+}
+
+int av_get_bits_per_sample_format(enum SampleFormat sample_fmt) {
+ switch (sample_fmt) {
+ case SAMPLE_FMT_U8:
+ return 8;
+ case SAMPLE_FMT_S16:
+ return 16;
+ case SAMPLE_FMT_S32:
+ case SAMPLE_FMT_FLT:
+ return 32;
+ case SAMPLE_FMT_DBL:
+ return 64;
+ default:
+ return 0;
+ }
+}
+
+#if !HAVE_THREADS
+int avcodec_thread_init(AVCodecContext *s, int thread_count){
+ s->thread_count = thread_count;
+ return -1;
+}
+#endif
+
+unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
+{
+ unsigned int n = 0;
+
+ while(v >= 0xff) {
+ *s++ = 0xff;
+ v -= 0xff;
+ n++;
+ }
+ *s = v;
+ n++;
+ return n;
+}
+
+#if LIBAVCODEC_VERSION_MAJOR < 53
+#include "libavcore/parseutils.h"
+
+int av_parse_video_frame_size(int *width_ptr, int *height_ptr, const char *str)
+{
+ return av_parse_video_size(width_ptr, height_ptr, str);
+}
+
+int av_parse_video_frame_rate(AVRational *frame_rate, const char *arg)
+{
+ return av_parse_video_rate(frame_rate, arg);
+}
+#endif
+
+int ff_match_2uint16(const uint16_t (*tab)[2], int size, int a, int b){
+ int i;
+ for(i=0; i<size && !(tab[i][0]==a && tab[i][1]==b); i++);
+ return i;
+}
+#endif
+
+void av_log_missing_feature(void *avc, const char *feature, int want_sample)
+{
+ av_log(avc, AV_LOG_WARNING, "%s not implemented. Update your FFmpeg "
+ "version to the newest one from SVN. If the problem still "
+ "occurs, it means that your file has a feature which has not "
+ "been implemented.", feature);
+ if(want_sample)
+ av_log_ask_for_sample(avc, NULL);
+ else
+ av_log(avc, AV_LOG_WARNING, "\n");
+}
+
+void av_log_ask_for_sample(void *avc, const char *msg)
+{
+ if (msg)
+ av_log(avc, AV_LOG_WARNING, "%s ", msg);
+ av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
+ "of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
+ "and contact the ffmpeg-devel mailing list.\n");
+}
+#if 0
+static AVHWAccel *first_hwaccel = NULL;
+
+void av_register_hwaccel(AVHWAccel *hwaccel)
+{
+ AVHWAccel **p = &first_hwaccel;
+ while (*p)
+ p = &(*p)->next;
+ *p = hwaccel;
+ hwaccel->next = NULL;
+}
+
+AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel)
+{
+ return hwaccel ? hwaccel->next : first_hwaccel;
+}
+
+AVHWAccel *ff_find_hwaccel(enum CodecID codec_id, enum PixelFormat pix_fmt)
+{
+ AVHWAccel *hwaccel=NULL;
+
+ while((hwaccel= av_hwaccel_next(hwaccel))){
+ if ( hwaccel->id == codec_id
+ && hwaccel->pix_fmt == pix_fmt)
+ return hwaccel;
+ }
+ return NULL;
+}
+
+int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
+{
+ if (ff_lockmgr_cb) {
+ if (ff_lockmgr_cb(&codec_mutex, AV_LOCK_DESTROY))
+ return -1;
+ }
+
+ ff_lockmgr_cb = cb;
+
+ if (ff_lockmgr_cb) {
+ if (ff_lockmgr_cb(&codec_mutex, AV_LOCK_CREATE))
+ return -1;
+ }
+ return 0;
+}
+
+unsigned int ff_toupper4(unsigned int x)
+{
+ return toupper( x &0xFF)
+ + (toupper((x>>8 )&0xFF)<<8 )
+ + (toupper((x>>16)&0xFF)<<16)
+ + (toupper((x>>24)&0xFF)<<24);
+}
+#endif
diff --git a/apps/codecs/libwmavoice/wmavoice.c b/apps/codecs/libwmavoice/wmavoice.c
index c4582f3..39bcb0e 100644
--- a/apps/codecs/libwmavoice/wmavoice.c
+++ b/apps/codecs/libwmavoice/wmavoice.c
@@ -2015,7 +2015,7 @@ static av_cold void wmavoice_flush(AVCodecContext *ctx)
memset(s->denoise_filter_cache, 0, sizeof(s->denoise_filter_cache));
}
}
-
+#if 0
AVCodec wmavoice_decoder = {
"wmavoice",
AVMEDIA_TYPE_AUDIO,
@@ -2029,3 +2029,9 @@ AVCodec wmavoice_decoder = {
.flush = wmavoice_flush,
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Voice"),
};
+#endif
+
+int main(void)
+{
+ return 0;
+}
generated by cgit v1.1 at 2026-04-26 02:58:09 +0000