mirror of https://github.com/FFmpeg/FFmpeg.git
Signed-off-by: Vittorio Giovara <vittorio.giovara@gmail.com> Signed-off-by: Luca Barbato <lu_zero@gentoo.org>pull/64/head
Paul B Mahol
11 years ago
committed by
Vittorio Giovara
parent
d37c96213a
commit
70daeacd6e
12 changed files with 746 additions and 2 deletions
@ -0,0 +1,450 @@ |
||||
/*
|
||||
* Packed Animation File video and audio decoder |
||||
* Copyright (c) 2012 Paul B Mahol |
||||
* |
||||
* This file is part of Libav. |
||||
* |
||||
* Libav 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. |
||||
* |
||||
* Libav 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 Libav; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#include "libavutil/imgutils.h" |
||||
#include "libavutil/intreadwrite.h" |
||||
|
||||
#include "avcodec.h" |
||||
#include "bytestream.h" |
||||
#include "copy_block.h" |
||||
#include "internal.h" |
||||
#include "mathops.h" |
||||
|
||||
#define PAF_SOUND_SAMPLES 2205 |
||||
#define PAF_SOUND_FRAME_SIZE ((256 + PAF_SOUND_SAMPLES) * 2) |
||||
|
||||
static const uint8_t block_sequences[16][8] = { |
||||
{ 0, 0, 0, 0, 0, 0, 0, 0 }, { 2, 0, 0, 0, 0, 0, 0, 0 }, |
||||
{ 5, 7, 0, 0, 0, 0, 0, 0 }, { 5, 0, 0, 0, 0, 0, 0, 0 }, |
||||
{ 6, 0, 0, 0, 0, 0, 0, 0 }, { 5, 7, 5, 7, 0, 0, 0, 0 }, |
||||
{ 5, 7, 5, 0, 0, 0, 0, 0 }, { 5, 7, 6, 0, 0, 0, 0, 0 }, |
||||
{ 5, 5, 0, 0, 0, 0, 0, 0 }, { 3, 0, 0, 0, 0, 0, 0, 0 }, |
||||
{ 6, 6, 0, 0, 0, 0, 0, 0 }, { 2, 4, 0, 0, 0, 0, 0, 0 }, |
||||
{ 2, 4, 5, 7, 0, 0, 0, 0 }, { 2, 4, 5, 0, 0, 0, 0, 0 }, |
||||
{ 2, 4, 6, 0, 0, 0, 0, 0 }, { 2, 4, 5, 7, 5, 7, 0, 0 }, |
||||
}; |
||||
|
||||
typedef struct PAFVideoDecContext { |
||||
AVFrame *pic; |
||||
GetByteContext gb; |
||||
|
||||
int width; |
||||
int height; |
||||
|
||||
int current_frame; |
||||
uint8_t *frame[4]; |
||||
int frame_size; |
||||
int video_size; |
||||
|
||||
uint8_t *opcodes; |
||||
} PAFVideoDecContext; |
||||
|
||||
static av_cold int paf_video_close(AVCodecContext *avctx) |
||||
{ |
||||
PAFVideoDecContext *c = avctx->priv_data; |
||||
int i; |
||||
|
||||
av_frame_free(&c->pic); |
||||
|
||||
for (i = 0; i < 4; i++) |
||||
av_freep(&c->frame[i]); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static av_cold int paf_video_init(AVCodecContext *avctx) |
||||
{ |
||||
PAFVideoDecContext *c = avctx->priv_data; |
||||
int i; |
||||
|
||||
c->width = avctx->width; |
||||
c->height = avctx->height; |
||||
|
||||
if (avctx->height & 3 || avctx->width & 3) { |
||||
av_log(avctx, AV_LOG_ERROR, |
||||
"width %d and height %d must be multiplie of 4.\n", |
||||
avctx->width, avctx->height); |
||||
return AVERROR_INVALIDDATA; |
||||
} |
||||
|
||||
avctx->pix_fmt = AV_PIX_FMT_PAL8; |
||||
|
||||
c->pic = av_frame_alloc(); |
||||
if (!c->pic) |
||||
return AVERROR(ENOMEM); |
||||
|
||||
c->frame_size = avctx->width * FFALIGN(avctx->height, 256); |
||||
c->video_size = avctx->width * avctx->height; |
||||
for (i = 0; i < 4; i++) { |
||||
c->frame[i] = av_mallocz(c->frame_size); |
||||
if (!c->frame[i]) { |
||||
paf_video_close(avctx); |
||||
return AVERROR(ENOMEM); |
||||
} |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void read4x4block(PAFVideoDecContext *c, uint8_t *dst, int width) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < 4; i++) { |
||||
bytestream2_get_buffer(&c->gb, dst, 4); |
||||
dst += width; |
||||
} |
||||
} |
||||
|
||||
static void copy_color_mask(uint8_t *dst, int width, uint8_t mask, uint8_t color) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < 4; i++) { |
||||
if (mask & (1 << 7 - i)) |
||||
dst[i] = color; |
||||
if (mask & (1 << 3 - i)) |
||||
dst[width + i] = color; |
||||
} |
||||
} |
||||
|
||||
static void copy_src_mask(uint8_t *dst, int width, uint8_t mask, const uint8_t *src) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < 4; i++) { |
||||
if (mask & (1 << 7 - i)) |
||||
dst[i] = src[i]; |
||||
if (mask & (1 << 3 - i)) |
||||
dst[width + i] = src[width + i]; |
||||
} |
||||
} |
||||
|
||||
static void set_src_position(PAFVideoDecContext *c, |
||||
const uint8_t **p, |
||||
const uint8_t **pend) |
||||
{ |
||||
int val = bytestream2_get_be16(&c->gb); |
||||
int page = val >> 14; |
||||
int x = (val & 0x7F); |
||||
int y = ((val >> 7) & 0x7F); |
||||
|
||||
*p = c->frame[page] + x * 2 + y * 2 * c->width; |
||||
*pend = c->frame[page] + c->frame_size; |
||||
} |
||||
|
||||
static int decode_0(PAFVideoDecContext *c, uint8_t *pkt, uint8_t code) |
||||
{ |
||||
uint32_t opcode_size, offset; |
||||
uint8_t *dst, *dend, mask = 0, color = 0; |
||||
const uint8_t *src, *send, *opcodes; |
||||
int i, j, op = 0; |
||||
|
||||
i = bytestream2_get_byte(&c->gb); |
||||
if (i) { |
||||
if (code & 0x10) { |
||||
int pos = bytestream2_tell(&c->gb) & 3; |
||||
if (pos) |
||||
bytestream2_skip(&c->gb, 4 - pos); |
||||
} |
||||
do { |
||||
int page, val, x, y; |
||||
val = bytestream2_get_be16(&c->gb); |
||||
page = val >> 14; |
||||
x = (val & 0x7F) * 2; |
||||
y = ((val >> 7) & 0x7F) * 2; |
||||
dst = c->frame[page] + x + y * c->width; |
||||
dend = c->frame[page] + c->frame_size; |
||||
offset = (x & 0x7F) * 2; |
||||
j = bytestream2_get_le16(&c->gb) + offset; |
||||
do { |
||||
offset++; |
||||
if (dst + 3 * c->width + 4 > dend) |
||||
return AVERROR_INVALIDDATA; |
||||
read4x4block(c, dst, c->width); |
||||
if ((offset & 0x3F) == 0) |
||||
dst += c->width * 3; |
||||
dst += 4; |
||||
} while (offset < j); |
||||
} while (--i); |
||||
} |
||||
|
||||
dst = c->frame[c->current_frame]; |
||||
dend = c->frame[c->current_frame] + c->frame_size; |
||||
do { |
||||
set_src_position(c, &src, &send); |
||||
if ((src + 3 * c->width + 4 > send) || |
||||
(dst + 3 * c->width + 4 > dend)) |
||||
return AVERROR_INVALIDDATA; |
||||
copy_block4(dst, src, c->width, c->width, 4); |
||||
i++; |
||||
if ((i & 0x3F) == 0) |
||||
dst += c->width * 3; |
||||
dst += 4; |
||||
} while (i < c->video_size / 16); |
||||
|
||||
opcode_size = bytestream2_get_le16(&c->gb); |
||||
bytestream2_skip(&c->gb, 2); |
||||
|
||||
if (bytestream2_get_bytes_left(&c->gb) < opcode_size) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
opcodes = pkt + bytestream2_tell(&c->gb); |
||||
bytestream2_skipu(&c->gb, opcode_size); |
||||
|
||||
dst = c->frame[c->current_frame]; |
||||
|
||||
for (i = 0; i < c->height; i += 4, dst += c->width * 3) |
||||
for (j = 0; j < c->width; j += 4, dst += 4) { |
||||
int opcode, k = 0; |
||||
if (op > opcode_size) |
||||
return AVERROR_INVALIDDATA; |
||||
if (j & 4) { |
||||
opcode = opcodes[op] & 15; |
||||
op++; |
||||
} else { |
||||
opcode = opcodes[op] >> 4; |
||||
} |
||||
|
||||
while (block_sequences[opcode][k]) { |
||||
offset = c->width * 2; |
||||
code = block_sequences[opcode][k++]; |
||||
|
||||
switch (code) { |
||||
case 2: |
||||
offset = 0; |
||||
case 3: |
||||
color = bytestream2_get_byte(&c->gb); |
||||
case 4: |
||||
mask = bytestream2_get_byte(&c->gb); |
||||
copy_color_mask(dst + offset, c->width, mask, color); |
||||
break; |
||||
case 5: |
||||
offset = 0; |
||||
case 6: |
||||
set_src_position(c, &src, &send); |
||||
case 7: |
||||
if (src + offset + c->width + 4 > send) |
||||
return AVERROR_INVALIDDATA; |
||||
mask = bytestream2_get_byte(&c->gb); |
||||
copy_src_mask(dst + offset, c->width, mask, src + offset); |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int paf_video_decode(AVCodecContext *avctx, void *data, |
||||
int *got_frame, AVPacket *pkt) |
||||
{ |
||||
PAFVideoDecContext *c = avctx->priv_data; |
||||
uint8_t code, *dst, *end; |
||||
int i, frame, ret; |
||||
|
||||
if ((ret = ff_reget_buffer(avctx, c->pic)) < 0) |
||||
return ret; |
||||
|
||||
bytestream2_init(&c->gb, pkt->data, pkt->size); |
||||
|
||||
code = bytestream2_get_byte(&c->gb); |
||||
if (code & 0x20) { // frame is keyframe
|
||||
for (i = 0; i < 4; i++) |
||||
memset(c->frame[i], 0, c->frame_size); |
||||
|
||||
memset(c->pic->data[1], 0, AVPALETTE_SIZE); |
||||
c->current_frame = 0; |
||||
c->pic->key_frame = 1; |
||||
c->pic->pict_type = AV_PICTURE_TYPE_I; |
||||
} else { |
||||
c->pic->key_frame = 0; |
||||
c->pic->pict_type = AV_PICTURE_TYPE_P; |
||||
} |
||||
|
||||
if (code & 0x40) { // palette update
|
||||
uint32_t *out = (uint32_t *)c->pic->data[1]; |
||||
int index, count; |
||||
|
||||
index = bytestream2_get_byte(&c->gb); |
||||
count = bytestream2_get_byte(&c->gb) + 1; |
||||
|
||||
if (index + count > 256) |
||||
return AVERROR_INVALIDDATA; |
||||
if (bytestream2_get_bytes_left(&c->gb) < 3 * count) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
out += index; |
||||
for (i = 0; i < count; i++) { |
||||
unsigned r, g, b; |
||||
|
||||
r = bytestream2_get_byteu(&c->gb); |
||||
r = r << 2 | r >> 4; |
||||
g = bytestream2_get_byteu(&c->gb); |
||||
g = g << 2 | g >> 4; |
||||
b = bytestream2_get_byteu(&c->gb); |
||||
b = b << 2 | b >> 4; |
||||
*out++ = (0xFFU << 24) | (r << 16) | (g << 8) | b; |
||||
} |
||||
c->pic->palette_has_changed = 1; |
||||
} |
||||
|
||||
switch (code & 0x0F) { |
||||
case 0: |
||||
/* Block-based motion compensation using 4x4 blocks with either
|
||||
* horizontal or vertical vectors; might incorporate VQ as well. */ |
||||
if ((ret = decode_0(c, pkt->data, code)) < 0) |
||||
return ret; |
||||
break; |
||||
case 1: |
||||
/* Uncompressed data. This mode specifies that (width * height) bytes
|
||||
* should be copied directly from the encoded buffer into the output. */ |
||||
dst = c->frame[c->current_frame]; |
||||
// possibly chunk length data
|
||||
bytestream2_skip(&c->gb, 2); |
||||
if (bytestream2_get_bytes_left(&c->gb) < c->video_size) |
||||
return AVERROR_INVALIDDATA; |
||||
bytestream2_get_bufferu(&c->gb, dst, c->video_size); |
||||
break; |
||||
case 2: |
||||
/* Copy reference frame: Consume the next byte in the stream as the
|
||||
* reference frame (which should be 0, 1, 2, or 3, and should not be |
||||
* the same as the current frame number). */ |
||||
frame = bytestream2_get_byte(&c->gb); |
||||
if (frame > 3) |
||||
return AVERROR_INVALIDDATA; |
||||
if (frame != c->current_frame) |
||||
memcpy(c->frame[c->current_frame], c->frame[frame], c->frame_size); |
||||
break; |
||||
case 4: |
||||
/* Run length encoding.*/ |
||||
dst = c->frame[c->current_frame]; |
||||
end = dst + c->video_size; |
||||
|
||||
bytestream2_skip(&c->gb, 2); |
||||
|
||||
while (dst < end) { |
||||
int8_t code; |
||||
int count; |
||||
|
||||
if (bytestream2_get_bytes_left(&c->gb) < 2) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
code = bytestream2_get_byteu(&c->gb); |
||||
count = FFABS(code) + 1; |
||||
|
||||
if (dst + count > end) |
||||
return AVERROR_INVALIDDATA; |
||||
if (code < 0) |
||||
memset(dst, bytestream2_get_byteu(&c->gb), count); |
||||
else |
||||
bytestream2_get_buffer(&c->gb, dst, count); |
||||
dst += count; |
||||
} |
||||
break; |
||||
default: |
||||
avpriv_request_sample(avctx, "unknown/invalid code"); |
||||
return AVERROR_INVALIDDATA; |
||||
} |
||||
|
||||
av_image_copy_plane(c->pic->data[0], c->pic->linesize[0], |
||||
c->frame[c->current_frame], c->width, |
||||
c->width, c->height); |
||||
|
||||
c->current_frame = (c->current_frame + 1) & 3; |
||||
if ((ret = av_frame_ref(data, c->pic)) < 0) |
||||
return ret; |
||||
|
||||
*got_frame = 1; |
||||
|
||||
return pkt->size; |
||||
} |
||||
|
||||
static av_cold int paf_audio_init(AVCodecContext *avctx) |
||||
{ |
||||
if (avctx->channels != 2) { |
||||
av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n"); |
||||
return AVERROR_INVALIDDATA; |
||||
} |
||||
|
||||
avctx->channel_layout = AV_CH_LAYOUT_STEREO; |
||||
avctx->sample_fmt = AV_SAMPLE_FMT_S16; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int paf_audio_decode(AVCodecContext *avctx, void *data, |
||||
int *got_frame, AVPacket *pkt) |
||||
{ |
||||
AVFrame *frame = data; |
||||
int16_t *output_samples; |
||||
const uint8_t *src = pkt->data; |
||||
int frames, ret, i, j; |
||||
int16_t cb[256]; |
||||
|
||||
frames = pkt->size / PAF_SOUND_FRAME_SIZE; |
||||
if (frames < 1) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
frame->nb_samples = PAF_SOUND_SAMPLES * frames; |
||||
if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
||||
return ret; |
||||
|
||||
output_samples = (int16_t *)frame->data[0]; |
||||
// codebook of 256 16-bit samples and 8-bit indices to it
|
||||
for (j = 0; j < frames; j++) { |
||||
for (i = 0; i < 256; i++) |
||||
cb[i] = sign_extend(AV_RL16(src + i * 2), 16); |
||||
src += 256 * 2; |
||||
// always 2 channels
|
||||
for (i = 0; i < PAF_SOUND_SAMPLES * 2; i++) |
||||
*output_samples++ = cb[*src++]; |
||||
} |
||||
*got_frame = 1; |
||||
|
||||
return pkt->size; |
||||
} |
||||
|
||||
#if CONFIG_PAF_VIDEO_DECODER |
||||
AVCodec ff_paf_video_decoder = { |
||||
.name = "paf_video", |
||||
.long_name = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Video"), |
||||
.type = AVMEDIA_TYPE_VIDEO, |
||||
.id = AV_CODEC_ID_PAF_VIDEO, |
||||
.priv_data_size = sizeof(PAFVideoDecContext), |
||||
.init = paf_video_init, |
||||
.close = paf_video_close, |
||||
.decode = paf_video_decode, |
||||
.capabilities = CODEC_CAP_DR1, |
||||
}; |
||||
#endif |
||||
|
||||
#if CONFIG_PAF_AUDIO_DECODER |
||||
AVCodec ff_paf_audio_decoder = { |
||||
.name = "paf_audio", |
||||
.long_name = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Audio"), |
||||
.type = AVMEDIA_TYPE_AUDIO, |
||||
.id = AV_CODEC_ID_PAF_AUDIO, |
||||
.init = paf_audio_init, |
||||
.decode = paf_audio_decode, |
||||
.capabilities = CODEC_CAP_DR1, |
||||
}; |
||||
#endif |
||||
@ -0,0 +1,267 @@ |
||||
/*
|
||||
* Packed Animation File demuxer |
||||
* Copyright (c) 2012 Paul B Mahol |
||||
* |
||||
* This file is part of Libav. |
||||
* |
||||
* Libav 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. |
||||
* |
||||
* Libav 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 Libav; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#include "libavutil/channel_layout.h" |
||||
|
||||
#include "avformat.h" |
||||
#include "internal.h" |
||||
|
||||
#define MAGIC "Packed Animation File V1.0\n(c) 1992-96 Amazing Studio\x0a\x1a" |
||||
#define PAF_SOUND_SAMPLES 2205 |
||||
#define PAF_SOUND_FRAME_SIZE ((256 + PAF_SOUND_SAMPLES) * 2) |
||||
|
||||
typedef struct { |
||||
uint32_t buffer_size; |
||||
uint32_t frame_blks; |
||||
uint32_t nb_frames; |
||||
uint32_t start_offset; |
||||
uint32_t preload_count; |
||||
uint32_t max_video_blks; |
||||
uint32_t max_audio_blks; |
||||
|
||||
uint32_t current_frame; |
||||
uint32_t current_frame_count; |
||||
uint32_t current_frame_block; |
||||
|
||||
uint32_t *blocks_count_table; |
||||
uint32_t *frames_offset_table; |
||||
uint32_t *blocks_offset_table; |
||||
|
||||
uint8_t *video_frame; |
||||
int video_size; |
||||
|
||||
uint8_t *audio_frame; |
||||
uint8_t *temp_audio_frame; |
||||
int audio_size; |
||||
|
||||
int got_audio; |
||||
} PAFDemuxContext; |
||||
|
||||
static int read_probe(AVProbeData *p) |
||||
{ |
||||
if ((p->buf_size >= strlen(MAGIC)) && |
||||
!memcmp(p->buf, MAGIC, strlen(MAGIC))) |
||||
return AVPROBE_SCORE_MAX; |
||||
return 0; |
||||
} |
||||
|
||||
static int read_close(AVFormatContext *s) |
||||
{ |
||||
PAFDemuxContext *p = s->priv_data; |
||||
|
||||
av_freep(&p->blocks_count_table); |
||||
av_freep(&p->frames_offset_table); |
||||
av_freep(&p->blocks_offset_table); |
||||
av_freep(&p->video_frame); |
||||
av_freep(&p->audio_frame); |
||||
av_freep(&p->temp_audio_frame); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void read_table(AVFormatContext *s, uint32_t *table, uint32_t count) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < count; i++) |
||||
table[i] = avio_rl32(s->pb); |
||||
|
||||
avio_skip(s->pb, 4 * (FFALIGN(count, 512) - count)); |
||||
} |
||||
|
||||
static int read_header(AVFormatContext *s) |
||||
{ |
||||
PAFDemuxContext *p = s->priv_data; |
||||
AVIOContext *pb = s->pb; |
||||
AVStream *ast, *vst; |
||||
int ret = 0; |
||||
|
||||
avio_skip(pb, 132); |
||||
|
||||
vst = avformat_new_stream(s, 0); |
||||
if (!vst) |
||||
return AVERROR(ENOMEM); |
||||
|
||||
vst->start_time = 0; |
||||
vst->nb_frames = |
||||
vst->duration = |
||||
p->nb_frames = avio_rl32(pb); |
||||
avio_skip(pb, 4); |
||||
|
||||
vst->codec->width = avio_rl32(pb); |
||||
vst->codec->height = avio_rl32(pb); |
||||
avio_skip(pb, 4); |
||||
|
||||
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; |
||||
vst->codec->codec_tag = 0; |
||||
vst->codec->codec_id = AV_CODEC_ID_PAF_VIDEO; |
||||
avpriv_set_pts_info(vst, 64, 1, 10); |
||||
|
||||
ast = avformat_new_stream(s, 0); |
||||
if (!ast) |
||||
return AVERROR(ENOMEM); |
||||
|
||||
ast->start_time = 0; |
||||
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
||||
ast->codec->codec_tag = 0; |
||||
ast->codec->codec_id = AV_CODEC_ID_PAF_AUDIO; |
||||
ast->codec->channels = 2; |
||||
ast->codec->channel_layout = AV_CH_LAYOUT_STEREO; |
||||
ast->codec->sample_rate = 22050; |
||||
avpriv_set_pts_info(ast, 64, 1, 22050); |
||||
|
||||
p->buffer_size = avio_rl32(pb); |
||||
p->preload_count = avio_rl32(pb); |
||||
p->frame_blks = avio_rl32(pb); |
||||
p->start_offset = avio_rl32(pb); |
||||
p->max_video_blks = avio_rl32(pb); |
||||
p->max_audio_blks = avio_rl32(pb); |
||||
if (p->buffer_size < 175 || |
||||
p->max_audio_blks < 2 || |
||||
p->max_video_blks < 1 || |
||||
p->frame_blks < 1 || |
||||
p->nb_frames < 1 || |
||||
p->preload_count < 1 || |
||||
p->buffer_size > 2048 || |
||||
p->max_video_blks > 2048 || |
||||
p->max_audio_blks > 2048 || |
||||
p->nb_frames > INT_MAX / sizeof(uint32_t) || |
||||
p->frame_blks > INT_MAX / sizeof(uint32_t)) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
p->blocks_count_table = av_mallocz(p->nb_frames * |
||||
sizeof(*p->blocks_count_table)); |
||||
p->frames_offset_table = av_mallocz(p->nb_frames * |
||||
sizeof(*p->frames_offset_table)); |
||||
p->blocks_offset_table = av_mallocz(p->frame_blks * |
||||
sizeof(*p->blocks_offset_table)); |
||||
|
||||
p->video_size = p->max_video_blks * p->buffer_size; |
||||
p->video_frame = av_mallocz(p->video_size); |
||||
|
||||
p->audio_size = p->max_audio_blks * p->buffer_size; |
||||
p->audio_frame = av_mallocz(p->audio_size); |
||||
p->temp_audio_frame = av_mallocz(p->audio_size); |
||||
|
||||
if (!p->blocks_count_table || |
||||
!p->frames_offset_table || |
||||
!p->blocks_offset_table || |
||||
!p->video_frame || |
||||
!p->audio_frame || |
||||
!p->temp_audio_frame) { |
||||
ret = AVERROR(ENOMEM); |
||||
goto fail; |
||||
} |
||||
|
||||
avio_seek(pb, p->buffer_size, SEEK_SET); |
||||
|
||||
read_table(s, p->blocks_count_table, p->nb_frames); |
||||
read_table(s, p->frames_offset_table, p->nb_frames); |
||||
read_table(s, p->blocks_offset_table, p->frame_blks); |
||||
|
||||
p->got_audio = 0; |
||||
p->current_frame = 0; |
||||
p->current_frame_block = 0; |
||||
|
||||
avio_seek(pb, p->start_offset, SEEK_SET); |
||||
|
||||
return 0; |
||||
|
||||
fail: |
||||
read_close(s); |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
static int read_packet(AVFormatContext *s, AVPacket *pkt) |
||||
{ |
||||
PAFDemuxContext *p = s->priv_data; |
||||
AVIOContext *pb = s->pb; |
||||
uint32_t count, offset; |
||||
int size, i; |
||||
|
||||
if (p->current_frame >= p->nb_frames || pb->eof_reached) |
||||
return AVERROR_EOF; |
||||
|
||||
if (p->got_audio) { |
||||
if (av_new_packet(pkt, p->audio_size) < 0) |
||||
return AVERROR(ENOMEM); |
||||
|
||||
memcpy(pkt->data, p->temp_audio_frame, p->audio_size); |
||||
pkt->duration = PAF_SOUND_SAMPLES * (p->audio_size / PAF_SOUND_FRAME_SIZE); |
||||
pkt->flags |= AV_PKT_FLAG_KEY; |
||||
pkt->stream_index = 1; |
||||
p->got_audio = 0; |
||||
return pkt->size; |
||||
} |
||||
|
||||
count = (p->current_frame == 0) ? p->preload_count |
||||
: p->blocks_count_table[p->current_frame - 1]; |
||||
for (i = 0; i < count; i++) { |
||||
if (p->current_frame_block >= p->frame_blks) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
offset = p->blocks_offset_table[p->current_frame_block] & ~(1U << 31); |
||||
if (p->blocks_offset_table[p->current_frame_block] & (1U << 31)) { |
||||
if (offset > p->audio_size - p->buffer_size) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
avio_read(pb, p->audio_frame + offset, p->buffer_size); |
||||
if (offset == (p->max_audio_blks - 2) * p->buffer_size) { |
||||
memcpy(p->temp_audio_frame, p->audio_frame, p->audio_size); |
||||
p->got_audio = 1; |
||||
} |
||||
} else { |
||||
if (offset > p->video_size - p->buffer_size) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
avio_read(pb, p->video_frame + offset, p->buffer_size); |
||||
} |
||||
p->current_frame_block++; |
||||
} |
||||
|
||||
if (p->frames_offset_table[p->current_frame] >= p->video_size) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
size = p->video_size - p->frames_offset_table[p->current_frame]; |
||||
|
||||
if (av_new_packet(pkt, size) < 0) |
||||
return AVERROR(ENOMEM); |
||||
|
||||
pkt->stream_index = 0; |
||||
pkt->duration = 1; |
||||
memcpy(pkt->data, p->video_frame + p->frames_offset_table[p->current_frame], size); |
||||
if (pkt->data[0] & 0x20) |
||||
pkt->flags |= AV_PKT_FLAG_KEY; |
||||
p->current_frame++; |
||||
|
||||
return pkt->size; |
||||
} |
||||
|
||||
AVInputFormat ff_paf_demuxer = { |
||||
.name = "paf", |
||||
.long_name = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File"), |
||||
.priv_data_size = sizeof(PAFDemuxContext), |
||||
.read_probe = read_probe, |
||||
.read_header = read_header, |
||||
.read_packet = read_packet, |
||||
.read_close = read_close, |
||||
}; |
||||
Loading…
Reference in new issue