lib cleanup and sync for mips vu support

libeplayer3/external/ffmpeg/get_bits.h

@@ -0,0 +1,552 @@
+/*
+ * copyright (c) 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
+ * bitstream reader API header.
+ */
+
+#ifndef AVCODEC_GET_BITS_H
+#define AVCODEC_GET_BITS_H
+
+#include <stdint.h>
+#include <limits.h>
+#include <libavutil/common.h>
+#include <libavutil/error.h>
+#include <libavutil/intreadwrite.h>
+#include <libavutil/attributes.h>
+
+#include "mathops.h"
+
+typedef struct GetBitContext
+{
+	const uint8_t *buffer, *buffer_end;
+	int index;
+	int size_in_bits;
+	int size_in_bits_plus8;
+} GetBitContext;
+
+/* Bitstream reader API docs:
+ * name
+ *   arbitrary name which is used as prefix for the internal variables
+ *
+ * gb
+ *   getbitcontext
+ *
+ * OPEN_READER(name, gb)
+ *   load gb into local variables
+ *
+ * CLOSE_READER(name, gb)
+ *   store local vars in gb
+ *
+ * UPDATE_CACHE(name, gb)
+ *   Refill the internal cache from the bitstream.
+ *   After this call at least MIN_CACHE_BITS will be available.
+ *
+ * GET_CACHE(name, gb)
+ *   Will output the contents of the internal cache,
+ *   next bit is MSB of 32 or 64 bits (FIXME 64 bits).
+ *
+ * SHOW_UBITS(name, gb, num)
+ *   Will return the next num bits.
+ *
+ * SHOW_SBITS(name, gb, num)
+ *   Will return the next num bits and do sign extension.
+ *
+ * SKIP_BITS(name, gb, num)
+ *   Will skip over the next num bits.
+ *   Note, this is equivalent to SKIP_CACHE; SKIP_COUNTER.
+ *
+ * SKIP_CACHE(name, gb, num)
+ *   Will remove the next num bits from the cache (note SKIP_COUNTER
+ *   MUST be called before UPDATE_CACHE / CLOSE_READER).
+ *
+ * SKIP_COUNTER(name, gb, num)
+ *   Will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS).
+ *
+ * LAST_SKIP_BITS(name, gb, num)
+ *   Like SKIP_BITS, to be used if next call is UPDATE_CACHE or CLOSE_READER.
+ *
+ * BITS_LEFT(name, gb)
+ *   Return the number of bits left
+ *
+ * For examples see get_bits, show_bits, skip_bits, get_vlc.
+ */
+
+#ifdef LONG_BITSTREAM_READER
+#   define MIN_CACHE_BITS 32
+#else
+#   define MIN_CACHE_BITS 25
+#endif
+
+#define OPEN_READER_NOSIZE(name, gb)            \
+    unsigned int name ## _index = (gb)->index;  \
+    unsigned int av_unused name ## _cache
+
+
+#define OPEN_READER(name, gb) OPEN_READER_NOSIZE(name, gb)
+#define BITS_AVAILABLE(name, gb) 1
+
+
+#define CLOSE_READER(name, gb) (gb)->index = name ## _index
+
+# ifdef LONG_BITSTREAM_READER
+
+# define UPDATE_CACHE_LE(name, gb) name ## _cache = \
+      AV_RL64((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)
+
+# define UPDATE_CACHE_BE(name, gb) name ## _cache = \
+      AV_RB64((gb)->buffer + (name ## _index >> 3)) >> (32 - (name ## _index & 7))
+
+#else
+
+# define UPDATE_CACHE_LE(name, gb) name ## _cache = \
+      AV_RL32((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)
+
+# define UPDATE_CACHE_BE(name, gb) name ## _cache = \
+      AV_RB32((gb)->buffer + (name ## _index >> 3)) << (name ## _index & 7)
+
+#endif
+
+
+#ifdef BITSTREAM_READER_LE
+
+# define UPDATE_CACHE(name, gb) UPDATE_CACHE_LE(name, gb)
+
+# define SKIP_CACHE(name, gb, num) name ## _cache >>= (num)
+
+#else
+
+# define UPDATE_CACHE(name, gb) UPDATE_CACHE_BE(name, gb)
+
+# define SKIP_CACHE(name, gb, num) name ## _cache <<= (num)
+
+#endif
+
+#define SKIP_COUNTER(name, gb, num) name ## _index += (num)
+
+
+#define BITS_LEFT(name, gb) ((int)((gb)->size_in_bits - name ## _index))
+
+#define SKIP_BITS(name, gb, num)                \
+    do {                                        \
+        SKIP_CACHE(name, gb, num);              \
+        SKIP_COUNTER(name, gb, num);            \
+    } while (0)
+
+#define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
+
+#define SHOW_UBITS_LE(name, gb, num) zero_extend(name ## _cache, num)
+#define SHOW_SBITS_LE(name, gb, num) sign_extend(name ## _cache, num)
+
+#define SHOW_UBITS_BE(name, gb, num) NEG_USR32(name ## _cache, num)
+#define SHOW_SBITS_BE(name, gb, num) NEG_SSR32(name ## _cache, num)
+
+#ifdef BITSTREAM_READER_LE
+#   define SHOW_UBITS(name, gb, num) SHOW_UBITS_LE(name, gb, num)
+#   define SHOW_SBITS(name, gb, num) SHOW_SBITS_LE(name, gb, num)
+#else
+#   define SHOW_UBITS(name, gb, num) SHOW_UBITS_BE(name, gb, num)
+#   define SHOW_SBITS(name, gb, num) SHOW_SBITS_BE(name, gb, num)
+#endif
+
+#define GET_CACHE(name, gb) ((uint32_t) name ## _cache)
+
+static inline int get_bits_count(const GetBitContext *s)
+{
+	return s->index;
+}
+
+static inline void skip_bits_long(GetBitContext *s, int n)
+{
+	s->index += n;
+}
+
+/**
+ * Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
+ * if MSB not set it is negative
+ * @param n length in bits
+ */
+static inline int get_xbits(GetBitContext *s, int n)
+{
+	register int sign;
+	register int32_t cache;
+	OPEN_READER(re, s);
+	UPDATE_CACHE(re, s);
+	cache = GET_CACHE(re, s);
+	sign  = ~cache >> 31;
+	LAST_SKIP_BITS(re, s, n);
+	CLOSE_READER(re, s);
+	return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
+}
+
+static inline int get_xbits_le(GetBitContext *s, int n)
+{
+	register int sign;
+	register int32_t cache;
+	OPEN_READER(re, s);
+	UPDATE_CACHE_LE(re, s);
+	cache = GET_CACHE(re, s);
+	sign  = sign_extend(~cache, n) >> 31;
+	LAST_SKIP_BITS(re, s, n);
+	CLOSE_READER(re, s);
+	return (zero_extend(sign ^ cache, n) ^ sign) - sign;
+}
+
+static inline int get_sbits(GetBitContext *s, int n)
+{
+	register int tmp;
+	OPEN_READER(re, s);
+	UPDATE_CACHE(re, s);
+	tmp = SHOW_SBITS(re, s, n);
+	LAST_SKIP_BITS(re, s, n);
+	CLOSE_READER(re, s);
+	return tmp;
+}
+
+/**
+ * Read 1-25 bits.
+ */
+static inline unsigned int get_bits(GetBitContext *s, int n)
+{
+	register int tmp;
+	OPEN_READER(re, s);
+	UPDATE_CACHE(re, s);
+	tmp = SHOW_UBITS(re, s, n);
+	LAST_SKIP_BITS(re, s, n);
+	CLOSE_READER(re, s);
+	return tmp;
+}
+
+/**
+ * Read 0-25 bits.
+ */
+static inline int get_bitsz(GetBitContext *s, int n)
+{
+	return n ? get_bits(s, n) : 0;
+}
+
+static inline unsigned int get_bits_le(GetBitContext *s, int n)
+{
+	register int tmp;
+	OPEN_READER(re, s);
+	UPDATE_CACHE_LE(re, s);
+	tmp = SHOW_UBITS_LE(re, s, n);
+	LAST_SKIP_BITS(re, s, n);
+	CLOSE_READER(re, s);
+	return tmp;
+}
+
+/**
+ * Show 1-25 bits.
+ */
+static inline unsigned int show_bits(GetBitContext *s, int n)
+{
+	register int tmp;
+	OPEN_READER_NOSIZE(re, s);
+	UPDATE_CACHE(re, s);
+	tmp = SHOW_UBITS(re, s, n);
+	return tmp;
+}
+
+static inline void skip_bits(GetBitContext *s, int n)
+{
+	OPEN_READER(re, s);
+	LAST_SKIP_BITS(re, s, n);
+	CLOSE_READER(re, s);
+}
+
+static inline unsigned int get_bits1(GetBitContext *s)
+{
+	unsigned int index = s->index;
+	uint8_t result     = s->buffer[index >> 3];
+#ifdef BITSTREAM_READER_LE
+	result >>= index & 7;
+	result  &= 1;
+#else
+	result <<= index & 7;
+	result >>= 8 - 1;
+#endif
+	index++;
+	s->index = index;
+
+	return result;
+}
+
+static inline unsigned int show_bits1(GetBitContext *s)
+{
+	return show_bits(s, 1);
+}
+
+static inline void skip_bits1(GetBitContext *s)
+{
+	skip_bits(s, 1);
+}
+
+/**
+ * Read 0-32 bits.
+ */
+static inline unsigned int get_bits_long(GetBitContext *s, int n)
+{
+	if (!n)
+	{
+		return 0;
+	}
+	else if (n <= MIN_CACHE_BITS)
+	{
+		return get_bits(s, n);
+	}
+	else
+	{
+#ifdef BITSTREAM_READER_LE
+		unsigned ret = get_bits(s, 16);
+		return ret | (get_bits(s, n - 16) << 16);
+#else
+		unsigned ret = get_bits(s, 16) << (n - 16);
+		return ret | get_bits(s, n - 16);
+#endif
+	}
+}
+
+/**
+ * Read 0-64 bits.
+ */
+static inline uint64_t get_bits64(GetBitContext *s, int n)
+{
+	if (n <= 32)
+	{
+		return get_bits_long(s, n);
+	}
+	else
+	{
+#ifdef BITSTREAM_READER_LE
+		uint64_t ret = get_bits_long(s, 32);
+		return ret | (uint64_t) get_bits_long(s, n - 32) << 32;
+#else
+		uint64_t ret = (uint64_t) get_bits_long(s, n - 32) << 32;
+		return ret | get_bits_long(s, 32);
+#endif
+	}
+}
+
+/**
+ * Read 0-32 bits as a signed integer.
+ */
+static inline int get_sbits_long(GetBitContext *s, int n)
+{
+	/* sign_extend(x, 0) is undefined */
+	if (!n)
+		return 0;
+
+	return sign_extend(get_bits_long(s, n), n);
+}
+
+/**
+ * Show 0-32 bits.
+ */
+static inline unsigned int show_bits_long(GetBitContext *s, int n)
+{
+	if (n <= MIN_CACHE_BITS)
+	{
+		return show_bits(s, n);
+	}
+	else
+	{
+		GetBitContext gb = *s;
+		return get_bits_long(&gb, n);
+	}
+}
+
+static inline int check_marker(void *logctx __attribute__((unused)), GetBitContext *s, const char *msg __attribute__((unused)))
+{
+	int bit = get_bits1(s);
+	return bit;
+}
+
+/**
+ * Initialize GetBitContext.
+ * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
+ *        larger than the actual read bits because some optimized bitstream
+ *        readers read 32 or 64 bit at once and could read over the end
+ * @param bit_size the size of the buffer in bits
+ * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
+ */
+static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
+                                int bit_size)
+{
+	int buffer_size;
+	int ret = 0;
+
+	if (bit_size >= INT_MAX - 7 || bit_size < 0 || !buffer)
+	{
+		bit_size    = 0;
+		buffer      = NULL;
+		ret         = AVERROR_INVALIDDATA;
+	}
+
+	buffer_size = (bit_size + 7) >> 3;
+
+	s->buffer             = buffer;
+	s->size_in_bits       = bit_size;
+	s->size_in_bits_plus8 = bit_size + 8;
+	s->buffer_end         = buffer + buffer_size;
+	s->index              = 0;
+
+	return ret;
+}
+
+/**
+ * Initialize GetBitContext.
+ * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
+ *        larger than the actual read bits because some optimized bitstream
+ *        readers read 32 or 64 bit at once and could read over the end
+ * @param byte_size the size of the buffer in bytes
+ * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
+ */
+static inline int init_get_bits8(GetBitContext *s, const uint8_t *buffer,
+                                 int byte_size)
+{
+	if (byte_size > INT_MAX / 8 || byte_size < 0)
+		byte_size = -1;
+	return init_get_bits(s, buffer, byte_size * 8);
+}
+
+static inline const uint8_t *align_get_bits(GetBitContext *s)
+{
+	int n = -get_bits_count(s) & 7;
+	if (n)
+		skip_bits(s, n);
+	return s->buffer + (s->index >> 3);
+}
+
+/**
+ * If the vlc code is invalid and max_depth=1, then no bits will be removed.
+ * If the vlc code is invalid and max_depth>1, then the number of bits removed
+ * is undefined.
+ */
+#define GET_VLC(code, name, gb, table, bits, max_depth)         \
+    do {                                                        \
+        int n, nb_bits;                                         \
+        unsigned int index;                                     \
+                                                                \
+        index = SHOW_UBITS(name, gb, bits);                     \
+        code  = table[index][0];                                \
+        n     = table[index][1];                                \
+                                                                \
+        if (max_depth > 1 && n < 0) {                           \
+            LAST_SKIP_BITS(name, gb, bits);                     \
+            UPDATE_CACHE(name, gb);                             \
+                                                                \
+            nb_bits = -n;                                       \
+                                                                \
+            index = SHOW_UBITS(name, gb, nb_bits) + code;       \
+            code  = table[index][0];                            \
+            n     = table[index][1];                            \
+            if (max_depth > 2 && n < 0) {                       \
+                LAST_SKIP_BITS(name, gb, nb_bits);              \
+                UPDATE_CACHE(name, gb);                         \
+                                                                \
+                nb_bits = -n;                                   \
+                                                                \
+                index = SHOW_UBITS(name, gb, nb_bits) + code;   \
+                code  = table[index][0];                        \
+                n     = table[index][1];                        \
+            }                                                   \
+        }                                                       \
+        SKIP_BITS(name, gb, n);                                 \
+    } while (0)
+
+#define GET_RL_VLC(level, run, name, gb, table, bits,  \
+                   max_depth, need_update)                      \
+    do {                                                        \
+        int n, nb_bits;                                         \
+        unsigned int index;                                     \
+                                                                \
+        index = SHOW_UBITS(name, gb, bits);                     \
+        level = table[index].level;                             \
+        n     = table[index].len;                               \
+                                                                \
+        if (max_depth > 1 && n < 0) {                           \
+            SKIP_BITS(name, gb, bits);                          \
+            if (need_update) {                                  \
+                UPDATE_CACHE(name, gb);                         \
+            }                                                   \
+                                                                \
+            nb_bits = -n;                                       \
+                                                                \
+            index = SHOW_UBITS(name, gb, nb_bits) + level;      \
+            level = table[index].level;                         \
+            n     = table[index].len;                           \
+            if (max_depth > 2 && n < 0) {                       \
+                LAST_SKIP_BITS(name, gb, nb_bits);              \
+                if (need_update) {                              \
+                    UPDATE_CACHE(name, gb);                     \
+                }                                               \
+                nb_bits = -n;                                   \
+                                                                \
+                index = SHOW_UBITS(name, gb, nb_bits) + level;  \
+                level = table[index].level;                     \
+                n     = table[index].len;                       \
+            }                                                   \
+        }                                                       \
+        run = table[index].run;                                 \
+        SKIP_BITS(name, gb, n);                                 \
+    } while (0)
+
+
+static inline int decode012(GetBitContext *gb)
+{
+	int n;
+	n = get_bits1(gb);
+	if (n == 0)
+		return 0;
+	else
+		return get_bits1(gb) + 1;
+}
+
+static inline int decode210(GetBitContext *gb)
+{
+	if (get_bits1(gb))
+		return 0;
+	else
+		return 2 - get_bits1(gb);
+}
+
+static inline int get_bits_left(GetBitContext *gb)
+{
+	return gb->size_in_bits - get_bits_count(gb);
+}
+
+static inline int skip_1stop_8data_bits(GetBitContext *gb)
+{
+	if (get_bits_left(gb) <= 0)
+		return AVERROR_INVALIDDATA;
+
+	while (get_bits1(gb))
+	{
+		skip_bits(gb, 8);
+		if (get_bits_left(gb) <= 0)
+			return AVERROR_INVALIDDATA;
+	}
+
+	return 0;
+}
+
+#endif /* AVCODEC_GET_BITS_H */

libeplayer3/external/ffmpeg/latmenc.h

@@ -0,0 +1,45 @@
+/*
+ * LATM/LOAS muxer
+ * Copyright (c) 2011 Kieran Kunhya <kieran@kunhya.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
+ */
+
+#ifndef AVCODEC_LATMENC_H
+#define AVCODEC_LATMENC_H
+
+#include <stdint.h>
+
+#define MAX_EXTRADATA_SIZE 1024
+
+typedef struct LATMContext
+{
+	int off;
+	int channel_conf;
+	int object_type;
+	int counter;
+	int mod; // default 0x0014
+	uint8_t loas_header[3];
+	uint8_t buffer[0x1fff + MAX_EXTRADATA_SIZE + 1024];
+	int len;
+} LATMContext;
+
+int latmenc_decode_extradata(LATMContext *ctx, uint8_t *buf, int size);
+int latmenc_write_packet(LATMContext *ctx, uint8_t *data, int size, uint8_t *extradata, int extradata_size);
+
+#endif /* AVCODEC_LATMENC_H */
+

libeplayer3/external/ffmpeg/mathops.h

@@ -0,0 +1,56 @@
+/*
+ * 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 <stdint.h>
+#include <libavutil/common.h>
+
+#ifndef NEG_USR32
+#   define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
+#endif
+
+#ifndef NEG_SSR32
+#   define NEG_SSR32(a,s) (((int32_t)(a))>>(32-(s)))
+#endif
+
+#ifndef sign_extend
+static inline av_const int sign_extend(int val, unsigned bits)
+{
+	unsigned shift = 8 * sizeof(int) - bits;
+	union
+	{
+		unsigned u;
+		int s;
+	} v = { (unsigned) val << shift };
+	return v.s >> shift;
+}
+#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
+
+#endif /* AVCODEC_MATHOPS_H */

libeplayer3/external/ffmpeg/mpeg4audio.h

@@ -0,0 +1,112 @@
+/*
+ * MPEG-4 Audio common header
+ * Copyright (c) 2008 Baptiste Coudurier <baptiste.coudurier@free.fr>
+ *
+ * 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_MPEG4AUDIO_H
+#define AVCODEC_MPEG4AUDIO_H
+
+#include <stdint.h>
+#include "get_bits.h"
+#include "put_bits.h"
+
+typedef struct MPEG4AudioConfig
+{
+	int object_type;
+	int sampling_index;
+	int sample_rate;
+	int chan_config;
+	int sbr; ///< -1 implicit, 1 presence
+	int ext_object_type;
+	int ext_sampling_index;
+	int ext_sample_rate;
+	int ext_chan_config;
+	int channels;
+	int ps;  ///< -1 implicit, 1 presence
+	int frame_length_short;
+} MPEG4AudioConfig;
+
+extern const int avpriv_mpeg4audio_sample_rates[16];
+extern const uint8_t ff_mpeg4audio_channels[8];
+
+/**
+ * Parse MPEG-4 systems extradata to retrieve audio configuration.
+ * @param[in] c        MPEG4AudioConfig structure to fill.
+ * @param[in] buf      Extradata from container.
+ * @param[in] bit_size Extradata size in bits.
+ * @param[in] sync_extension look for a sync extension after config if true.
+ * @return On error -1 is returned, on success AudioSpecificConfig bit index in extradata.
+ */
+int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf,
+                                 int bit_size, int sync_extension);
+
+enum AudioObjectType
+{
+	AOT_NULL,
+	// Support?                Name
+	AOT_AAC_MAIN,              ///< Y                       Main
+	AOT_AAC_LC,                ///< Y                       Low Complexity
+	AOT_AAC_SSR,               ///< N (code in SoC repo)    Scalable Sample Rate
+	AOT_AAC_LTP,               ///< Y                       Long Term Prediction
+	AOT_SBR,                   ///< Y                       Spectral Band Replication
+	AOT_AAC_SCALABLE,          ///< N                       Scalable
+	AOT_TWINVQ,                ///< N                       Twin Vector Quantizer
+	AOT_CELP,                  ///< N                       Code Excited Linear Prediction
+	AOT_HVXC,                  ///< N                       Harmonic Vector eXcitation Coding
+	AOT_TTSI             = 12, ///< N                       Text-To-Speech Interface
+	AOT_MAINSYNTH,             ///< N                       Main Synthesis
+	AOT_WAVESYNTH,             ///< N                       Wavetable Synthesis
+	AOT_MIDI,                  ///< N                       General MIDI
+	AOT_SAFX,                  ///< N                       Algorithmic Synthesis and Audio Effects
+	AOT_ER_AAC_LC,             ///< N                       Error Resilient Low Complexity
+	AOT_ER_AAC_LTP       = 19, ///< N                       Error Resilient Long Term Prediction
+	AOT_ER_AAC_SCALABLE,       ///< N                       Error Resilient Scalable
+	AOT_ER_TWINVQ,             ///< N                       Error Resilient Twin Vector Quantizer
+	AOT_ER_BSAC,               ///< N                       Error Resilient Bit-Sliced Arithmetic Coding
+	AOT_ER_AAC_LD,             ///< N                       Error Resilient Low Delay
+	AOT_ER_CELP,               ///< N                       Error Resilient Code Excited Linear Prediction
+	AOT_ER_HVXC,               ///< N                       Error Resilient Harmonic Vector eXcitation Coding
+	AOT_ER_HILN,               ///< N                       Error Resilient Harmonic and Individual Lines plus Noise
+	AOT_ER_PARAM,              ///< N                       Error Resilient Parametric
+	AOT_SSC,                   ///< N                       SinuSoidal Coding
+	AOT_PS,                    ///< N                       Parametric Stereo
+	AOT_SURROUND,              ///< N                       MPEG Surround
+	AOT_ESCAPE,                ///< Y                       Escape Value
+	AOT_L1,                    ///< Y                       Layer 1
+	AOT_L2,                    ///< Y                       Layer 2
+	AOT_L3,                    ///< Y                       Layer 3
+	AOT_DST,                   ///< N                       Direct Stream Transfer
+	AOT_ALS,                   ///< Y                       Audio LosslesS
+	AOT_SLS,                   ///< N                       Scalable LosslesS
+	AOT_SLS_NON_CORE,          ///< N                       Scalable LosslesS (non core)
+	AOT_ER_AAC_ELD,            ///< N                       Error Resilient Enhanced Low Delay
+	AOT_SMR_SIMPLE,            ///< N                       Symbolic Music Representation Simple
+	AOT_SMR_MAIN,              ///< N                       Symbolic Music Representation Main
+	AOT_USAC_NOSBR,            ///< N                       Unified Speech and Audio Coding (no SBR)
+	AOT_SAOC,                  ///< N                       Spatial Audio Object Coding
+	AOT_LD_SURROUND,           ///< N                       Low Delay MPEG Surround
+	AOT_USAC,                  ///< N                       Unified Speech and Audio Coding
+};
+
+#define MAX_PCE_SIZE 320 ///<Maximum size of a PCE including the 3-bit ID_PCE
+///<marker and the comment
+
+int avpriv_copy_pce_data(PutBitContext *pb, GetBitContext *gb);
+
+#endif /* AVCODEC_MPEG4AUDIO_H */

libeplayer3/external/ffmpeg/put_bits.h

@@ -0,0 +1,281 @@
+/*
+ * copyright (c) 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
+ * bitstream writer API
+ */
+
+#ifndef AVCODEC_PUT_BITS_H
+#define AVCODEC_PUT_BITS_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "libavutil/intreadwrite.h"
+#include "libavutil/avassert.h"
+
+typedef struct PutBitContext
+{
+	uint32_t bit_buf;
+	int bit_left;
+	uint8_t *buf, *buf_ptr, *buf_end;
+	int size_in_bits;
+} PutBitContext;
+
+/**
+ * Initialize the PutBitContext s.
+ *
+ * @param buffer the buffer where to put bits
+ * @param buffer_size the size in bytes of buffer
+ */
+static inline void init_put_bits(PutBitContext *s, uint8_t *buffer,
+                                 int buffer_size)
+{
+	if (buffer_size < 0)
+	{
+		buffer_size = 0;
+		buffer      = NULL;
+	}
+
+	s->size_in_bits = 8 * buffer_size;
+	s->buf          = buffer;
+	s->buf_end      = s->buf + buffer_size;
+	s->buf_ptr      = s->buf;
+	s->bit_left     = 32;
+	s->bit_buf      = 0;
+}
+
+/**
+ * Rebase the bit writer onto a reallocated buffer.
+ *
+ * @param buffer the buffer where to put bits
+ * @param buffer_size the size in bytes of buffer,
+ *                    must be larger than the previous size
+ */
+static inline void rebase_put_bits(PutBitContext *s, uint8_t *buffer,
+                                   int buffer_size)
+{
+	av_assert0(8 * buffer_size > s->size_in_bits);
+
+	s->buf_end = buffer + buffer_size;
+	s->buf_ptr = buffer + (s->buf_ptr - s->buf);
+	s->buf     = buffer;
+	s->size_in_bits = 8 * buffer_size;
+}
+
+/**
+ * @return the total number of bits written to the bitstream.
+ */
+static inline int put_bits_count(PutBitContext *s)
+{
+	return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;
+}
+
+/**
+ * @return the number of bits available in the bitstream.
+ */
+static inline int put_bits_left(PutBitContext *s)
+{
+	return (s->buf_end - s->buf_ptr) * 8 - 32 + s->bit_left;
+}
+
+/**
+ * Pad the end of the output stream with zeros.
+ */
+static inline void flush_put_bits(PutBitContext *s)
+{
+#ifndef BITSTREAM_WRITER_LE
+	if (s->bit_left < 32)
+		s->bit_buf <<= s->bit_left;
+#endif
+	while (s->bit_left < 32)
+	{
+		av_assert0(s->buf_ptr < s->buf_end);
+#ifdef BITSTREAM_WRITER_LE
+		*s->buf_ptr++ = s->bit_buf;
+		s->bit_buf  >>= 8;
+#else
+		*s->buf_ptr++ = s->bit_buf >> 24;
+		s->bit_buf  <<= 8;
+#endif
+		s->bit_left  += 8;
+	}
+	s->bit_left = 32;
+	s->bit_buf  = 0;
+}
+
+#ifdef BITSTREAM_WRITER_LE
+#define avpriv_align_put_bits align_put_bits_unsupported_here
+#define avpriv_put_string ff_put_string_unsupported_here
+#define avpriv_copy_bits avpriv_copy_bits_unsupported_here
+#else
+/**
+ * Pad the bitstream with zeros up to the next byte boundary.
+ */
+void avpriv_align_put_bits(PutBitContext *s);
+
+/**
+ * Put the string string in the bitstream.
+ *
+ * @param terminate_string 0-terminates the written string if value is 1
+ */
+void avpriv_put_string(PutBitContext *pb, const char *string,
+                       int terminate_string);
+
+/**
+ * Copy the content of src to the bitstream.
+ *
+ * @param length the number of bits of src to copy
+ */
+void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length);
+#endif
+
+/**
+ * Write up to 31 bits into a bitstream.
+ * Use put_bits32 to write 32 bits.
+ */
+static inline void put_bits(PutBitContext *s, int n, unsigned int value)
+{
+	unsigned int bit_buf;
+	int bit_left;
+
+	av_assert2(n <= 31 && value < (1U << n));
+
+	bit_buf  = s->bit_buf;
+	bit_left = s->bit_left;
+
+	/* XXX: optimize */
+#ifdef BITSTREAM_WRITER_LE
+	bit_buf |= value << (32 - bit_left);
+	if (n >= bit_left)
+	{
+		if (3 < s->buf_end - s->buf_ptr)
+		{
+			AV_WL32(s->buf_ptr, bit_buf);
+			s->buf_ptr += 4;
+		}
+		else
+		{
+			av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
+			av_assert2(0);
+		}
+		bit_buf     = value >> bit_left;
+		bit_left   += 32;
+	}
+	bit_left -= n;
+#else
+	if (n < bit_left)
+	{
+		bit_buf     = (bit_buf << n) | value;
+		bit_left   -= n;
+	}
+	else
+	{
+		bit_buf   <<= bit_left;
+		bit_buf    |= value >> (n - bit_left);
+		if (3 < s->buf_end - s->buf_ptr)
+		{
+			AV_WB32(s->buf_ptr, bit_buf);
+			s->buf_ptr += 4;
+		}
+		else
+		{
+			av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
+			av_assert2(0);
+		}
+		bit_left   += 32 - n;
+		bit_buf     = value;
+	}
+#endif
+
+	s->bit_buf  = bit_buf;
+	s->bit_left = bit_left;
+}
+
+static inline void put_sbits(PutBitContext *pb, int n, int32_t value)
+{
+	av_assert2(n >= 0 && n <= 31);
+
+	put_bits(pb, n, av_mod_uintp2(value, n));
+}
+
+/**
+ * Write exactly 32 bits into a bitstream.
+ */
+static void av_unused put_bits32(PutBitContext *s, uint32_t value)
+{
+	int lo = value & 0xffff;
+	int hi = value >> 16;
+#ifdef BITSTREAM_WRITER_LE
+	put_bits(s, 16, lo);
+	put_bits(s, 16, hi);
+#else
+	put_bits(s, 16, hi);
+	put_bits(s, 16, lo);
+#endif
+}
+
+/**
+ * Return the pointer to the byte where the bitstream writer will put
+ * the next bit.
+ */
+static inline uint8_t *put_bits_ptr(PutBitContext *s)
+{
+	return s->buf_ptr;
+}
+
+/**
+ * Skip the given number of bytes.
+ * PutBitContext must be flushed & aligned to a byte boundary before calling this.
+ */
+static inline void skip_put_bytes(PutBitContext *s, int n)
+{
+	av_assert2((put_bits_count(s) & 7) == 0);
+	av_assert2(s->bit_left == 32);
+	av_assert0(n <= s->buf_end - s->buf_ptr);
+	s->buf_ptr += n;
+}
+
+/**
+ * Skip the given number of bits.
+ * Must only be used if the actual values in the bitstream do not matter.
+ * If n is 0 the behavior is undefined.
+ */
+static inline void skip_put_bits(PutBitContext *s, int n)
+{
+	s->bit_left -= n;
+	s->buf_ptr  -= 4 * (s->bit_left >> 5);
+	s->bit_left &= 31;
+}
+
+/**
+ * Change the end of the buffer.
+ *
+ * @param size the new size in bytes of the buffer where to put bits
+ */
+static inline void set_put_bits_buffer_size(PutBitContext *s, int size)
+{
+	av_assert0(size <= INT_MAX / 8 - 32);
+	s->buf_end = s->buf + size;
+	s->size_in_bits = 8 * size;
+}
+
+#endif /* AVCODEC_PUT_BITS_H */

libeplayer3/external/ffmpeg/src/bitstream.c

@@ -0,0 +1,78 @@
+/*
+ * Common bit i/o utils
+ * Copyright (c) 2000, 2001 Fabrice Bellard
+ * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
+ * Copyright (c) 2010 Loren Merritt
+ *
+ * alternative bitstream reader & writer by 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
+ * bitstream api.
+ */
+
+#include <libavutil/avassert.h>
+#include <ffmpeg/put_bits.h>
+
+
+void avpriv_align_put_bits(PutBitContext *s)
+{
+	put_bits(s, s->bit_left & 7, 0);
+}
+
+void avpriv_put_string(PutBitContext *pb, const char *string, int terminate_string)
+{
+	while (*string)
+	{
+		put_bits(pb, 8, *string);
+		string++;
+	}
+	if (terminate_string)
+		put_bits(pb, 8, 0);
+}
+
+void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
+{
+	int words = length >> 4;
+	int bits  = length & 15;
+	int i;
+
+	if (length == 0)
+		return;
+
+	av_assert0(length <= put_bits_left(pb));
+
+	if (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++)
+			put_bits(pb, 8, src[i]);
+		flush_put_bits(pb);
+		memcpy(put_bits_ptr(pb), src + i, 2 * words - i);
+		skip_put_bytes(pb, 2 * words - i);
+	}
+
+	put_bits(pb, bits, AV_RB16(src + 2 * words) >> (16 - bits));
+}
+

libeplayer3/external/ffmpeg/src/latmenc.c

@@ -0,0 +1,171 @@
+/*
+ * LATM/LOAS muxer
+ * Copyright (c) 2011 Kieran Kunhya <kieran@kunhya.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
+ */
+
+/* ***************************** */
+/* Includes                      */
+/* ***************************** */
+#include <ffmpeg/get_bits.h>
+#include <ffmpeg/put_bits.h>
+#include <ffmpeg/mpeg4audio.h>
+#include <ffmpeg/latmenc.h>
+#include "debug.h"
+
+/* ***************************** */
+/* Makros/Constants              */
+/* ***************************** */
+
+int latmenc_decode_extradata(LATMContext *ctx, uint8_t *buf, int size)
+{
+	MPEG4AudioConfig m4ac;
+
+	if (size > MAX_EXTRADATA_SIZE)
+	{
+		latmenc_err("Extradata is larger than currently supported.\n");
+		return AVERROR_INVALIDDATA;
+	}
+	ctx->off = avpriv_mpeg4audio_get_config(&m4ac, buf, size * 8, 1);
+	if (ctx->off < 0)
+		return ctx->off;
+
+	if (ctx->object_type == AOT_ALS && (ctx->off & 7))
+	{
+		// as long as avpriv_mpeg4audio_get_config works correctly this is impossible
+		latmenc_err("BUG: ALS offset is not byte-aligned\n");
+		return AVERROR_INVALIDDATA;
+	}
+	/* FIXME: are any formats not allowed in LATM? */
+
+	if (m4ac.object_type > AOT_SBR && m4ac.object_type != AOT_ALS)
+	{
+		latmenc_err("Muxing MPEG-4 AOT %d in LATM is not supported\n", m4ac.object_type);
+		return AVERROR_INVALIDDATA;
+	}
+	ctx->channel_conf = m4ac.chan_config;
+	ctx->object_type  = m4ac.object_type;
+
+	return 0;
+}
+
+static void latmenc_write_frame_header(LATMContext *ctx, uint8_t *extradata, int extradata_size, PutBitContext *bs)
+{
+	int header_size;
+
+	/* AudioMuxElement */
+	put_bits(bs, 1, !!ctx->counter);
+
+	if (!ctx->counter)
+	{
+		/* StreamMuxConfig */
+		put_bits(bs, 1, 0); /* audioMuxVersion */
+		put_bits(bs, 1, 1); /* allStreamsSameTimeFraming */
+		put_bits(bs, 6, 0); /* numSubFrames */
+		put_bits(bs, 4, 0); /* numProgram */
+		put_bits(bs, 3, 0); /* numLayer */
+
+		/* AudioSpecificConfig */
+		if (ctx->object_type == AOT_ALS)
+		{
+			header_size = extradata_size - (ctx->off >> 3);
+			avpriv_copy_bits(bs, &extradata[ctx->off >> 3], header_size);
+		}
+		else
+		{
+			// + 3 assumes not scalable and dependsOnCoreCoder == 0,
+			// see decode_ga_specific_config in libavcodec/aacdec.c
+			avpriv_copy_bits(bs, extradata, ctx->off + 3);
+
+			if (!ctx->channel_conf)
+			{
+				GetBitContext gb;
+				int ret = init_get_bits8(&gb, extradata, extradata_size);
+				av_assert0(ret >= 0); // extradata size has been checked already, so this should not fail
+				skip_bits_long(&gb, ctx->off + 3);
+				avpriv_copy_pce_data(bs, &gb);
+			}
+		}
+
+		put_bits(bs, 3, 0); /* frameLengthType */
+		put_bits(bs, 8, 0xff); /* latmBufferFullness */
+
+		put_bits(bs, 1, 0); /* otherDataPresent */
+		put_bits(bs, 1, 0); /* crcCheckPresent */
+	}
+
+	ctx->counter++;
+	ctx->counter %= ctx->mod;
+}
+
+int latmenc_write_packet(LATMContext *ctx, uint8_t *data, int size, uint8_t *extradata, int extradata_size)
+{
+	PutBitContext bs;
+	int i, len;
+
+	if (size > 0x1fff)
+		goto too_large;
+
+	init_put_bits(&bs, ctx->buffer, size + 1024 + MAX_EXTRADATA_SIZE);
+
+	latmenc_write_frame_header(ctx, extradata, extradata_size, &bs);
+
+	/* PayloadLengthInfo() */
+	for (i = 0; i <= size - 255; i += 255)
+		put_bits(&bs, 8, 255);
+
+	put_bits(&bs, 8, size - i);
+
+	/* The LATM payload is written unaligned */
+
+	/* PayloadMux() */
+	if (size && (data[0] & 0xe1) == 0x81)
+	{
+		// Convert byte-aligned DSE to non-aligned.
+		// Due to the input format encoding we know that
+		// it is naturally byte-aligned in the input stream,
+		// so there are no padding bits to account for.
+		// To avoid having to add padding bits and rearrange
+		// the whole stream we just remove the byte-align flag.
+		// This allows us to remux our FATE AAC samples into latm
+		// files that are still playable with minimal effort.
+		put_bits(&bs, 8, data[0] & 0xfe);
+		avpriv_copy_bits(&bs, data + 1, 8 * size - 8);
+	}
+	else
+		avpriv_copy_bits(&bs, data, 8 * size);
+
+	avpriv_align_put_bits(&bs);
+	flush_put_bits(&bs);
+
+	len = put_bits_count(&bs) >> 3;
+
+	if (len > 0x1fff)
+		goto too_large;
+
+	memcpy(ctx->loas_header, "\x56\xe0\x00", 3);
+	ctx->loas_header[1] |= (len >> 8) & 0x1f;
+	ctx->loas_header[2] |= len & 0xff;
+	ctx->len = len;
+	return 0;
+
+too_large:
+	latmenc_err("LATM packet size larger than maximum size 0x1fff\n");
+	return AVERROR_INVALIDDATA;
+}
+

libeplayer3/external/ffmpeg/src/mpeg4audio.c

@@ -0,0 +1,205 @@
+/*
+ * MPEG-4 Audio common code
+ * Copyright (c) 2008 Baptiste Coudurier <baptiste.coudurier@free.fr>
+ * Copyright (c) 2009 Alex Converse <alex.converse@gmail.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 <ffmpeg/get_bits.h>
+#include <ffmpeg/put_bits.h>
+#include <ffmpeg/mpeg4audio.h>
+
+/**
+ * Parse MPEG-4 audio configuration for ALS object type.
+ * @param[in] gb       bit reader context
+ * @param[in] c        MPEG4AudioConfig structure to fill
+ * @return on success 0 is returned, otherwise a value < 0
+ */
+static int parse_config_ALS(GetBitContext *gb, MPEG4AudioConfig *c)
+{
+	if (get_bits_left(gb) < 112)
+		return -1;
+
+	if (get_bits_long(gb, 32) != MKBETAG('A', 'L', 'S', '\0'))
+		return -1;
+
+	// override AudioSpecificConfig channel configuration and sample rate
+	// which are buggy in old ALS conformance files
+	c->sample_rate = get_bits_long(gb, 32);
+
+	// skip number of samples
+	skip_bits_long(gb, 32);
+
+	// read number of channels
+	c->chan_config = 0;
+	c->channels    = get_bits(gb, 16) + 1;
+
+	return 0;
+}
+
+/* XXX: make sure to update the copies in the different encoders if you change
+ * this table */
+const int avpriv_mpeg4audio_sample_rates[16] =
+{
+	96000, 88200, 64000, 48000, 44100, 32000,
+	24000, 22050, 16000, 12000, 11025, 8000, 7350
+};
+
+const uint8_t ff_mpeg4audio_channels[8] =
+{
+	0, 1, 2, 3, 4, 5, 6, 8
+};
+
+static inline int get_object_type(GetBitContext *gb)
+{
+	int object_type = get_bits(gb, 5);
+	if (object_type == AOT_ESCAPE)
+		object_type = 32 + get_bits(gb, 6);
+	return object_type;
+}
+
+static inline int get_sample_rate(GetBitContext *gb, int *index)
+{
+	*index = get_bits(gb, 4);
+	return *index == 0x0f ? (int)get_bits(gb, 24) : avpriv_mpeg4audio_sample_rates[*index];
+}
+
+int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf,
+                                 int bit_size, int sync_extension)
+{
+	GetBitContext gb;
+	int specific_config_bitindex, ret;
+
+	if (bit_size <= 0)
+		return AVERROR_INVALIDDATA;
+
+	ret = init_get_bits(&gb, buf, bit_size);
+	if (ret < 0)
+		return ret;
+
+	c->object_type = get_object_type(&gb);
+	c->sample_rate = get_sample_rate(&gb, &c->sampling_index);
+	c->chan_config = get_bits(&gb, 4);
+	if (c->chan_config < (int)FF_ARRAY_ELEMS(ff_mpeg4audio_channels))
+		c->channels = ff_mpeg4audio_channels[c->chan_config];
+	c->sbr = -1;
+	c->ps  = -1;
+	if (c->object_type == AOT_SBR || (c->object_type == AOT_PS &&
+	    // check for W6132 Annex YYYY draft MP3onMP4
+	    !(show_bits(&gb, 3) & 0x03 && !(show_bits(&gb, 9) & 0x3F))))
+	{
+		if (c->object_type == AOT_PS)
+			c->ps = 1;
+		c->ext_object_type = AOT_SBR;
+		c->sbr = 1;
+		c->ext_sample_rate = get_sample_rate(&gb, &c->ext_sampling_index);
+		c->object_type = get_object_type(&gb);
+		if (c->object_type == AOT_ER_BSAC)
+			c->ext_chan_config = get_bits(&gb, 4);
+	}
+	else
+	{
+		c->ext_object_type = AOT_NULL;
+		c->ext_sample_rate = 0;
+	}
+	specific_config_bitindex = get_bits_count(&gb);
+
+	if (c->object_type == AOT_ALS)
+	{
+		skip_bits(&gb, 5);
+		if (show_bits_long(&gb, 24) != MKBETAG('\0', 'A', 'L', 'S'))
+			skip_bits_long(&gb, 24);
+
+		specific_config_bitindex = get_bits_count(&gb);
+
+		if (parse_config_ALS(&gb, c))
+			return -1;
+	}
+
+	if (c->ext_object_type != AOT_SBR && sync_extension)
+	{
+		while (get_bits_left(&gb) > 15)
+		{
+			if (show_bits(&gb, 11) == 0x2b7)   // sync extension
+			{
+				get_bits(&gb, 11);
+				c->ext_object_type = get_object_type(&gb);
+				if (c->ext_object_type == AOT_SBR && (c->sbr = get_bits1(&gb)) == 1)
+				{
+					c->ext_sample_rate = get_sample_rate(&gb, &c->ext_sampling_index);
+					if (c->ext_sample_rate == c->sample_rate)
+						c->sbr = -1;
+				}
+				if (get_bits_left(&gb) > 11 && get_bits(&gb, 11) == 0x548)
+					c->ps = get_bits1(&gb);
+				break;
+			}
+			else
+				get_bits1(&gb); // skip 1 bit
+		}
+	}
+
+	//PS requires SBR
+	if (!c->sbr)
+		c->ps = 0;
+	//Limit implicit PS to the HE-AACv2 Profile
+	if ((c->ps == -1 && c->object_type != AOT_AAC_LC) || c->channels & ~0x01)
+		c->ps = 0;
+
+	return specific_config_bitindex;
+}
+
+static av_always_inline unsigned int copy_bits(PutBitContext *pb,
+        GetBitContext *gb,
+        int bits)
+{
+	unsigned int el = get_bits(gb, bits);
+	put_bits(pb, bits, el);
+	return el;
+}
+
+int avpriv_copy_pce_data(PutBitContext *pb, GetBitContext *gb)
+{
+	int five_bit_ch, four_bit_ch, comment_size, bits;
+	int offset = put_bits_count(pb);
+
+	copy_bits(pb, gb, 10);                  //Tag, Object Type, Frequency
+	five_bit_ch  = copy_bits(pb, gb, 4);    //Front
+	five_bit_ch += copy_bits(pb, gb, 4);    //Side
+	five_bit_ch += copy_bits(pb, gb, 4);    //Back
+	four_bit_ch  = copy_bits(pb, gb, 2);    //LFE
+	four_bit_ch += copy_bits(pb, gb, 3);    //Data
+	five_bit_ch += copy_bits(pb, gb, 4);    //Coupling
+	if (copy_bits(pb, gb, 1))               //Mono Mixdown
+		copy_bits(pb, gb, 4);
+	if (copy_bits(pb, gb, 1))               //Stereo Mixdown
+		copy_bits(pb, gb, 4);
+	if (copy_bits(pb, gb, 1))               //Matrix Mixdown
+		copy_bits(pb, gb, 3);
+	for (bits = five_bit_ch * 5 + four_bit_ch * 4; bits > 16; bits -= 16)
+		copy_bits(pb, gb, 16);
+	if (bits)
+		copy_bits(pb, gb, bits);
+	avpriv_align_put_bits(pb);
+	align_get_bits(gb);
+	comment_size = copy_bits(pb, gb, 8);
+	for (; comment_size > 0; comment_size--)
+		copy_bits(pb, gb, 8);
+
+	return put_bits_count(pb) - offset;
+}