* @author Alex Beregszaszi
*/
-#define BITSTREAM_READER_LE
-//#define DEBUG
#include <limits.h>
-#include "avcodec.h"
-#include "get_bits.h"
+
#include "libavutil/crc.h"
+#define BITSTREAM_READER_LE
+#include "avcodec.h"
+#include "bitstream.h"
+#include "internal.h"
+#include "unary.h"
+
#define FORMAT_SIMPLE 1
#define FORMAT_ENCRYPTED 2
typedef struct TTAContext {
AVCodecContext *avctx;
- AVFrame frame;
- GetBitContext gb;
+ BitstreamContext bc;
const AVCRC *crc_table;
int format, channels, bps;
unsigned data_length;
- int frame_length, last_frame_length, total_frames;
+ int frame_length, last_frame_length;
int32_t *decode_buffer;
c->sum1 = shift_16[k1];
}
-static int tta_get_unary(GetBitContext *gb)
-{
- int ret = 0;
-
- // count ones
- while (get_bits_left(gb) > 0 && get_bits1(gb))
- ret++;
- return ret;
-}
-
static int tta_check_crc(TTAContext *s, const uint8_t *buf, int buf_size)
{
uint32_t crc, CRC;
static av_cold int tta_decode_init(AVCodecContext * avctx)
{
TTAContext *s = avctx->priv_data;
+ int total_frames;
s->avctx = avctx;
if (avctx->extradata_size < 30)
return -1;
- init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
- if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
- {
+ bitstream_init8(&s->bc, avctx->extradata, avctx->extradata_size);
+ if (bitstream_peek(&s->bc, 32) == AV_RL32("TTA1")) {
if (avctx->err_recognition & AV_EF_CRCCHECK) {
s->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);
tta_check_crc(s, avctx->extradata, 18);
}
/* signature */
- skip_bits_long(&s->gb, 32);
+ bitstream_skip(&s->bc, 32);
- s->format = get_bits(&s->gb, 16);
+ s->format = bitstream_read(&s->bc, 16);
if (s->format > 2) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid format\n");
return -1;
}
if (s->format == FORMAT_ENCRYPTED) {
- av_log_missing_feature(s->avctx, "Encrypted TTA", 0);
- return AVERROR(EINVAL);
+ avpriv_report_missing_feature(s->avctx, "Encrypted TTA");
+ return AVERROR_PATCHWELCOME;
}
- avctx->channels = s->channels = get_bits(&s->gb, 16);
- avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
+ avctx->channels =
+ s->channels = bitstream_read(&s->bc, 16);
+ avctx->bits_per_coded_sample = bitstream_read(&s->bc, 16);
s->bps = (avctx->bits_per_coded_sample + 7) / 8;
- avctx->sample_rate = get_bits_long(&s->gb, 32);
- s->data_length = get_bits_long(&s->gb, 32);
- skip_bits_long(&s->gb, 32); // CRC32 of header
+ avctx->sample_rate = bitstream_read(&s->bc, 32);
+ s->data_length = bitstream_read(&s->bc, 32);
+ bitstream_skip(&s->bc, 32); // CRC32 of header
if (s->channels == 0) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
s->frame_length = 256 * avctx->sample_rate / 245;
s->last_frame_length = s->data_length % s->frame_length;
- s->total_frames = s->data_length / s->frame_length +
- (s->last_frame_length ? 1 : 0);
+ total_frames = s->data_length / s->frame_length +
+ (s->last_frame_length ? 1 : 0);
av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
avctx->block_align);
av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
- s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
+ s->data_length, s->frame_length, s->last_frame_length, total_frames);
// FIXME: seek table
- if (avctx->extradata_size <= 26 || s->total_frames > INT_MAX / 4 ||
- avctx->extradata_size - 26 < s->total_frames * 4)
+ if (avctx->extradata_size <= 26 || total_frames > INT_MAX / 4 ||
+ avctx->extradata_size - 26 < total_frames * 4)
av_log(avctx, AV_LOG_WARNING, "Seek table missing or too small\n");
else if (avctx->err_recognition & AV_EF_CRCCHECK) {
- if (tta_check_crc(s, avctx->extradata + 22, s->total_frames * 4))
+ int ret = tta_check_crc(s, avctx->extradata + 22, total_frames * 4);
+ if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE)
return AVERROR_INVALIDDATA;
}
- skip_bits_long(&s->gb, 32 * s->total_frames);
- skip_bits_long(&s->gb, 32); // CRC32 of seektable
+ bitstream_skip(&s->bc, 32 * total_frames);
+ bitstream_skip(&s->bc, 32); // CRC32 of seektable
if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
return -1;
}
- avcodec_get_frame_defaults(&s->frame);
- avctx->coded_frame = &s->frame;
-
return 0;
}
static int tta_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
+ AVFrame *frame = data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
TTAContext *s = avctx->priv_data;
int32_t *p;
if (avctx->err_recognition & AV_EF_CRCCHECK) {
- if (buf_size < 4 || tta_check_crc(s, buf, buf_size - 4))
+ if (buf_size < 4 ||
+ (tta_check_crc(s, buf, buf_size - 4) && avctx->err_recognition & AV_EF_EXPLODE))
return AVERROR_INVALIDDATA;
}
- init_get_bits(&s->gb, buf, buf_size*8);
-
- // FIXME: seeking
- s->total_frames--;
- if (!s->total_frames && s->last_frame_length)
- framelen = s->last_frame_length;
+ bitstream_init8(&s->bc, buf, buf_size);
/* get output buffer */
- s->frame.nb_samples = framelen;
- if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
+ frame->nb_samples = framelen;
+ if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
// decode directly to output buffer for 24-bit sample format
if (s->bps == 3)
- s->decode_buffer = (int32_t *)s->frame.data[0];
+ s->decode_buffer = (int32_t *)frame->data[0];
// init per channel states
for (i = 0; i < s->channels; i++) {
rice_init(&s->ch_ctx[i].rice, 10, 10);
}
+ i = 0;
for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
uint32_t unary, depth, k;
int32_t value;
- unary = tta_get_unary(&s->gb);
+ unary = get_unary(&s->bc, 0, bitstream_bits_left(&s->bc));
if (unary == 0) {
depth = 0;
unary--;
}
- if (get_bits_left(&s->gb) < k) {
+ if (bitstream_bits_left(&s->bc) < k) {
ret = AVERROR_INVALIDDATA;
goto error;
}
if (k) {
- if (k > MIN_CACHE_BITS) {
+ if (k >= 32 || unary > INT32_MAX >> k) {
ret = AVERROR_INVALIDDATA;
goto error;
}
- value = (unary << k) + get_bits(&s->gb, k);
+ value = (unary << k) + bitstream_read(&s->bc, k);
} else
value = unary;
*r = *(r + 1) - *r;
}
cur_chan = 0;
+ i++;
+ // check for last frame
+ if (i == s->last_frame_length && bitstream_bits_left(&s->bc) / 8 == 4) {
+ frame->nb_samples = framelen = s->last_frame_length;
+ break;
+ }
}
}
- if (get_bits_left(&s->gb) < 32) {
+ bitstream_align(&s->bc);
+ if (bitstream_bits_left(&s->bc) < 32) {
ret = AVERROR_INVALIDDATA;
goto error;
}
- skip_bits_long(&s->gb, 32); // frame crc
+ bitstream_skip(&s->bc, 32); // frame CRC
// convert to output buffer
if (s->bps == 2) {
- int16_t *samples = (int16_t *)s->frame.data[0];
+ int16_t *samples = (int16_t *)frame->data[0];
for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
*samples++ = *p;
} else {
// shift samples for 24-bit sample format
- int32_t *samples = (int32_t *)s->frame.data[0];
+ int32_t *samples = (int32_t *)frame->data[0];
for (i = 0; i < framelen * s->channels; i++)
*samples++ <<= 8;
// reset decode buffer
s->decode_buffer = NULL;
}
- *got_frame_ptr = 1;
- *(AVFrame *)data = s->frame;
+ *got_frame_ptr = 1;
return buf_size;
error:
AVCodec ff_tta_decoder = {
.name = "tta",
+ .long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
.type = AVMEDIA_TYPE_AUDIO,
- .id = CODEC_ID_TTA,
+ .id = AV_CODEC_ID_TTA,
.priv_data_size = sizeof(TTAContext),
.init = tta_decode_init,
.close = tta_decode_close,
.decode = tta_decode_frame,
- .capabilities = CODEC_CAP_DR1,
- .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
+ .capabilities = AV_CODEC_CAP_DR1,
};
projects / ffmpeg / blobdiff