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

8svx/iff: fix decoding of compressed stereo 8svx files.

Browse Source 
Make the iff demuxer send the whole audio chunk to the decoder as a
single packet and move stereo interleaving from the iff demuxer to the
decoder.

Based on a patch by Stefano Sabatini.
git.videolan.org/ffmpeg.git
commit e280a4da2a
pull/2/head
Justin Ruggles 13 years ago
parent fda459cee7
commit 1993c6849c
2 changed files with 88 additions and 58 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. 101
      libavcodec/8svx.c
  2. 43
      libavformat/iff.c

101
libavcodec/8svx.c
Unescape View File

@ -32,8 +32,14 @@
/** decoder context */ /** decoder context */
typedef struct EightSvxContext { typedef struct EightSvxContext {
uint8_t fib_acc; uint8_t fib_acc[2];
const int8_t *table; const int8_t *table;
/* buffer used to store the whole first packet.
data is only sent as one large packet */
uint8_t *data[2];
int data_size;
int data_idx;
} EightSvxContext; } EightSvxContext;
static const int8_t fibonacci[16] = { -34, -21, -13, -8, -5, -3, -2, -1, static const int8_t fibonacci[16] = { -34, -21, -13, -8, -5, -3, -2, -1,
@ -41,6 +47,8 @@ static const int8_t fibonacci[16] = { -34, -21, -13, -8, -5, -3, -2, -1,
static const int8_t exponential[16] = { -128, -64, -32, -16, -8, -4, -2, -1, static const int8_t exponential[16] = { -128, -64, -32, -16, -8, -4, -2, -1,
0, 1, 2, 4, 8, 16, 32, 64 }; 0, 1, 2, 4, 8, 16, 32, 64 };
#define MAX_FRAME_SIZE 32768
/** /**
* Delta decode the compressed values in src, and put the resulting * Delta decode the compressed values in src, and put the resulting
* decoded samples in dst. * decoded samples in dst.
@ -48,16 +56,18 @@ static const int8_t exponential[16] = { -128, -64, -32, -16, -8, -4, -2, -1,
* @param[in,out] state starting value. it is saved for use in the next call. * @param[in,out] state starting value. it is saved for use in the next call.
*/ */
static void delta_decode(uint8_t *dst, const uint8_t *src, int src_size, static void delta_decode(uint8_t *dst, const uint8_t *src, int src_size,
uint8_t *state, const int8_t *table) uint8_t *state, const int8_t *table, int channels)
{ {
uint8_t val = *state; uint8_t val = *state;
while (src_size--) { while (src_size--) {
uint8_t d = *src++; uint8_t d = *src++;
val = av_clip_uint8(val + table[d & 0xF]); val = av_clip_uint8(val + table[d & 0xF]);
*dst++ = val; *dst = val;
dst += channels;
val = av_clip_uint8(val + table[d >> 4]); val = av_clip_uint8(val + table[d >> 4]);
*dst++ = val; *dst = val;
dst += channels;
} }
*state = val; *state = val;
@ -67,33 +77,69 @@ static void delta_decode(uint8_t *dst, const uint8_t *src, int src_size,
static int eightsvx_decode_frame(AVCodecContext *avctx, void *data, int *data_size, static int eightsvx_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt) AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
EightSvxContext *esc = avctx->priv_data; EightSvxContext *esc = avctx->priv_data;
int buf_size;
uint8_t *out_data = data; uint8_t *out_data = data;
int consumed = buf_size; int out_data_size;
/* for the first packet, copy data to buffer */
if (avpkt->data) {
int chan_size = (avpkt->size / avctx->channels) - 2;
if(avctx->frame_number == 0) { if (avpkt->size < 2) {
if (buf_size < 2) {
av_log(avctx, AV_LOG_ERROR, "packet size is too small\n"); av_log(avctx, AV_LOG_ERROR, "packet size is too small\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
esc->fib_acc = (int8_t)buf[1] + 128; if (esc->data[0]) {
buf_size -= 2; av_log(avctx, AV_LOG_ERROR, "unexpected data after first packet\n");
buf += 2; return AVERROR(EINVAL);
}
esc->fib_acc[0] = avpkt->data[1] + 128;
if (avctx->channels == 2)
esc->fib_acc[1] = avpkt->data[2+chan_size+1] + 128;
esc->data_idx = 0;
esc->data_size = chan_size;
if (!(esc->data[0] = av_malloc(chan_size)))
return AVERROR(ENOMEM);
if (avctx->channels == 2) {
if (!(esc->data[1] = av_malloc(chan_size))) {
av_freep(&esc->data[0]);
return AVERROR(ENOMEM);
}
}
memcpy(esc->data[0], &avpkt->data[2], chan_size);
if (avctx->channels == 2)
memcpy(esc->data[1], &avpkt->data[2+chan_size+2], chan_size);
}
if (!esc->data[0]) {
av_log(avctx, AV_LOG_ERROR, "unexpected empty packet\n");
return AVERROR(EINVAL);
} }
if (*data_size < buf_size * 2) { /* decode next piece of data from the buffer */
buf_size = FFMIN(MAX_FRAME_SIZE, esc->data_size - esc->data_idx);
if (buf_size <= 0) {
*data_size = 0;
return avpkt->size;
}
out_data_size = buf_size * 2 * avctx->channels;
if (*data_size < out_data_size) {
av_log(avctx, AV_LOG_ERROR, "Provided buffer with size %d is too small.\n", av_log(avctx, AV_LOG_ERROR, "Provided buffer with size %d is too small.\n",
*data_size); *data_size);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
delta_decode(out_data, &esc->data[0][esc->data_idx], buf_size,
&esc->fib_acc[0], esc->table, avctx->channels);
if (avctx->channels == 2) {
delta_decode(&out_data[1], &esc->data[1][esc->data_idx], buf_size,
&esc->fib_acc[1], esc->table, avctx->channels);
}
esc->data_idx += buf_size;
*data_size = out_data_size;
delta_decode(out_data, buf, buf_size, &esc->fib_acc, esc->table); return avpkt->size;
*data_size = buf_size * 2;
return consumed;
} }
/** initialize 8svx decoder */ /** initialize 8svx decoder */
@ -101,6 +147,11 @@ static av_cold int eightsvx_decode_init(AVCodecContext *avctx)
{ {
EightSvxContext *esc = avctx->priv_data; EightSvxContext *esc = avctx->priv_data;
if (avctx->channels < 1 || avctx->channels > 2) {
av_log(avctx, AV_LOG_ERROR, "8SVX does not support more than 2 channels\n");
return AVERROR(EINVAL);
}
switch(avctx->codec->id) { switch(avctx->codec->id) {
case CODEC_ID_8SVX_FIB: case CODEC_ID_8SVX_FIB:
esc->table = fibonacci; esc->table = fibonacci;
@ -115,13 +166,25 @@ static av_cold int eightsvx_decode_init(AVCodecContext *avctx)
return 0; return 0;
} }
static av_cold int eightsvx_decode_close(AVCodecContext *avctx)
{
EightSvxContext *esc = avctx->priv_data;
av_freep(&esc->data[0]);
av_freep(&esc->data[1]);
return 0;
}
AVCodec ff_eightsvx_fib_decoder = { AVCodec ff_eightsvx_fib_decoder = {
.name = "8svx_fib", .name = "8svx_fib",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_8SVX_FIB, .id = CODEC_ID_8SVX_FIB,
.priv_data_size = sizeof (EightSvxContext), .priv_data_size = sizeof (EightSvxContext),
.init = eightsvx_decode_init, .init = eightsvx_decode_init,
.close = eightsvx_decode_close,
.decode = eightsvx_decode_frame, .decode = eightsvx_decode_frame,
.capabilities = CODEC_CAP_DELAY,
.long_name = NULL_IF_CONFIG_SMALL("8SVX fibonacci"), .long_name = NULL_IF_CONFIG_SMALL("8SVX fibonacci"),
}; };
@ -131,6 +194,8 @@ AVCodec ff_eightsvx_exp_decoder = {
.id = CODEC_ID_8SVX_EXP, .id = CODEC_ID_8SVX_EXP,
.priv_data_size = sizeof (EightSvxContext), .priv_data_size = sizeof (EightSvxContext),
.init = eightsvx_decode_init, .init = eightsvx_decode_init,
.close = eightsvx_decode_close,
.decode = eightsvx_decode_frame, .decode = eightsvx_decode_frame,
.capabilities = CODEC_CAP_DELAY,
.long_name = NULL_IF_CONFIG_SMALL("8SVX exponential"), .long_name = NULL_IF_CONFIG_SMALL("8SVX exponential"),
}; };

43
libavformat/iff.c
Unescape View File

@ -59,8 +59,6 @@
#define RIGHT 4 #define RIGHT 4
#define STEREO 6 #define STEREO 6
#define PACKET_SIZE 1024
typedef enum { typedef enum {
COMP_NONE, COMP_NONE,
COMP_FIB, COMP_FIB,
@ -76,22 +74,9 @@ typedef struct {
uint64_t body_pos; uint64_t body_pos;
uint32_t body_size; uint32_t body_size;
uint32_t sent_bytes; uint32_t sent_bytes;
uint32_t audio_frame_count;
} IffDemuxContext; } IffDemuxContext;
static void interleave_stereo(const uint8_t *src, uint8_t *dest, int size)
{
uint8_t *end = dest + size;
size = size>>1;
while(dest < end) {
*dest++ = *src;
*dest++ = *(src+size);
src++;
}
}
/* Metadata string read */ /* Metadata string read */
static int get_metadata(AVFormatContext *s, static int get_metadata(AVFormatContext *s,
const char *const tag, const char *const tag,
@ -278,40 +263,20 @@ static int iff_read_packet(AVFormatContext *s,
{ {
IffDemuxContext *iff = s->priv_data; IffDemuxContext *iff = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVStream *st = s->streams[0];
int ret; int ret;
if(iff->sent_bytes >= iff->body_size) if(iff->sent_bytes >= iff->body_size)
return AVERROR(EIO); return AVERROR_EOF;
if(st->codec->channels == 2) {
uint8_t sample_buffer[PACKET_SIZE];
ret = avio_read(pb, sample_buffer, PACKET_SIZE);
if(av_new_packet(pkt, PACKET_SIZE) < 0) {
av_log(s, AV_LOG_ERROR, "cannot allocate packet\n");
return AVERROR(ENOMEM);
}
interleave_stereo(sample_buffer, pkt->data, PACKET_SIZE);
} else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
ret = av_get_packet(pb, pkt, iff->body_size); ret = av_get_packet(pb, pkt, iff->body_size);
} else { if (ret < 0)
ret = av_get_packet(pb, pkt, PACKET_SIZE); return ret;
}
if(iff->sent_bytes == 0) if(iff->sent_bytes == 0)
pkt->flags |= AV_PKT_FLAG_KEY; pkt->flags |= AV_PKT_FLAG_KEY;
if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
iff->sent_bytes += PACKET_SIZE;
} else {
iff->sent_bytes = iff->body_size; iff->sent_bytes = iff->body_size;
}
pkt->stream_index = 0; pkt->stream_index = 0;
if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
pkt->pts = iff->audio_frame_count;
iff->audio_frame_count += ret / st->codec->channels;
}
return ret; return ret;
} }

Write Preview
Loading…
Cancel
Save