1/* 2 * Packed Animation File video decoder 3 * Copyright (c) 2012 Paul B Mahol 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22#include "libavutil/imgutils.h" 23 24#include "avcodec.h" 25#include "bytestream.h" 26#include "copy_block.h" 27#include "codec_internal.h" 28#include "internal.h" 29 30 31static const uint8_t block_sequences[16][8] = { 32 { 0, 0, 0, 0, 0, 0, 0, 0 }, 33 { 2, 0, 0, 0, 0, 0, 0, 0 }, 34 { 5, 7, 0, 0, 0, 0, 0, 0 }, 35 { 5, 0, 0, 0, 0, 0, 0, 0 }, 36 { 6, 0, 0, 0, 0, 0, 0, 0 }, 37 { 5, 7, 5, 7, 0, 0, 0, 0 }, 38 { 5, 7, 5, 0, 0, 0, 0, 0 }, 39 { 5, 7, 6, 0, 0, 0, 0, 0 }, 40 { 5, 5, 0, 0, 0, 0, 0, 0 }, 41 { 3, 0, 0, 0, 0, 0, 0, 0 }, 42 { 6, 6, 0, 0, 0, 0, 0, 0 }, 43 { 2, 4, 0, 0, 0, 0, 0, 0 }, 44 { 2, 4, 5, 7, 0, 0, 0, 0 }, 45 { 2, 4, 5, 0, 0, 0, 0, 0 }, 46 { 2, 4, 6, 0, 0, 0, 0, 0 }, 47 { 2, 4, 5, 7, 5, 7, 0, 0 }, 48}; 49 50typedef struct PAFVideoDecContext { 51 AVFrame *pic; 52 GetByteContext gb; 53 54 int width; 55 int height; 56 57 int current_frame; 58 uint8_t *frame[4]; 59 int dirty[4]; 60 int frame_size; 61 int video_size; 62 63 uint8_t *opcodes; 64} PAFVideoDecContext; 65 66static av_cold int paf_video_close(AVCodecContext *avctx) 67{ 68 PAFVideoDecContext *c = avctx->priv_data; 69 int i; 70 71 av_frame_free(&c->pic); 72 73 for (i = 0; i < 4; i++) 74 av_freep(&c->frame[i]); 75 76 return 0; 77} 78 79static av_cold int paf_video_init(AVCodecContext *avctx) 80{ 81 PAFVideoDecContext *c = avctx->priv_data; 82 int i; 83 int ret; 84 85 c->width = avctx->width; 86 c->height = avctx->height; 87 88 if (avctx->height & 3 || avctx->width & 3) { 89 av_log(avctx, AV_LOG_ERROR, 90 "width %d and height %d must be multiplie of 4.\n", 91 avctx->width, avctx->height); 92 return AVERROR_INVALIDDATA; 93 } 94 95 avctx->pix_fmt = AV_PIX_FMT_PAL8; 96 ret = av_image_check_size2(avctx->width, FFALIGN(avctx->height, 256), avctx->max_pixels, avctx->pix_fmt, 0, avctx); 97 if (ret < 0) 98 return ret; 99 100 c->pic = av_frame_alloc(); 101 if (!c->pic) 102 return AVERROR(ENOMEM); 103 104 c->frame_size = avctx->width * FFALIGN(avctx->height, 256); 105 c->video_size = avctx->width * avctx->height; 106 for (i = 0; i < 4; i++) { 107 c->frame[i] = av_mallocz(c->frame_size); 108 if (!c->frame[i]) 109 return AVERROR(ENOMEM); 110 } 111 112 return 0; 113} 114 115static void read4x4block(PAFVideoDecContext *c, uint8_t *dst, int width) 116{ 117 int i; 118 119 for (i = 0; i < 4; i++) { 120 bytestream2_get_buffer(&c->gb, dst, 4); 121 dst += width; 122 } 123} 124 125static void copy_color_mask(uint8_t *dst, int width, uint8_t mask, uint8_t color) 126{ 127 int i; 128 129 for (i = 0; i < 4; i++) { 130 if (mask & (1 << 7 - i)) 131 dst[i] = color; 132 if (mask & (1 << 3 - i)) 133 dst[width + i] = color; 134 } 135} 136 137static void copy_src_mask(uint8_t *dst, int width, uint8_t mask, const uint8_t *src) 138{ 139 int i; 140 141 for (i = 0; i < 4; i++) { 142 if (mask & (1 << 7 - i)) 143 dst[i] = src[i]; 144 if (mask & (1 << 3 - i)) 145 dst[width + i] = src[width + i]; 146 } 147} 148 149static void set_src_position(PAFVideoDecContext *c, 150 const uint8_t **p, 151 const uint8_t **pend) 152{ 153 int val = bytestream2_get_be16(&c->gb); 154 int page = val >> 14; 155 int x = (val & 0x7F); 156 int y = ((val >> 7) & 0x7F); 157 158 *p = c->frame[page] + x * 2 + y * 2 * c->width; 159 *pend = c->frame[page] + c->frame_size; 160} 161 162static int decode_0(PAFVideoDecContext *c, const uint8_t *pkt, uint8_t code) 163{ 164 uint32_t opcode_size, offset; 165 uint8_t *dst, *dend, mask = 0, color = 0; 166 const uint8_t *src, *send, *opcodes; 167 int i, j, op = 0; 168 169 i = bytestream2_get_byte(&c->gb); 170 if (i) { 171 if (code & 0x10) { 172 int align; 173 174 align = bytestream2_tell(&c->gb) & 3; 175 if (align) 176 bytestream2_skip(&c->gb, 4 - align); 177 } 178 do { 179 int page, val, x, y; 180 val = bytestream2_get_be16(&c->gb); 181 page = val >> 14; 182 x = (val & 0x7F) * 2; 183 y = ((val >> 7) & 0x7F) * 2; 184 dst = c->frame[page] + x + y * c->width; 185 dend = c->frame[page] + c->frame_size; 186 offset = (x & 0x7F) * 2; 187 j = bytestream2_get_le16(&c->gb) + offset; 188 if (bytestream2_get_bytes_left(&c->gb) < (j - offset) * 16) 189 return AVERROR_INVALIDDATA; 190 c->dirty[page] = 1; 191 do { 192 offset++; 193 if (dst + 3 * c->width + 4 > dend) 194 return AVERROR_INVALIDDATA; 195 read4x4block(c, dst, c->width); 196 if ((offset & 0x3F) == 0) 197 dst += c->width * 3; 198 dst += 4; 199 } while (offset < j); 200 } while (--i); 201 } 202 203 dst = c->frame[c->current_frame]; 204 dend = c->frame[c->current_frame] + c->frame_size; 205 do { 206 set_src_position(c, &src, &send); 207 if ((src + 3 * c->width + 4 > send) || 208 (dst + 3 * c->width + 4 > dend) || 209 bytestream2_get_bytes_left(&c->gb) < 4) 210 return AVERROR_INVALIDDATA; 211 copy_block4(dst, src, c->width, c->width, 4); 212 i++; 213 if ((i & 0x3F) == 0) 214 dst += c->width * 3; 215 dst += 4; 216 } while (i < c->video_size / 16); 217 218 opcode_size = bytestream2_get_le16(&c->gb); 219 bytestream2_skip(&c->gb, 2); 220 221 if (bytestream2_get_bytes_left(&c->gb) < opcode_size) 222 return AVERROR_INVALIDDATA; 223 224 opcodes = pkt + bytestream2_tell(&c->gb); 225 bytestream2_skipu(&c->gb, opcode_size); 226 227 dst = c->frame[c->current_frame]; 228 229 for (i = 0; i < c->height; i += 4, dst += c->width * 3) 230 for (j = 0; j < c->width; j += 4, dst += 4) { 231 int opcode, k = 0; 232 if (op > opcode_size) 233 return AVERROR_INVALIDDATA; 234 if (j & 4) { 235 opcode = opcodes[op] & 15; 236 op++; 237 } else { 238 opcode = opcodes[op] >> 4; 239 } 240 241 while (block_sequences[opcode][k]) { 242 offset = c->width * 2; 243 code = block_sequences[opcode][k++]; 244 245 switch (code) { 246 case 2: 247 offset = 0; 248 case 3: 249 color = bytestream2_get_byte(&c->gb); 250 case 4: 251 mask = bytestream2_get_byte(&c->gb); 252 copy_color_mask(dst + offset, c->width, mask, color); 253 break; 254 case 5: 255 offset = 0; 256 case 6: 257 set_src_position(c, &src, &send); 258 case 7: 259 if (src + offset + c->width + 4 > send) 260 return AVERROR_INVALIDDATA; 261 mask = bytestream2_get_byte(&c->gb); 262 copy_src_mask(dst + offset, c->width, mask, src + offset); 263 break; 264 } 265 } 266 } 267 268 return 0; 269} 270 271static int paf_video_decode(AVCodecContext *avctx, AVFrame *rframe, 272 int *got_frame, AVPacket *pkt) 273{ 274 PAFVideoDecContext *c = avctx->priv_data; 275 uint8_t code, *dst, *end; 276 int i, frame, ret; 277 278 if (pkt->size < 2) 279 return AVERROR_INVALIDDATA; 280 281 bytestream2_init(&c->gb, pkt->data, pkt->size); 282 283 code = bytestream2_get_byte(&c->gb); 284 if ((code & 0xF) > 4 || (code & 0xF) == 3) { 285 avpriv_request_sample(avctx, "unknown/invalid code"); 286 return AVERROR_INVALIDDATA; 287 } 288 289 if ((code & 0xF) == 0 && 290 c->video_size / 32 - (int64_t)bytestream2_get_bytes_left(&c->gb) > c->video_size / 32 * (int64_t)avctx->discard_damaged_percentage / 100) 291 return AVERROR_INVALIDDATA; 292 293 if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0) 294 return ret; 295 296 if (code & 0x20) { // frame is keyframe 297 memset(c->pic->data[1], 0, AVPALETTE_SIZE); 298 c->current_frame = 0; 299 c->pic->key_frame = 1; 300 c->pic->pict_type = AV_PICTURE_TYPE_I; 301 } else { 302 c->pic->key_frame = 0; 303 c->pic->pict_type = AV_PICTURE_TYPE_P; 304 } 305 306 if (code & 0x40) { // palette update 307 uint32_t *out = (uint32_t *)c->pic->data[1]; 308 int index, count; 309 310 index = bytestream2_get_byte(&c->gb); 311 count = bytestream2_get_byte(&c->gb) + 1; 312 313 if (index + count > 256) 314 return AVERROR_INVALIDDATA; 315 if (bytestream2_get_bytes_left(&c->gb) < 3 * count) 316 return AVERROR_INVALIDDATA; 317 318 out += index; 319 for (i = 0; i < count; i++) { 320 unsigned r, g, b; 321 322 r = bytestream2_get_byteu(&c->gb); 323 r = r << 2 | r >> 4; 324 g = bytestream2_get_byteu(&c->gb); 325 g = g << 2 | g >> 4; 326 b = bytestream2_get_byteu(&c->gb); 327 b = b << 2 | b >> 4; 328 *out++ = (0xFFU << 24) | (r << 16) | (g << 8) | b; 329 } 330 c->pic->palette_has_changed = 1; 331 } 332 333 c->dirty[c->current_frame] = 1; 334 if (code & 0x20) 335 for (i = 0; i < 4; i++) { 336 if (c->dirty[i]) 337 memset(c->frame[i], 0, c->frame_size); 338 c->dirty[i] = 0; 339 } 340 341 switch (code & 0x0F) { 342 case 0: 343 /* Block-based motion compensation using 4x4 blocks with either 344 * horizontal or vertical vectors; might incorporate VQ as well. */ 345 if ((ret = decode_0(c, pkt->data, code)) < 0) 346 return ret; 347 break; 348 case 1: 349 /* Uncompressed data. This mode specifies that (width * height) bytes 350 * should be copied directly from the encoded buffer into the output. */ 351 dst = c->frame[c->current_frame]; 352 // possibly chunk length data 353 bytestream2_skip(&c->gb, 2); 354 if (bytestream2_get_bytes_left(&c->gb) < c->video_size) 355 return AVERROR_INVALIDDATA; 356 bytestream2_get_bufferu(&c->gb, dst, c->video_size); 357 break; 358 case 2: 359 /* Copy reference frame: Consume the next byte in the stream as the 360 * reference frame (which should be 0, 1, 2, or 3, and should not be 361 * the same as the current frame number). */ 362 frame = bytestream2_get_byte(&c->gb); 363 if (frame > 3) 364 return AVERROR_INVALIDDATA; 365 if (frame != c->current_frame) 366 memcpy(c->frame[c->current_frame], c->frame[frame], c->frame_size); 367 break; 368 case 4: 369 /* Run length encoding.*/ 370 dst = c->frame[c->current_frame]; 371 end = dst + c->video_size; 372 373 bytestream2_skip(&c->gb, 2); 374 375 while (dst < end) { 376 int8_t code; 377 int count; 378 379 if (bytestream2_get_bytes_left(&c->gb) < 2) 380 return AVERROR_INVALIDDATA; 381 382 code = bytestream2_get_byteu(&c->gb); 383 count = FFABS(code) + 1; 384 385 if (dst + count > end) 386 return AVERROR_INVALIDDATA; 387 if (code < 0) 388 memset(dst, bytestream2_get_byteu(&c->gb), count); 389 else 390 bytestream2_get_buffer(&c->gb, dst, count); 391 dst += count; 392 } 393 break; 394 default: 395 av_assert0(0); 396 } 397 398 av_image_copy_plane(c->pic->data[0], c->pic->linesize[0], 399 c->frame[c->current_frame], c->width, 400 c->width, c->height); 401 402 c->current_frame = (c->current_frame + 1) & 3; 403 if ((ret = av_frame_ref(rframe, c->pic)) < 0) 404 return ret; 405 406 *got_frame = 1; 407 408 return pkt->size; 409} 410 411const FFCodec ff_paf_video_decoder = { 412 .p.name = "paf_video", 413 .p.long_name = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Video"), 414 .p.type = AVMEDIA_TYPE_VIDEO, 415 .p.id = AV_CODEC_ID_PAF_VIDEO, 416 .priv_data_size = sizeof(PAFVideoDecContext), 417 .init = paf_video_init, 418 .close = paf_video_close, 419 FF_CODEC_DECODE_CB(paf_video_decode), 420 .p.capabilities = AV_CODEC_CAP_DR1, 421 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, 422}; 423