Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

tak: reduce difference with qatar

Browse Source 
Mostly cosmetics changes, but also makes
decoding little faster here.

Signed-off-by: Paul B Mahol <onemda@gmail.com>
pull/8/head
Paul B Mahol 12 years ago
parent 461b5bf4ab
commit cef28b5602
5 changed files with 499 additions and 513 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 26
      libavcodec/tak.c
  2. 54
      libavcodec/tak.h
  3. 9
      libavcodec/tak_parser.c
  4. 576
      libavcodec/takdec.c
  5. 1
      libavformat/takdec.c

26
libavcodec/tak.c
Unescape View File

@ -60,7 +60,8 @@ static int tak_get_nb_samples(int sample_rate, enum TAKFrameSizeType type)
max_nb_samples = 16384; max_nb_samples = 16384;
} else if (type < FF_ARRAY_ELEMS(frame_duration_type_quants)) { } else if (type < FF_ARRAY_ELEMS(frame_duration_type_quants)) {
nb_samples = frame_duration_type_quants[type]; nb_samples = frame_duration_type_quants[type];
max_nb_samples = sample_rate * frame_duration_type_quants[TAK_FST_250ms] >> max_nb_samples = sample_rate *
frame_duration_type_quants[TAK_FST_250ms] >>
TAK_FRAME_DURATION_QUANT_SHIFT; TAK_FRAME_DURATION_QUANT_SHIFT;
} else { } else {
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -116,9 +117,12 @@ void avpriv_tak_parse_streaminfo(GetBitContext *gb, TAKStreamInfo *s)
s->samples = get_bits64(gb, TAK_SIZE_SAMPLES_NUM_BITS); s->samples = get_bits64(gb, TAK_SIZE_SAMPLES_NUM_BITS);
s->data_type = get_bits(gb, TAK_FORMAT_DATA_TYPE_BITS); s->data_type = get_bits(gb, TAK_FORMAT_DATA_TYPE_BITS);
s->sample_rate = get_bits(gb, TAK_FORMAT_SAMPLE_RATE_BITS) + TAK_SAMPLE_RATE_MIN; s->sample_rate = get_bits(gb, TAK_FORMAT_SAMPLE_RATE_BITS) +
s->bps = get_bits(gb, TAK_FORMAT_BPS_BITS) + TAK_BPS_MIN; TAK_SAMPLE_RATE_MIN;
s->channels = get_bits(gb, TAK_FORMAT_CHANNEL_BITS) + TAK_CHANNELS_MIN; s->bps = get_bits(gb, TAK_FORMAT_BPS_BITS) +
TAK_BPS_MIN;
s->channels = get_bits(gb, TAK_FORMAT_CHANNEL_BITS) +
TAK_CHANNELS_MIN;
if (get_bits1(gb)) { if (get_bits1(gb)) {
skip_bits(gb, TAK_FORMAT_VALID_BITS); skip_bits(gb, TAK_FORMAT_VALID_BITS);
@ -136,31 +140,25 @@ void avpriv_tak_parse_streaminfo(GetBitContext *gb, TAKStreamInfo *s)
s->frame_samples = tak_get_nb_samples(s->sample_rate, frame_type); s->frame_samples = tak_get_nb_samples(s->sample_rate, frame_type);
} }
#define FRAME_IS_LAST 1
#define FRAME_HAVE_INFO 2
#define FRAME_HAVE_METADATA 4
int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
TAKStreamInfo *ti, int log_level_offset) TAKStreamInfo *ti, int log_level_offset)
{ {
int flags;
if (get_bits(gb, TAK_FRAME_HEADER_SYNC_ID_BITS) != TAK_FRAME_HEADER_SYNC_ID) { if (get_bits(gb, TAK_FRAME_HEADER_SYNC_ID_BITS) != TAK_FRAME_HEADER_SYNC_ID) {
av_log(avctx, AV_LOG_ERROR + log_level_offset, "missing sync id\n"); av_log(avctx, AV_LOG_ERROR + log_level_offset, "missing sync id\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
flags = get_bits(gb, TAK_FRAME_HEADER_FLAGS_BITS); ti->flags = get_bits(gb, TAK_FRAME_HEADER_FLAGS_BITS);
ti->frame_num = get_bits(gb, TAK_FRAME_HEADER_NO_BITS); ti->frame_num = get_bits(gb, TAK_FRAME_HEADER_NO_BITS);
if (flags & FRAME_IS_LAST) { if (ti->flags & TAK_FRAME_FLAG_IS_LAST) {
ti->last_frame_samples = get_bits(gb, TAK_FRAME_HEADER_SAMPLE_COUNT_BITS) + 1; ti->last_frame_samples = get_bits(gb, TAK_FRAME_HEADER_SAMPLE_COUNT_BITS) + 1;
skip_bits(gb, 2); skip_bits(gb, 2);
} else { } else {
ti->last_frame_samples = 0; ti->last_frame_samples = 0;
} }
if (flags & FRAME_HAVE_INFO) { if (ti->flags & TAK_FRAME_FLAG_HAS_INFO) {
avpriv_tak_parse_streaminfo(gb, ti); avpriv_tak_parse_streaminfo(gb, ti);
if (get_bits(gb, 6)) if (get_bits(gb, 6))
@ -168,7 +166,7 @@ int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
align_get_bits(gb); align_get_bits(gb);
} }
if (flags & FRAME_HAVE_METADATA) if (ti->flags & TAK_FRAME_FLAG_HAS_METADATA)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
skip_bits(gb, 24); skip_bits(gb, 24);

54
libavcodec/tak.h
Unescape View File

@ -57,40 +57,50 @@
#define TAK_FRAME_DURATION_QUANT_SHIFT 5 #define TAK_FRAME_DURATION_QUANT_SHIFT 5
#define TAK_CRC24_BITS 24 #define TAK_CRC24_BITS 24
#define TAK_MAX_CHANNELS ( 1 << TAK_FORMAT_CHANNEL_BITS )
#define TAK_MIN_FRAME_HEADER_BITS ( TAK_FRAME_HEADER_SYNC_ID_BITS + \ #define TAK_FRAME_FLAG_IS_LAST 0x1
#define TAK_FRAME_FLAG_HAS_INFO 0x2
#define TAK_FRAME_FLAG_HAS_METADATA 0x4
#define TAK_MAX_CHANNELS (1 << TAK_FORMAT_CHANNEL_BITS)
#define TAK_MIN_FRAME_HEADER_BITS (TAK_FRAME_HEADER_SYNC_ID_BITS + \
TAK_FRAME_HEADER_FLAGS_BITS + \ TAK_FRAME_HEADER_FLAGS_BITS + \
TAK_FRAME_HEADER_NO_BITS + \ TAK_FRAME_HEADER_NO_BITS + \
TAK_CRC24_BITS ) TAK_CRC24_BITS)
#define TAK_MIN_FRAME_HEADER_LAST_BITS ( TAK_MIN_FRAME_HEADER_BITS + 2 + \ #define TAK_MIN_FRAME_HEADER_LAST_BITS (TAK_MIN_FRAME_HEADER_BITS + 2 + \
TAK_FRAME_HEADER_SAMPLE_COUNT_BITS ) TAK_FRAME_HEADER_SAMPLE_COUNT_BITS)
#define TAK_ENCODER_BITS ( TAK_ENCODER_CODEC_BITS + \ #define TAK_ENCODER_BITS (TAK_ENCODER_CODEC_BITS + \
TAK_ENCODER_PROFILE_BITS ) TAK_ENCODER_PROFILE_BITS)
#define TAK_SIZE_BITS ( TAK_SIZE_SAMPLES_NUM_BITS + \ #define TAK_SIZE_BITS (TAK_SIZE_SAMPLES_NUM_BITS + \
TAK_SIZE_FRAME_DURATION_BITS ) TAK_SIZE_FRAME_DURATION_BITS)
#define TAK_FORMAT_BITS ( TAK_FORMAT_DATA_TYPE_BITS + \ #define TAK_FORMAT_BITS (TAK_FORMAT_DATA_TYPE_BITS + \
TAK_FORMAT_SAMPLE_RATE_BITS + \ TAK_FORMAT_SAMPLE_RATE_BITS + \
TAK_FORMAT_BPS_BITS + \ TAK_FORMAT_BPS_BITS + \
TAK_FORMAT_CHANNEL_BITS + 1 + \ TAK_FORMAT_CHANNEL_BITS + 1 + \
TAK_FORMAT_VALID_BITS + 1 + \ TAK_FORMAT_VALID_BITS + 1 + \
TAK_FORMAT_CH_LAYOUT_BITS * \ TAK_FORMAT_CH_LAYOUT_BITS * \
TAK_MAX_CHANNELS ) TAK_MAX_CHANNELS)
#define TAK_STREAMINFO_BITS ( TAK_ENCODER_BITS + \ #define TAK_STREAMINFO_BITS (TAK_ENCODER_BITS + \
TAK_SIZE_BITS + \ TAK_SIZE_BITS + \
TAK_FORMAT_BITS ) TAK_FORMAT_BITS)
#define TAK_MAX_FRAME_HEADER_BITS ( TAK_MIN_FRAME_HEADER_LAST_BITS + \ #define TAK_MAX_FRAME_HEADER_BITS (TAK_MIN_FRAME_HEADER_LAST_BITS + \
TAK_STREAMINFO_BITS + 31 ) TAK_STREAMINFO_BITS + 31)
#define TAK_STREAMINFO_BYTES (( TAK_STREAMINFO_BITS + 7 ) / 8) #define TAK_STREAMINFO_BYTES ((TAK_STREAMINFO_BITS + 7) / 8)
#define TAK_MAX_FRAME_HEADER_BYTES (( TAK_MAX_FRAME_HEADER_BITS + 7 ) / 8) #define TAK_MAX_FRAME_HEADER_BYTES ((TAK_MAX_FRAME_HEADER_BITS + 7) / 8)
#define TAK_MIN_FRAME_HEADER_BYTES (( TAK_MIN_FRAME_HEADER_BITS + 7 ) / 8) #define TAK_MIN_FRAME_HEADER_BYTES ((TAK_MIN_FRAME_HEADER_BITS + 7) / 8)
enum TAKCodecType {
TAK_CODEC_MONO_STEREO = 2,
TAK_CODEC_MULTICHANNEL = 4,
};
enum TAKMetaDataType { enum TAKMetaDataType {
TAK_METADATA_END = 0, TAK_METADATA_END = 0,
@ -117,7 +127,8 @@ enum TAKFrameSizeType {
}; };
typedef struct TAKStreamInfo { typedef struct TAKStreamInfo {
int codec; int flags;
enum TAKCodecType codec;
int data_type; int data_type;
int sample_rate; int sample_rate;
int channels; int channels;
@ -145,8 +156,9 @@ void avpriv_tak_parse_streaminfo(GetBitContext *gb, TAKStreamInfo *s);
* @param avctx AVCodecContext to use as av_log() context * @param avctx AVCodecContext to use as av_log() context
* @param[in] gb GetBitContext from which to read frame header * @param[in] gb GetBitContext from which to read frame header
* @param[out] s frame information * @param[out] s frame information
* @param log_level_offset log level offset. can be used to silence error messages. * @param log_level_offset log level offset, can be used to silence
* @return non-zero on error, 0 if ok * error messages.
* @return non-zero on error, 0 if OK
*/ */
int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
TAKStreamInfo *s, int log_level_offset); TAKStreamInfo *s, int log_level_offset);

9
libavcodec/tak_parser.c
Unescape View File

@ -24,8 +24,8 @@
* TAK parser * TAK parser
**/ **/
#include "parser.h"
#include "tak.h" #include "tak.h"
#include "parser.h"
typedef struct TAKParseContext { typedef struct TAKParseContext {
ParseContext pc; ParseContext pc;
@ -54,8 +54,8 @@ static int tak_parse(AVCodecParserContext *s, AVCodecContext *avctx,
TAKStreamInfo ti; TAKStreamInfo ti;
init_get_bits(&gb, buf, buf_size); init_get_bits(&gb, buf, buf_size);
if (!ff_tak_decode_frame_header(avctx, &gb, &ti, 127)) if (!ff_tak_decode_frame_header(avctx, &gb, &ti, 127))
s->duration = t->ti.last_frame_samples ? t->ti.last_frame_samples : s->duration = t->ti.last_frame_samples ? t->ti.last_frame_samples
t->ti.frame_samples; : t->ti.frame_samples;
*poutbuf = buf; *poutbuf = buf;
*poutbuf_size = buf_size; *poutbuf_size = buf_size;
return buf_size; return buf_size;
@ -63,7 +63,8 @@ static int tak_parse(AVCodecParserContext *s, AVCodecContext *avctx,
while (buf_size || t->index + needed <= pc->index) { while (buf_size || t->index + needed <= pc->index) {
if (buf_size && t->index + TAK_MAX_FRAME_HEADER_BYTES > pc->index) { if (buf_size && t->index + TAK_MAX_FRAME_HEADER_BYTES > pc->index) {
int tmp_buf_size = FFMIN(2 * TAK_MAX_FRAME_HEADER_BYTES, buf_size); int tmp_buf_size = FFMIN(2 * TAK_MAX_FRAME_HEADER_BYTES,
buf_size);
const uint8_t *tmp_buf = buf; const uint8_t *tmp_buf = buf;
if (ff_combine_frame(pc, END_NOT_FOUND, &tmp_buf, &tmp_buf_size) != -1) if (ff_combine_frame(pc, END_NOT_FOUND, &tmp_buf, &tmp_buf_size) != -1)

576
libavcodec/takdec.c
Unescape View File

@ -28,15 +28,15 @@
#include "libavutil/samplefmt.h" #include "libavutil/samplefmt.h"
#include "tak.h" #include "tak.h"
#include "avcodec.h" #include "avcodec.h"
#include "dsputil.h"
#include "internal.h" #include "internal.h"
#include "unary.h" #include "unary.h"
#include "dsputil.h"
#define MAX_SUBFRAMES 8 ///< max number of subframes per channel #define MAX_SUBFRAMES 8 ///< max number of subframes per channel
#define MAX_PREDICTORS 256 #define MAX_PREDICTORS 256
typedef struct MCDParam { typedef struct MCDParam {
int8_t present; ///< is decorrelation parameters available for this channel int8_t present; ///< decorrelation parameter availability for this channel
int8_t index; ///< index into array of decorrelation types int8_t index; ///< index into array of decorrelation types
int8_t chan1; int8_t chan1;
int8_t chan2; int8_t chan2;
@ -49,6 +49,7 @@ typedef struct TAKDecContext {
TAKStreamInfo ti; TAKStreamInfo ti;
GetBitContext gb; ///< bitstream reader initialized to start at the current frame GetBitContext gb; ///< bitstream reader initialized to start at the current frame
int uval;
int nb_samples; ///< number of samples in the current frame int nb_samples; ///< number of samples in the current frame
uint8_t *decode_buffer; uint8_t *decode_buffer;
unsigned int decode_buffer_size; unsigned int decode_buffer_size;
@ -56,34 +57,21 @@ typedef struct TAKDecContext {
int8_t lpc_mode[TAK_MAX_CHANNELS]; int8_t lpc_mode[TAK_MAX_CHANNELS];
int8_t sample_shift[TAK_MAX_CHANNELS]; ///< shift applied to every sample in the channel int8_t sample_shift[TAK_MAX_CHANNELS]; ///< shift applied to every sample in the channel
int32_t xred;
int size;
int ared;
int filter_order;
int16_t predictors[MAX_PREDICTORS]; int16_t predictors[MAX_PREDICTORS];
int nb_subframes; ///< number of subframes in the current frame int nb_subframes; ///< number of subframes in the current frame
int16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples int16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
int subframe_scale; int subframe_scale;
int8_t dmode; ///< channel decorrelation type in the current frame int8_t dmode; ///< channel decorrelation type in the current frame
int8_t dshift;
int16_t dfactor;
int8_t dval1;
int8_t dval2;
MCDParam mcdparams[TAK_MAX_CHANNELS]; ///< multichannel decorrelation parameters MCDParam mcdparams[TAK_MAX_CHANNELS]; ///< multichannel decorrelation parameters
int wlength;
int uval;
int rval;
int8_t coding_mode[128]; int8_t coding_mode[128];
DECLARE_ALIGNED(16, int16_t, filter)[MAX_PREDICTORS]; DECLARE_ALIGNED(16, int16_t, filter)[MAX_PREDICTORS];
DECLARE_ALIGNED(16, int16_t, residues)[544]; DECLARE_ALIGNED(16, int16_t, residues)[544];
} TAKDecContext; } TAKDecContext;
static const int8_t mc_dmodes[] = { static const int8_t mc_dmodes[] = { 1, 3, 4, 6, };
1, 3, 4, 6,
};
static const uint16_t predictor_sizes[] = { static const uint16_t predictor_sizes[] = {
4, 8, 12, 16, 24, 32, 48, 64, 80, 96, 128, 160, 192, 224, 256, 0, 4, 8, 12, 16, 24, 32, 48, 64, 80, 96, 128, 160, 192, 224, 256, 0,
@ -161,7 +149,8 @@ static int set_bps_params(AVCodecContext *avctx)
avctx->sample_fmt = AV_SAMPLE_FMT_S32P; avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
break; break;
default: default:
av_log(avctx, AV_LOG_ERROR, "invalid/unsupported bits per sample\n"); av_log(avctx, AV_LOG_ERROR, "invalid/unsupported bits per sample: %d\n",
avctx->bits_per_raw_sample);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -196,30 +185,30 @@ static av_cold int tak_decode_init(AVCodecContext *avctx)
static void decode_lpc(int32_t *coeffs, int mode, int length) static void decode_lpc(int32_t *coeffs, int mode, int length)
{ {
int i, a1, a2, a3, a4, a5; int i;
if (length < 2) if (length < 2)
return; return;
if (mode == 1) { if (mode == 1) {
a1 = *coeffs++; int a1 = *coeffs++;
for (i = 0; i < (length - 1 >> 1); i++) { for (i = 0; i < length - 1 >> 1; i++) {
*coeffs += a1; *coeffs += a1;
coeffs[1] += *coeffs; coeffs[1] += *coeffs;
a1 = coeffs[1]; a1 = coeffs[1];
coeffs += 2; coeffs += 2;
} }
if ((length - 1) & 1) if (length - 1 & 1)
*coeffs += a1; *coeffs += a1;
} else if (mode == 2) { } else if (mode == 2) {
a1 = coeffs[1]; int a1 = coeffs[1];
a2 = a1 + *coeffs; int a2 = a1 + *coeffs;
coeffs[1] = a2; coeffs[1] = a2;
if (length > 2) { if (length > 2) {
coeffs += 2; coeffs += 2;
for (i = 0; i < (length - 2 >> 1); i++) { for (i = 0; i < length - 2 >> 1; i++) {
a3 = *coeffs + a1; int a3 = *coeffs + a1;
a4 = a3 + a2; int a4 = a3 + a2;
*coeffs = a4; *coeffs = a4;
a1 = coeffs[1] + a3; a1 = coeffs[1] + a3;
a2 = a1 + a4; a2 = a1 + a4;
@ -230,13 +219,13 @@ static void decode_lpc(int32_t *coeffs, int mode, int length)
*coeffs += a1 + a2; *coeffs += a1 + a2;
} }
} else if (mode == 3) { } else if (mode == 3) {
a1 = coeffs[1]; int a1 = coeffs[1];
a2 = a1 + *coeffs; int a2 = a1 + *coeffs;
coeffs[1] = a2; coeffs[1] = a2;
if (length > 2) { if (length > 2) {
a3 = coeffs[2]; int a3 = coeffs[2];
a4 = a3 + a1; int a4 = a3 + a1;
a5 = a4 + a2; int a5 = a4 + a2;
coeffs += 3; coeffs += 3;
for (i = 0; i < length - 3; i++) { for (i = 0; i < length - 3; i++) {
a3 += *coeffs; a3 += *coeffs;
@ -249,140 +238,123 @@ static void decode_lpc(int32_t *coeffs, int mode, int length)
} }
} }
static int decode_segment(TAKDecContext *s, int8_t value, int32_t *dst, int len) static int decode_segment(TAKDecContext *s, int8_t mode, int32_t *decoded, int len)
{ {
struct CParam code;
GetBitContext *gb = &s->gb; GetBitContext *gb = &s->gb;
int i;
if (!value) { if (!mode) {
memset(dst, 0, len * 4); memset(decoded, 0, len * sizeof(*decoded));
} else {
int x, y, z, i = 0;
value--;
do {
while (1) {
x = get_bits_long(gb, xcodes[value].init);
if (x >= xcodes[value].escape)
break;
dst[i++] = (x >> 1) ^ -(x & 1);
if (i >= len)
return 0; return 0;
} }
y = get_bits1(gb); if (mode > FF_ARRAY_ELEMS(xcodes))
x = (y << xcodes[value].init) | x; return AVERROR_INVALIDDATA;
if (x >= xcodes[value].aescape) { code = xcodes[mode - 1];
int c = get_unary(gb, 1, 9);
for (i = 0; i < len; i++) {
if (c == 9) { int x = get_bits_long(gb, code.init);
int d; if (x >= code.escape && get_bits1(gb)) {
x |= 1 << code.init;
z = x + xcodes[value].bias; if (x >= code.aescape) {
d = get_bits(gb, 3); int scale = get_unary(gb, 1, 9);
if (d == 7) { if (scale == 9) {
d = get_bits(gb, 5) + 7; int scale_bits = get_bits(gb, 3);
if (d > 29) if (scale_bits > 0) {
if (scale_bits == 7) {
scale_bits += get_bits(gb, 5);
if (scale_bits > 29)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (d) scale = get_bits_long(gb, scale_bits) + 1;
z += xcodes[value].scale * (get_bits_long(gb, d) + 1); x += code.scale * scale;
} else {
z = xcodes[value].scale * c + x - xcodes[value].escape;
} }
} else { x += code.bias;
z = x - (xcodes[value].escape & -y); } else
x += code.scale * scale - code.escape;
} else
x -= code.escape;
} }
dst[i++] = (z >> 1) ^ -(z & 1); decoded[i] = (x >> 1) ^ -(x & 1);
} while (i < len);
} }
return 0; return 0;
} }
static int xget(TAKDecContext *s, int d, int q) static int decode_residues(TAKDecContext *s, int32_t *decoded, int length)
{ {
int x; GetBitContext *gb = &s->gb;
int i, mode, ret;
x = d / q;
s->rval = d - (x * q); if (length > s->nb_samples)
return AVERROR_INVALIDDATA;
if (s->rval < q / 2) { if (get_bits1(gb)) {
s->rval += q; int wlength, rval;
} else {
x++;
}
if (x <= 1 || x > 128) wlength = length / s->uval;
return -1;
return x; rval = length - (wlength * s->uval);
}
static int get_len(TAKDecContext *s, int b) if (rval < s->uval / 2)
{ rval += s->uval;
if (b >= s->wlength - 1)
return s->rval;
else else
return s->uval; wlength++;
}
static int decode_coeffs(TAKDecContext *s, int32_t *dst, int length) if (wlength <= 1 || wlength > 128)
{
GetBitContext *gb = &s->gb;
int i, v, ret;
if (length > s->nb_samples)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (get_bits1(gb)) { s->coding_mode[0] = mode = get_bits(gb, 6);
if ((s->wlength = xget(s, length, s->uval)) < 0)
return AVERROR_INVALIDDATA;
s->coding_mode[0] = v = get_bits(gb, 6); for (i = 1; i < wlength; i++) {
if (s->coding_mode[0] > FF_ARRAY_ELEMS(xcodes))
return AVERROR_INVALIDDATA;
for (i = 1; i < s->wlength; i++) {
int c = get_unary(gb, 1, 6); int c = get_unary(gb, 1, 6);
if (c > 5) { switch (c) {
v = get_bits(gb, 6); case 6:
} else if (c > 2) { mode = get_bits(gb, 6);
int t = get_bits1(gb); break;
case 5:
v += (-t ^ (c - 1)) + t; case 4:
} else { case 3: {
v += (-(c & 1) ^ (((c & 1) + c) >> 1)) + (c & 1); /* mode += sign ? (1 - c) : (c - 1) */
int sign = get_bits1(gb);
mode += (-sign ^ (c - 1)) + sign;
break;
} }
case 2:
if (v > FF_ARRAY_ELEMS(xcodes)) mode++;
return AVERROR_INVALIDDATA; break;
s->coding_mode[i] = v; case 1:
mode--;
break;
}
s->coding_mode[i] = mode;
} }
i = 0; i = 0;
while (i < s->wlength) { while (i < wlength) {
int len = 0; int len = 0;
v = s->coding_mode[i]; mode = s->coding_mode[i];
do { do {
len += get_len(s, i); if (i >= wlength - 1)
len += rval;
else
len += s->uval;
i++; i++;
if (i == s->wlength) if (i == wlength)
break; break;
} while (v == s->coding_mode[i]); } while (s->coding_mode[i] == mode);
if ((ret = decode_segment(s, v, dst, len)) < 0) if ((ret = decode_segment(s, mode, decoded, len)) < 0)
return ret; return ret;
dst += len; decoded += len;
} }
} else { } else {
v = get_bits(gb, 6); mode = get_bits(gb, 6);
if (v > FF_ARRAY_ELEMS(xcodes)) if ((ret = decode_segment(s, mode, decoded, length)) < 0)
return AVERROR_INVALIDDATA;
if ((ret = decode_segment(s, v, dst, length)) < 0)
return ret; return ret;
} }
@ -397,67 +369,71 @@ static int get_bits_esc4(GetBitContext *gb)
return 0; return 0;
} }
static int decode_subframe(TAKDecContext *s, int32_t *ptr, int subframe_size, static int decode_subframe(TAKDecContext *s, int32_t *decoded,
int prev_subframe_size) int subframe_size, int prev_subframe_size)
{ {
GetBitContext *gb = &s->gb; GetBitContext *gb = &s->gb;
int tmp, x, y, i, j, ret = 0; int tmp, x, y, i, j, ret = 0;
int dshift, size, filter_quant, filter_order;
int tfilter[MAX_PREDICTORS]; int tfilter[MAX_PREDICTORS];
if (get_bits1(gb)) { if (!get_bits1(gb))
s->filter_order = predictor_sizes[get_bits(gb, 4)]; return decode_residues(s, decoded, subframe_size);
filter_order = predictor_sizes[get_bits(gb, 4)];
if (prev_subframe_size > 0 && get_bits1(gb)) { if (prev_subframe_size > 0 && get_bits1(gb)) {
if (s->filter_order > prev_subframe_size) if (filter_order > prev_subframe_size)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
ptr -= s->filter_order; decoded -= filter_order;
subframe_size += s->filter_order; subframe_size += filter_order;
if (s->filter_order > subframe_size) if (filter_order > subframe_size)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} else { } else {
int lpc; int lpc_mode;
if (s->filter_order > subframe_size) if (filter_order > subframe_size)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
lpc = get_bits(gb, 2); lpc_mode = get_bits(gb, 2);
if (lpc > 2) if (lpc_mode > 2)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if ((ret = decode_coeffs(s, ptr, s->filter_order)) < 0) if ((ret = decode_residues(s, decoded, filter_order)) < 0)
return ret; return ret;
decode_lpc(ptr, lpc, s->filter_order); if (lpc_mode)
decode_lpc(decoded, lpc_mode, filter_order);
} }
s->xred = get_bits_esc4(gb); dshift = get_bits_esc4(gb);
s->size = get_bits1(gb) + 5; size = get_bits1(gb) + 6;
filter_quant = 10;
if (get_bits1(gb)) { if (get_bits1(gb)) {
s->ared = get_bits(gb, 3) + 1; filter_quant -= get_bits(gb, 3) + 1;
if (s->ared > 7) if (filter_quant < 3)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} else {
s->ared = 0;
} }
s->predictors[0] = get_sbits(gb, 10); s->predictors[0] = get_sbits(gb, 10);
s->predictors[1] = get_sbits(gb, 10); s->predictors[1] = get_sbits(gb, 10);
s->predictors[2] = get_sbits(gb, s->size + 1) << (9 - s->size); s->predictors[2] = get_sbits(gb, size) << (10 - size);
s->predictors[3] = get_sbits(gb, s->size + 1) << (9 - s->size); s->predictors[3] = get_sbits(gb, size) << (10 - size);
if (s->filter_order > 4) { if (filter_order > 4) {
tmp = s->size + 1 - get_bits1(gb); tmp = size - get_bits1(gb);
for (i = 4; i < s->filter_order; i++) { for (i = 4; i < filter_order; i++) {
if (!(i & 3)) if (!(i & 3))
x = tmp - get_bits(gb, 2); x = tmp - get_bits(gb, 2);
s->predictors[i] = get_sbits(gb, x) << (9 - s->size); s->predictors[i] = get_sbits(gb, x) << (10 - size);
} }
} }
tfilter[0] = s->predictors[0] << 6; tfilter[0] = s->predictors[0] << 6;
for (i = 1; i < s->filter_order; i++) { for (i = 1; i < filter_order; i++) {
int32_t *p1 = &tfilter[0]; int32_t *p1 = &tfilter[0];
int32_t *p2 = &tfilter[i - 1]; int32_t *p2 = &tfilter[i - 1];
@ -471,43 +447,41 @@ static int decode_subframe(TAKDecContext *s, int32_t *ptr, int subframe_size,
tfilter[i] = s->predictors[i] << 6; tfilter[i] = s->predictors[i] << 6;
} }
x = -1 << (32 - (s->ared + 5)); x = 1 << (32 - (15 - filter_quant));
y = 1 << ((s->ared + 5) - 1); y = 1 << ((15 - filter_quant) - 1);
for (i = 0, j = s->filter_order - 1; i < s->filter_order / 2; i++, j--) { for (i = 0, j = filter_order - 1; i < filter_order / 2; i++, j--) {
tmp = y + tfilter[j]; tmp = y + tfilter[j];
s->filter[j] = -(x & -(y + tfilter[i] >> 31) | s->filter[j] = x - ((tfilter[i] + y) >> (15 - filter_quant));
(y + tfilter[i]) >> (s->ared + 5)); s->filter[i] = x - ((tfilter[j] + y) >> (15 - filter_quant));
s->filter[i] = -(x & -(tmp >> 31) | (tmp >> s->ared + 5));
} }
if ((ret = decode_coeffs(s, &ptr[s->filter_order], if ((ret = decode_residues(s, &decoded[filter_order],
subframe_size - s->filter_order)) < 0) subframe_size - filter_order)) < 0)
return ret; return ret;
for (i = 0; i < s->filter_order; i++) for (i = 0; i < filter_order; i++)
s->residues[i] = *ptr++ >> s->xred; s->residues[i] = *decoded++ >> dshift;
y = FF_ARRAY_ELEMS(s->residues) - s->filter_order; y = FF_ARRAY_ELEMS(s->residues) - filter_order;
x = subframe_size - s->filter_order; x = subframe_size - filter_order;
while (x > 0) { while (x > 0) {
tmp = FFMIN(y, x); tmp = FFMIN(y, x);
for (i = 0; i < tmp; i++) { for (i = 0; i < tmp; i++) {
int v, w, m; int v = 1 << (filter_quant - 1);
v = 1 << (10 - s->ared - 1); if (!(filter_order & 15)) {
if (!(s->filter_order & 15)) {
v += s->dsp.scalarproduct_int16(&s->residues[i], s->filter, v += s->dsp.scalarproduct_int16(&s->residues[i], s->filter,
s->filter_order); filter_order);
} else if (s->filter_order & 4) { } else if (filter_order & 4) {
for (j = 0; j < s->filter_order; j += 4) { for (j = 0; j < filter_order; j += 4) {
v += s->residues[i + j + 3] * s->filter[j + 3] + v += s->residues[i + j + 3] * s->filter[j + 3] +
s->residues[i + j + 2] * s->filter[j + 2] + s->residues[i + j + 2] * s->filter[j + 2] +
s->residues[i + j + 1] * s->filter[j + 1] + s->residues[i + j + 1] * s->filter[j + 1] +
s->residues[i + j ] * s->filter[j ]; s->residues[i + j ] * s->filter[j ];
} }
} else { } else {
for (j = 0; j < s->filter_order; j += 8) { for (j = 0; j < filter_order; j += 8) {
v += s->residues[i + j + 7] * s->filter[j + 7] + v += s->residues[i + j + 7] * s->filter[j + 7] +
s->residues[i + j + 6] * s->filter[j + 6] + s->residues[i + j + 6] * s->filter[j + 6] +
s->residues[i + j + 5] * s->filter[j + 5] + s->residues[i + j + 5] * s->filter[j + 5] +
@ -518,39 +492,34 @@ static int decode_subframe(TAKDecContext *s, int32_t *ptr, int subframe_size,
s->residues[i + j ] * s->filter[j ]; s->residues[i + j ] * s->filter[j ];
} }
} }
m = (-1 << (32 - (10 - s->ared))) & -(v >> 31) | (v >> 10 - s->ared); v = (av_clip(v >> filter_quant, -8192, 8191) << dshift) - *decoded;
m = av_clip(m, -8192, 8191); *decoded++ = v;
w = (m << s->xred) - *ptr; s->residues[filter_order + i] = v >> dshift;
*ptr++ = w;
s->residues[s->filter_order + i] = w >> s->xred;
} }
x -= tmp; x -= tmp;
if (x > 0) if (x > 0)
memcpy(s->residues, &s->residues[y], 2 * s->filter_order); memcpy(s->residues, &s->residues[y], 2 * filter_order);
} }
emms_c(); emms_c();
} else {
ret = decode_coeffs(s, ptr, subframe_size);
}
return ret; return 0;
} }
static int decode_channel(TAKDecContext *s, int chan) static int decode_channel(TAKDecContext *s, int chan)
{ {
AVCodecContext *avctx = s->avctx; AVCodecContext *avctx = s->avctx;
GetBitContext *gb = &s->gb; GetBitContext *gb = &s->gb;
int32_t *dst = s->decoded[chan]; int32_t *decoded = s->decoded[chan];
int i = 0, ret, prev = 0;
int left = s->nb_samples - 1; int left = s->nb_samples - 1;
int i = 0, ret, prev = 0;
s->sample_shift[chan] = get_bits_esc4(gb); s->sample_shift[chan] = get_bits_esc4(gb);
if (s->sample_shift[chan] >= avctx->bits_per_raw_sample) if (s->sample_shift[chan] >= avctx->bits_per_raw_sample)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
*dst++ = get_sbits(gb, avctx->bits_per_raw_sample - s->sample_shift[chan]); *decoded++ = get_sbits(gb, avctx->bits_per_raw_sample - s->sample_shift[chan]);
s->lpc_mode[chan] = get_bits(gb, 2); s->lpc_mode[chan] = get_bits(gb, 2);
s->nb_subframes = get_bits(gb, 3) + 1; s->nb_subframes = get_bits(gb, 3) + 1;
@ -572,13 +541,13 @@ static int decode_channel(TAKDecContext *s, int chan)
if (left <= 0) if (left <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
s->subframe_len[i] = left; s->subframe_len[i] = left;
prev = 0; prev = 0;
for (i = 0; i < s->nb_subframes; i++) { for (i = 0; i < s->nb_subframes; i++) {
if ((ret = decode_subframe(s, dst, s->subframe_len[i], prev)) < 0) if ((ret = decode_subframe(s, decoded, s->subframe_len[i], prev)) < 0)
return ret; return ret;
dst += s->subframe_len[i]; decoded += s->subframe_len[i];
prev = s->subframe_len[i]; prev = s->subframe_len[i];
} }
@ -588,101 +557,106 @@ static int decode_channel(TAKDecContext *s, int chan)
static int decorrelate(TAKDecContext *s, int c1, int c2, int length) static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
{ {
GetBitContext *gb = &s->gb; GetBitContext *gb = &s->gb;
uint32_t *p1 = s->decoded[c1] + 1; int32_t *p1 = s->decoded[c1] + 1;
uint32_t *p2 = s->decoded[c2] + 1; int32_t *p2 = s->decoded[c2] + 1;
int a, b, i, x, tmp; int i;
int dshift, dfactor;
if (s->dmode > 3) {
s->dshift = get_bits_esc4(gb);
if (s->dmode > 5) {
if (get_bits1(gb))
s->filter_order = 16;
else
s->filter_order = 8;
s->dval1 = get_bits1(gb);
s->dval2 = get_bits1(gb);
for (i = 0; i < s->filter_order; i++) {
if (!(i & 3))
x = 14 - get_bits(gb, 3);
s->filter[i] = get_sbits(gb, x);
}
} else {
s->dfactor = get_sbits(gb, 10);
}
}
switch (s->dmode) { switch (s->dmode) {
case 1: case 1: /* left/side */
for (i = 0; i < length; i++, p1++, p2++) for (i = 0; i < length; i++) {
*p2 += *p1; int32_t a = p1[i];
int32_t b = p2[i];
p2[i] = a + b;
}
break; break;
case 2: case 2: /* side/right */
for (i = 0; i < length; i++, p1++, p2++) for (i = 0; i < length; i++) {
*p1 = *p2 - *p1; int32_t a = p1[i];
int32_t b = p2[i];
p1[i] = b - a;
}
break; break;
case 3: case 3: /* side/mid */
for (i = 0; i < length; i++, p1++, p2++) { for (i = 0; i < length; i++) {
x = (*p2 & 1) + 2 * *p1; int32_t a = p1[i];
a = -*p2 + x; int32_t b = p2[i];
b = *p2 + x; a -= b >> 1;
*p1 = a & 0x80000000 | (a >> 1); p1[i] = a;
*p2 = b & 0x80000000 | (b >> 1); p2[i] = a + b;
} }
break; break;
case 4: case 4: /* side/left with scale factor */
FFSWAP(uint32_t *, p1, p2); FFSWAP(int32_t*, p1, p2);
case 5: case 5: /* side/right with scale factor */
if (s->dshift) dshift = get_bits_esc4(gb);
tmp = -1 << (32 - s->dshift); dfactor = get_sbits(gb, 10);
else for (i = 0; i < length; i++) {
tmp = 0; int32_t a = p1[i];
int32_t b = p2[i];
for (i = 0; i < length; i++, p1++, p2++) { b = dfactor * (b >> dshift) + 128 >> 8 << dshift;
x = s->dfactor * (tmp & -(*p2 >> 31) | (*p2 >> s->dshift)) + 128; p1[i] = b - a;
*p1 = ((-(x >> 31) & 0xFF000000 | (x >> 8)) << s->dshift) - *p1;
} }
break; break;
case 6: case 6:
FFSWAP(uint32_t *, p1, p2); FFSWAP(int32_t*, p1, p2);
case 7: case 7: {
int length2, order_half, filter_order, dval1, dval2;
int tmp, x, code_size;
if (length < 256) if (length < 256)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
a = s->filter_order / 2; dshift = get_bits_esc4(gb);
b = length - (s->filter_order - 1); filter_order = 8 << get_bits1(gb);
dval1 = get_bits1(gb);
dval2 = get_bits1(gb);
if (s->dval1) { for (i = 0; i < filter_order; i++) {
for (i = 0; i < a; i++) if (!(i & 3))
p1[i] += p2[i]; code_size = 14 - get_bits(gb, 3);
s->filter[i] = get_sbits(gb, code_size);
} }
if (s->dval2) { order_half = filter_order / 2;
x = a + b; length2 = length - (filter_order - 1);
for (i = 0; i < length - x; i++)
p1[x + i] += p2[x + i]; /* decorrelate beginning samples */
if (dval1) {
for (i = 0; i < order_half; i++) {
int32_t a = p1[i];
int32_t b = p2[i];
p1[i] = a + b;
}
} }
for (i = 0; i < s->filter_order; i++) /* decorrelate ending samples */
s->residues[i] = *p2++ >> s->dshift; if (dval2) {
for (i = length2 + order_half; i < length; i++) {
int32_t a = p1[i];
int32_t b = p2[i];
p1[i] = a + b;
}
}
for (i = 0; i < filter_order; i++)
s->residues[i] = *p2++ >> dshift;
p1 += a; p1 += order_half;
x = FF_ARRAY_ELEMS(s->residues) - s->filter_order; x = FF_ARRAY_ELEMS(s->residues) - filter_order;
for (; b > 0; b -= tmp) { for (; length2 > 0; length2 -= tmp) {
tmp = FFMIN(b, x); tmp = FFMIN(length2, x);
for (i = 0; i < tmp; i++) for (i = 0; i < tmp; i++)
s->residues[s->filter_order + i] = *p2++ >> s->dshift; s->residues[filter_order + i] = *p2++ >> dshift;
for (i = 0; i < tmp; i++) { for (i = 0; i < tmp; i++) {
int v, w, m; int v = 1 << 9;
v = 1 << 9; if (filter_order == 16) {
if (s->filter_order == 16) {
v += s->dsp.scalarproduct_int16(&s->residues[i], s->filter, v += s->dsp.scalarproduct_int16(&s->residues[i], s->filter,
s->filter_order); filter_order);
} else { } else {
v += s->residues[i + 7] * s->filter[7] + v += s->residues[i + 7] * s->filter[7] +
s->residues[i + 6] * s->filter[6] + s->residues[i + 6] * s->filter[6] +
@ -694,18 +668,16 @@ static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
s->residues[i ] * s->filter[0]; s->residues[i ] * s->filter[0];
} }
m = (-1 << 22) & -(v >> 31) | (v >> 10); *p1++ = (av_clip(v >> 10, -8192, 8191) << dshift) - *p1;
m = av_clip(m, -8192, 8191);
w = (m << s->dshift) - *p1;
*p1++ = w;
} }
memcpy(s->residues, &s->residues[tmp], 2 * s->filter_order); memcpy(s->residues, &s->residues[tmp], 2 * filter_order);
} }
emms_c(); emms_c();
break; break;
} }
}
return 0; return 0;
} }
@ -716,7 +688,6 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
TAKDecContext *s = avctx->priv_data; TAKDecContext *s = avctx->priv_data;
GetBitContext *gb = &s->gb; GetBitContext *gb = &s->gb;
int chan, i, ret, hsize; int chan, i, ret, hsize;
int32_t *p;
if (pkt->size < TAK_MIN_FRAME_HEADER_BYTES) if (pkt->size < TAK_MIN_FRAME_HEADER_BYTES)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -734,20 +705,24 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
} }
} }
if (s->ti.codec != 2 && s->ti.codec != 4) { if (s->ti.codec != TAK_CODEC_MONO_STEREO &&
s->ti.codec != TAK_CODEC_MULTICHANNEL) {
av_log(avctx, AV_LOG_ERROR, "unsupported codec: %d\n", s->ti.codec); av_log(avctx, AV_LOG_ERROR, "unsupported codec: %d\n", s->ti.codec);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
if (s->ti.data_type) { if (s->ti.data_type) {
av_log(avctx, AV_LOG_ERROR, "unsupported data type: %d\n", s->ti.data_type); av_log(avctx, AV_LOG_ERROR,
"unsupported data type: %d\n", s->ti.data_type);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (s->ti.codec == 2 && s->ti.channels > 2) { if (s->ti.codec == TAK_CODEC_MONO_STEREO && s->ti.channels > 2) {
av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n", s->ti.channels); av_log(avctx, AV_LOG_ERROR,
"invalid number of channels: %d\n", s->ti.channels);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (s->ti.channels > 6) { if (s->ti.channels > 6) {
av_log(avctx, AV_LOG_ERROR, "unsupported number of channels: %d\n", s->ti.channels); av_log(avctx, AV_LOG_ERROR,
"unsupported number of channels: %d\n", s->ti.channels);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -769,8 +744,8 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
avctx->channel_layout = s->ti.ch_layout; avctx->channel_layout = s->ti.ch_layout;
avctx->channels = s->ti.channels; avctx->channels = s->ti.channels;
s->nb_samples = s->ti.last_frame_samples ? s->ti.last_frame_samples : s->nb_samples = s->ti.last_frame_samples ? s->ti.last_frame_samples
s->ti.frame_samples; : s->ti.frame_samples;
s->frame.nb_samples = s->nb_samples; s->frame.nb_samples = s->nb_samples;
if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) if ((ret = ff_get_buffer(avctx, &s->frame)) < 0)
@ -790,32 +765,32 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
return ret; return ret;
} else { } else {
for (chan = 0; chan < avctx->channels; chan++) for (chan = 0; chan < avctx->channels; chan++)
s->decoded[chan] = (int32_t *)s->frame.data[chan]; s->decoded[chan] = (int32_t *)s->frame.extended_data[chan];
} }
if (s->nb_samples < 16) { if (s->nb_samples < 16) {
for (chan = 0; chan < avctx->channels; chan++) { for (chan = 0; chan < avctx->channels; chan++) {
p = s->decoded[chan]; int32_t *decoded = s->decoded[chan];
for (i = 0; i < s->nb_samples; i++) for (i = 0; i < s->nb_samples; i++)
*p++ = get_sbits(gb, avctx->bits_per_raw_sample); decoded[i] = get_sbits(gb, avctx->bits_per_raw_sample);
} }
} else { } else {
if (s->ti.codec == 2) { if (s->ti.codec == TAK_CODEC_MONO_STEREO) {
for (chan = 0; chan < avctx->channels; chan++) { for (chan = 0; chan < avctx->channels; chan++)
if (ret = decode_channel(s, chan)) if (ret = decode_channel(s, chan))
return ret; return ret;
}
if (avctx->channels == 2) { if (avctx->channels == 2) {
s->nb_subframes = get_bits(gb, 1) + 1; s->nb_subframes = get_bits(gb, 1) + 1;
if (s->nb_subframes > 1) if (s->nb_subframes > 1) {
s->subframe_len[1] = get_bits(gb, 6); s->subframe_len[1] = get_bits(gb, 6);
}
s->dmode = get_bits(gb, 3); s->dmode = get_bits(gb, 3);
if (ret = decorrelate(s, 0, 1, s->nb_samples - 1)) if (ret = decorrelate(s, 0, 1, s->nb_samples - 1))
return ret; return ret;
} }
} else if (s->ti.codec == 4) { } else if (s->ti.codec == TAK_CODEC_MULTICHANNEL) {
if (get_bits1(gb)) { if (get_bits1(gb)) {
int ch_mask = 0; int ch_mask = 0;
@ -859,17 +834,17 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
} }
for (i = 0; i < chan; i++) { for (i = 0; i < chan; i++) {
if (s->mcdparams[i].present && s->mcdparams[i].index == 1) { if (s->mcdparams[i].present && s->mcdparams[i].index == 1)
if (ret = decode_channel(s, s->mcdparams[i].chan2)) if (ret = decode_channel(s, s->mcdparams[i].chan2))
return ret; return ret;
}
if (ret = decode_channel(s, s->mcdparams[i].chan1)) if (ret = decode_channel(s, s->mcdparams[i].chan1))
return ret; return ret;
if (s->mcdparams[i].present) { if (s->mcdparams[i].present) {
s->dmode = mc_dmodes[s->mcdparams[i].index]; s->dmode = mc_dmodes[s->mcdparams[i].index];
if (ret = decorrelate(s, s->mcdparams[i].chan2, if (ret = decorrelate(s,
s->mcdparams[i].chan2,
s->mcdparams[i].chan1, s->mcdparams[i].chan1,
s->nb_samples - 1)) s->nb_samples - 1))
return ret; return ret;
@ -878,13 +853,14 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
} }
for (chan = 0; chan < avctx->channels; chan++) { for (chan = 0; chan < avctx->channels; chan++) {
p = s->decoded[chan]; int32_t *decoded = s->decoded[chan];
decode_lpc(p, s->lpc_mode[chan], s->nb_samples);
if (s->lpc_mode[chan])
decode_lpc(decoded, s->lpc_mode[chan], s->nb_samples);
if (s->sample_shift[chan] > 0) { if (s->sample_shift[chan] > 0)
for (i = 0; i < s->nb_samples; i++) for (i = 0; i < s->nb_samples; i++)
*p++ <<= s->sample_shift[chan]; decoded[i] <<= s->sample_shift[chan];
}
} }
} }
@ -903,29 +879,29 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
} }
} }
// convert to output buffer /* convert to output buffer */
switch (avctx->bits_per_raw_sample) { switch (avctx->sample_fmt) {
case 8: case AV_SAMPLE_FMT_U8P:
for (chan = 0; chan < avctx->channels; chan++) { for (chan = 0; chan < avctx->channels; chan++) {
uint8_t *samples = (uint8_t *)s->frame.data[chan]; uint8_t *samples = (uint8_t *)s->frame.extended_data[chan];
p = s->decoded[chan]; int32_t *decoded = s->decoded[chan];
for (i = 0; i < s->nb_samples; i++, p++) for (i = 0; i < s->nb_samples; i++)
*samples++ = *p + 0x80; samples[i] = decoded[i] + 0x80;
} }
break; break;
case 16: case AV_SAMPLE_FMT_S16P:
for (chan = 0; chan < avctx->channels; chan++) { for (chan = 0; chan < avctx->channels; chan++) {
int16_t *samples = (int16_t *)s->frame.data[chan]; int16_t *samples = (int16_t *)s->frame.extended_data[chan];
p = s->decoded[chan]; int32_t *decoded = s->decoded[chan];
for (i = 0; i < s->nb_samples; i++, p++) for (i = 0; i < s->nb_samples; i++)
*samples++ = *p; samples[i] = decoded[i];
} }
break; break;
case 24: case AV_SAMPLE_FMT_S32P:
for (chan = 0; chan < avctx->channels; chan++) { for (chan = 0; chan < avctx->channels; chan++) {
int32_t *samples = (int32_t *)s->frame.data[chan]; int32_t *samples = (int32_t *)s->frame.extended_data[chan];
for (i = 0; i < s->nb_samples; i++) for (i = 0; i < s->nb_samples; i++)
*samples++ <<= 8; samples[i] <<= 8;
} }
break; break;
} }

1
libavformat/takdec.c
Unescape View File

@ -106,7 +106,6 @@ static int tak_read_header(AVFormatContext *s)
tc->data_end += curpos; tc->data_end += curpos;
return 0; return 0;
break;
} }
default: default:
ret = avio_skip(pb, size); ret = avio_skip(pb, size);

Write Preview
Loading…
Cancel
Save