00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "libavcodec/paf.h"
00023 #include "avformat.h"
00024 #include "internal.h"
00025
00026 #define MAGIC "Packed Animation File V1.0\n(c) 1992-96 Amazing Studio\x0a\x1a"
00027
00028 typedef struct {
00029 uint32_t buffer_size;
00030 uint32_t frame_blks;
00031 uint32_t nb_frames;
00032 uint32_t start_offset;
00033 uint32_t preload_count;
00034 uint32_t max_video_blks;
00035 uint32_t max_audio_blks;
00036
00037 uint32_t current_frame;
00038 uint32_t current_frame_count;
00039 uint32_t current_frame_block;
00040
00041 uint32_t *blocks_count_table;
00042 uint32_t *frames_offset_table;
00043 uint32_t *blocks_offset_table;
00044
00045 uint8_t *video_frame;
00046 int video_size;
00047
00048 uint8_t *audio_frame;
00049 uint8_t *temp_audio_frame;
00050 int audio_size;
00051
00052 int got_audio;
00053 } PAFDemuxContext;
00054
00055 static int read_probe(AVProbeData *p)
00056 {
00057 if ((p->buf_size >= strlen(MAGIC)) &&
00058 !memcmp(p->buf, MAGIC, strlen(MAGIC)))
00059 return AVPROBE_SCORE_MAX;
00060 return 0;
00061 }
00062
00063 static int read_close(AVFormatContext *s)
00064 {
00065 PAFDemuxContext *p = s->priv_data;
00066
00067 av_freep(&p->blocks_count_table);
00068 av_freep(&p->frames_offset_table);
00069 av_freep(&p->blocks_offset_table);
00070 av_freep(&p->video_frame);
00071 av_freep(&p->audio_frame);
00072 av_freep(&p->temp_audio_frame);
00073
00074 return 0;
00075 }
00076
00077 static void read_table(AVFormatContext *s, uint32_t *table, uint32_t count)
00078 {
00079 int i;
00080
00081 for (i = 0; i < count; i++)
00082 table[i] = avio_rl32(s->pb);
00083
00084 avio_skip(s->pb, 4 * (FFALIGN(count, 512) - count));
00085 }
00086
00087 static int read_header(AVFormatContext *s)
00088 {
00089 PAFDemuxContext *p = s->priv_data;
00090 AVIOContext *pb = s->pb;
00091 AVStream *ast, *vst;
00092 int ret = 0;
00093
00094 avio_skip(pb, 132);
00095
00096 vst = avformat_new_stream(s, 0);
00097 if (!vst)
00098 return AVERROR(ENOMEM);
00099
00100 vst->start_time = 0;
00101 vst->nb_frames =
00102 vst->duration =
00103 p->nb_frames = avio_rl32(pb);
00104 avio_skip(pb, 4);
00105 vst->codec->width = avio_rl32(pb);
00106 vst->codec->height = avio_rl32(pb);
00107 avio_skip(pb, 4);
00108 vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
00109 vst->codec->codec_tag = 0;
00110 vst->codec->codec_id = AV_CODEC_ID_PAF_VIDEO;
00111 avpriv_set_pts_info(vst, 64, 1, 10);
00112
00113 ast = avformat_new_stream(s, 0);
00114 if (!ast)
00115 return AVERROR(ENOMEM);
00116
00117 ast->start_time = 0;
00118 ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
00119 ast->codec->codec_tag = 0;
00120 ast->codec->codec_id = AV_CODEC_ID_PAF_AUDIO;
00121 ast->codec->channels = 2;
00122 ast->codec->sample_rate = 22050;
00123 avpriv_set_pts_info(ast, 64, 1, 22050);
00124
00125 p->buffer_size = avio_rl32(pb);
00126 p->preload_count = avio_rl32(pb);
00127 p->frame_blks = avio_rl32(pb);
00128 p->start_offset = avio_rl32(pb);
00129 p->max_video_blks = avio_rl32(pb);
00130 p->max_audio_blks = avio_rl32(pb);
00131 if (p->buffer_size < 175 ||
00132 p->max_audio_blks < 2 ||
00133 p->max_video_blks < 1 ||
00134 p->frame_blks < 1 ||
00135 p->nb_frames < 1 ||
00136 p->preload_count < 1 ||
00137 p->buffer_size > 2048 ||
00138 p->max_video_blks > 2048 ||
00139 p->max_audio_blks > 2048 ||
00140 p->nb_frames > INT_MAX / sizeof(uint32_t) ||
00141 p->frame_blks > INT_MAX / sizeof(uint32_t))
00142 return AVERROR_INVALIDDATA;
00143
00144 p->blocks_count_table = av_mallocz(p->nb_frames * sizeof(uint32_t));
00145 p->frames_offset_table = av_mallocz(p->nb_frames * sizeof(uint32_t));
00146 p->blocks_offset_table = av_mallocz(p->frame_blks * sizeof(uint32_t));
00147
00148 p->video_size = p->max_video_blks * p->buffer_size;
00149 p->video_frame = av_mallocz(p->video_size);
00150
00151 p->audio_size = p->max_audio_blks * p->buffer_size;
00152 p->audio_frame = av_mallocz(p->audio_size);
00153 p->temp_audio_frame = av_mallocz(p->audio_size);
00154
00155 if (!p->blocks_count_table ||
00156 !p->frames_offset_table ||
00157 !p->blocks_offset_table ||
00158 !p->video_frame ||
00159 !p->audio_frame ||
00160 !p->temp_audio_frame) {
00161 ret = AVERROR(ENOMEM);
00162 goto fail;
00163 }
00164
00165 avio_seek(pb, p->buffer_size, SEEK_SET);
00166
00167 read_table(s, p->blocks_count_table, p->nb_frames);
00168 read_table(s, p->frames_offset_table, p->nb_frames);
00169 read_table(s, p->blocks_offset_table, p->frame_blks);
00170
00171 p->got_audio = 0;
00172 p->current_frame = 0;
00173 p->current_frame_block = 0;
00174
00175 avio_seek(pb, p->start_offset, SEEK_SET);
00176
00177 return 0;
00178
00179 fail:
00180 read_close(s);
00181
00182 return ret;
00183 }
00184
00185 static int read_packet(AVFormatContext *s, AVPacket *pkt)
00186 {
00187 PAFDemuxContext *p = s->priv_data;
00188 AVIOContext *pb = s->pb;
00189 uint32_t count, offset;
00190 int size, i;
00191
00192 if (p->current_frame >= p->nb_frames)
00193 return AVERROR_EOF;
00194
00195 if (url_feof(pb))
00196 return AVERROR_EOF;
00197
00198 if (p->got_audio) {
00199 if (av_new_packet(pkt, p->audio_size) < 0)
00200 return AVERROR(ENOMEM);
00201
00202 memcpy(pkt->data, p->temp_audio_frame, p->audio_size);
00203 pkt->duration = PAF_SOUND_SAMPLES * (p->audio_size / PAF_SOUND_FRAME_SIZE);
00204 pkt->flags |= AV_PKT_FLAG_KEY;
00205 pkt->stream_index = 1;
00206 p->got_audio = 0;
00207 return pkt->size;
00208 }
00209
00210 count = (p->current_frame == 0) ? p->preload_count : p->blocks_count_table[p->current_frame - 1];
00211 for (i = 0; i < count; i++) {
00212 if (p->current_frame_block >= p->frame_blks)
00213 return AVERROR_INVALIDDATA;
00214
00215 offset = p->blocks_offset_table[p->current_frame_block] & ~(1 << 31);
00216 if (p->blocks_offset_table[p->current_frame_block] & (1 << 31)) {
00217 if (offset > p->audio_size - p->buffer_size)
00218 return AVERROR_INVALIDDATA;
00219
00220 avio_read(pb, p->audio_frame + offset, p->buffer_size);
00221 if (offset == (p->max_audio_blks - 2) * p->buffer_size) {
00222 memcpy(p->temp_audio_frame, p->audio_frame, p->audio_size);
00223 p->got_audio = 1;
00224 }
00225 } else {
00226 if (offset > p->video_size - p->buffer_size)
00227 return AVERROR_INVALIDDATA;
00228
00229 avio_read(pb, p->video_frame + offset, p->buffer_size);
00230 }
00231 p->current_frame_block++;
00232 }
00233
00234 size = p->video_size - p->frames_offset_table[p->current_frame];
00235 if (size < 1)
00236 return AVERROR_INVALIDDATA;
00237
00238 if (av_new_packet(pkt, size) < 0)
00239 return AVERROR(ENOMEM);
00240
00241 pkt->stream_index = 0;
00242 pkt->duration = 1;
00243 memcpy(pkt->data, p->video_frame + p->frames_offset_table[p->current_frame], size);
00244 if (pkt->data[0] & 0x20)
00245 pkt->flags |= AV_PKT_FLAG_KEY;
00246 p->current_frame++;
00247
00248 return pkt->size;
00249 }
00250
00251 AVInputFormat ff_paf_demuxer = {
00252 .name = "paf",
00253 .long_name = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File"),
00254 .priv_data_size = sizeof(PAFDemuxContext),
00255 .read_probe = read_probe,
00256 .read_header = read_header,
00257 .read_packet = read_packet,
00258 .read_close = read_close,
00259 };