1/* 2 * FLI/FLC Animation Video Decoder 3 * Copyright (C) 2003, 2004 The FFmpeg project 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/** 23 * @file 24 * Autodesk Animator FLI/FLC Video Decoder 25 * by Mike Melanson (melanson@pcisys.net) 26 * for more information on the .fli/.flc file format and all of its many 27 * variations, visit: 28 * http://www.compuphase.com/flic.htm 29 * 30 * This decoder outputs PAL8/RGB555/RGB565/BGR24. To use this decoder, be 31 * sure that your demuxer sends the FLI file header to the decoder via 32 * the extradata chunk in AVCodecContext. The chunk should be 128 bytes 33 * large. The only exception is for FLI files from the game "Magic Carpet", 34 * in which the header is only 12 bytes. 35 */ 36 37#include <stdio.h> 38#include <stdlib.h> 39#include <string.h> 40 41#include "libavutil/intreadwrite.h" 42#include "avcodec.h" 43#include "bytestream.h" 44#include "codec_internal.h" 45#include "internal.h" 46#include "mathops.h" 47 48#define FLI_256_COLOR 4 49#define FLI_DELTA 7 50#define FLI_COLOR 11 51#define FLI_LC 12 52#define FLI_BLACK 13 53#define FLI_BRUN 15 54#define FLI_COPY 16 55#define FLI_MINI 18 56#define FLI_DTA_BRUN 25 57#define FLI_DTA_COPY 26 58#define FLI_DTA_LC 27 59 60#define FLI_TYPE_CODE (0xAF11) 61#define FLC_FLX_TYPE_CODE (0xAF12) 62#define FLC_DTA_TYPE_CODE (0xAF44) /* Marks an "Extended FLC" comes from Dave's Targa Animator (DTA) */ 63#define FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE (0xAF13) 64 65#define CHECK_PIXEL_PTR(n) \ 66 if (pixel_ptr + n > pixel_limit) { \ 67 av_log (s->avctx, AV_LOG_ERROR, "Invalid pixel_ptr = %d > pixel_limit = %d\n", \ 68 pixel_ptr + n, pixel_limit); \ 69 return AVERROR_INVALIDDATA; \ 70 } \ 71 72typedef struct FlicDecodeContext { 73 AVCodecContext *avctx; 74 AVFrame *frame; 75 76 unsigned int palette[256]; 77 int new_palette; 78 int fli_type; /* either 0xAF11 or 0xAF12, affects palette resolution */ 79} FlicDecodeContext; 80 81static av_cold int flic_decode_init(AVCodecContext *avctx) 82{ 83 FlicDecodeContext *s = avctx->priv_data; 84 unsigned char *fli_header = (unsigned char *)avctx->extradata; 85 int depth; 86 87 if (avctx->extradata_size != 0 && 88 avctx->extradata_size != 12 && 89 avctx->extradata_size != 128 && 90 avctx->extradata_size != 256 && 91 avctx->extradata_size != 904 && 92 avctx->extradata_size != 1024) { 93 av_log(avctx, AV_LOG_ERROR, "Unexpected extradata size %d\n", avctx->extradata_size); 94 return AVERROR_INVALIDDATA; 95 } 96 97 s->avctx = avctx; 98 99 if (s->avctx->extradata_size == 12) { 100 /* special case for magic carpet FLIs */ 101 s->fli_type = FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE; 102 depth = 8; 103 } else if (avctx->extradata_size == 1024) { 104 uint8_t *ptr = avctx->extradata; 105 int i; 106 107 for (i = 0; i < 256; i++) { 108 s->palette[i] = AV_RL32(ptr); 109 ptr += 4; 110 } 111 depth = 8; 112 /* FLI in MOV, see e.g. FFmpeg trac issue #626 */ 113 } else if (avctx->extradata_size == 0 || 114 avctx->extradata_size == 256 || 115 /* see FFmpeg ticket #1234 */ 116 avctx->extradata_size == 904) { 117 s->fli_type = FLI_TYPE_CODE; 118 depth = 8; 119 } else { 120 s->fli_type = AV_RL16(&fli_header[4]); 121 depth = AV_RL16(&fli_header[12]); 122 } 123 124 if (depth == 0) { 125 depth = 8; /* Some FLC generators set depth to zero, when they mean 8Bpp. Fix up here */ 126 } 127 128 if ((s->fli_type == FLC_FLX_TYPE_CODE) && (depth == 16)) { 129 depth = 15; /* Original Autodesk FLX's say the depth is 16Bpp when it is really 15Bpp */ 130 } 131 132 switch (depth) { 133 case 8 : avctx->pix_fmt = AV_PIX_FMT_PAL8; break; 134 case 15 : avctx->pix_fmt = AV_PIX_FMT_RGB555; break; 135 case 16 : avctx->pix_fmt = AV_PIX_FMT_RGB565; break; 136 case 24 : avctx->pix_fmt = AV_PIX_FMT_BGR24; break; 137 default : 138 av_log(avctx, AV_LOG_ERROR, "Unknown FLC/FLX depth of %d Bpp is unsupported.\n",depth); 139 return AVERROR_INVALIDDATA; 140 } 141 142 s->frame = av_frame_alloc(); 143 if (!s->frame) 144 return AVERROR(ENOMEM); 145 146 s->new_palette = 0; 147 148 return 0; 149} 150 151static int flic_decode_frame_8BPP(AVCodecContext *avctx, 152 AVFrame *rframe, int *got_frame, 153 const uint8_t *buf, int buf_size) 154{ 155 FlicDecodeContext *s = avctx->priv_data; 156 157 GetByteContext g2; 158 int pixel_ptr; 159 int palette_ptr; 160 unsigned char palette_idx1; 161 unsigned char palette_idx2; 162 163 unsigned int frame_size; 164 int num_chunks; 165 166 unsigned int chunk_size; 167 int chunk_type; 168 169 int i, j, ret; 170 171 int color_packets; 172 int color_changes; 173 int color_shift; 174 unsigned char r, g, b; 175 176 int lines; 177 int compressed_lines; 178 int starting_line; 179 int line_packets; 180 int y_ptr; 181 int byte_run; 182 int pixel_skip; 183 int pixel_countdown; 184 unsigned char *pixels; 185 unsigned int pixel_limit; 186 187 bytestream2_init(&g2, buf, buf_size); 188 189 if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0) 190 return ret; 191 192 pixels = s->frame->data[0]; 193 pixel_limit = s->avctx->height * s->frame->linesize[0]; 194 if (buf_size < 16 || buf_size > INT_MAX - (3 * 256 + AV_INPUT_BUFFER_PADDING_SIZE)) 195 return AVERROR_INVALIDDATA; 196 frame_size = bytestream2_get_le32(&g2); 197 if (frame_size > buf_size) 198 frame_size = buf_size; 199 bytestream2_skip(&g2, 2); /* skip the magic number */ 200 num_chunks = bytestream2_get_le16(&g2); 201 bytestream2_skip(&g2, 8); /* skip padding */ 202 203 if (frame_size < 16) 204 return AVERROR_INVALIDDATA; 205 206 frame_size -= 16; 207 208 /* iterate through the chunks */ 209 while ((frame_size >= 6) && (num_chunks > 0) && 210 bytestream2_get_bytes_left(&g2) >= 4) { 211 int stream_ptr_after_chunk; 212 chunk_size = bytestream2_get_le32(&g2); 213 if (chunk_size > frame_size) { 214 av_log(avctx, AV_LOG_WARNING, 215 "Invalid chunk_size = %u > frame_size = %u\n", chunk_size, frame_size); 216 chunk_size = frame_size; 217 } 218 stream_ptr_after_chunk = bytestream2_tell(&g2) - 4 + chunk_size; 219 220 chunk_type = bytestream2_get_le16(&g2); 221 222 switch (chunk_type) { 223 case FLI_256_COLOR: 224 case FLI_COLOR: 225 /* check special case: If this file is from the Magic Carpet 226 * game and uses 6-bit colors even though it reports 256-color 227 * chunks in a 0xAF12-type file (fli_type is set to 0xAF13 during 228 * initialization) */ 229 if ((chunk_type == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE)) 230 color_shift = 0; 231 else 232 color_shift = 2; 233 /* set up the palette */ 234 color_packets = bytestream2_get_le16(&g2); 235 palette_ptr = 0; 236 for (i = 0; i < color_packets; i++) { 237 /* first byte is how many colors to skip */ 238 palette_ptr += bytestream2_get_byte(&g2); 239 240 /* next byte indicates how many entries to change */ 241 color_changes = bytestream2_get_byte(&g2); 242 243 /* if there are 0 color changes, there are actually 256 */ 244 if (color_changes == 0) 245 color_changes = 256; 246 247 if (bytestream2_tell(&g2) + color_changes * 3 > stream_ptr_after_chunk) 248 break; 249 250 for (j = 0; j < color_changes; j++) { 251 unsigned int entry; 252 253 /* wrap around, for good measure */ 254 if ((unsigned)palette_ptr >= 256) 255 palette_ptr = 0; 256 257 r = bytestream2_get_byte(&g2) << color_shift; 258 g = bytestream2_get_byte(&g2) << color_shift; 259 b = bytestream2_get_byte(&g2) << color_shift; 260 entry = 0xFFU << 24 | r << 16 | g << 8 | b; 261 if (color_shift == 2) 262 entry |= entry >> 6 & 0x30303; 263 if (s->palette[palette_ptr] != entry) 264 s->new_palette = 1; 265 s->palette[palette_ptr++] = entry; 266 } 267 } 268 break; 269 270 case FLI_DELTA: 271 y_ptr = 0; 272 compressed_lines = bytestream2_get_le16(&g2); 273 while (compressed_lines > 0) { 274 if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk) 275 break; 276 if (y_ptr > pixel_limit) 277 return AVERROR_INVALIDDATA; 278 line_packets = sign_extend(bytestream2_get_le16(&g2), 16); 279 if ((line_packets & 0xC000) == 0xC000) { 280 // line skip opcode 281 line_packets = -line_packets; 282 if (line_packets > s->avctx->height) 283 return AVERROR_INVALIDDATA; 284 y_ptr += line_packets * s->frame->linesize[0]; 285 } else if ((line_packets & 0xC000) == 0x4000) { 286 av_log(avctx, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", line_packets); 287 } else if ((line_packets & 0xC000) == 0x8000) { 288 // "last byte" opcode 289 pixel_ptr= y_ptr + s->frame->linesize[0] - 1; 290 CHECK_PIXEL_PTR(0); 291 pixels[pixel_ptr] = line_packets & 0xff; 292 } else { 293 compressed_lines--; 294 pixel_ptr = y_ptr; 295 CHECK_PIXEL_PTR(0); 296 pixel_countdown = s->avctx->width; 297 for (i = 0; i < line_packets; i++) { 298 if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk) 299 break; 300 /* account for the skip bytes */ 301 pixel_skip = bytestream2_get_byte(&g2); 302 pixel_ptr += pixel_skip; 303 pixel_countdown -= pixel_skip; 304 byte_run = sign_extend(bytestream2_get_byte(&g2), 8); 305 if (byte_run < 0) { 306 byte_run = -byte_run; 307 palette_idx1 = bytestream2_get_byte(&g2); 308 palette_idx2 = bytestream2_get_byte(&g2); 309 CHECK_PIXEL_PTR(byte_run * 2); 310 for (j = 0; j < byte_run; j++, pixel_countdown -= 2) { 311 pixels[pixel_ptr++] = palette_idx1; 312 pixels[pixel_ptr++] = palette_idx2; 313 } 314 } else { 315 CHECK_PIXEL_PTR(byte_run * 2); 316 if (bytestream2_tell(&g2) + byte_run * 2 > stream_ptr_after_chunk) 317 break; 318 for (j = 0; j < byte_run * 2; j++, pixel_countdown--) { 319 pixels[pixel_ptr++] = bytestream2_get_byte(&g2); 320 } 321 } 322 } 323 324 y_ptr += s->frame->linesize[0]; 325 } 326 } 327 break; 328 329 case FLI_LC: 330 /* line compressed */ 331 starting_line = bytestream2_get_le16(&g2); 332 if (starting_line >= s->avctx->height) 333 return AVERROR_INVALIDDATA; 334 y_ptr = 0; 335 y_ptr += starting_line * s->frame->linesize[0]; 336 337 compressed_lines = bytestream2_get_le16(&g2); 338 while (compressed_lines > 0) { 339 pixel_ptr = y_ptr; 340 CHECK_PIXEL_PTR(0); 341 pixel_countdown = s->avctx->width; 342 if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk) 343 break; 344 line_packets = bytestream2_get_byte(&g2); 345 if (line_packets > 0) { 346 for (i = 0; i < line_packets; i++) { 347 /* account for the skip bytes */ 348 if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk) 349 break; 350 pixel_skip = bytestream2_get_byte(&g2); 351 pixel_ptr += pixel_skip; 352 pixel_countdown -= pixel_skip; 353 byte_run = sign_extend(bytestream2_get_byte(&g2),8); 354 if (byte_run > 0) { 355 CHECK_PIXEL_PTR(byte_run); 356 if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk) 357 break; 358 for (j = 0; j < byte_run; j++, pixel_countdown--) { 359 pixels[pixel_ptr++] = bytestream2_get_byte(&g2); 360 } 361 } else if (byte_run < 0) { 362 byte_run = -byte_run; 363 palette_idx1 = bytestream2_get_byte(&g2); 364 CHECK_PIXEL_PTR(byte_run); 365 for (j = 0; j < byte_run; j++, pixel_countdown--) { 366 pixels[pixel_ptr++] = palette_idx1; 367 } 368 } 369 } 370 } 371 372 y_ptr += s->frame->linesize[0]; 373 compressed_lines--; 374 } 375 break; 376 377 case FLI_BLACK: 378 /* set the whole frame to color 0 (which is usually black) */ 379 memset(pixels, 0, 380 s->frame->linesize[0] * s->avctx->height); 381 break; 382 383 case FLI_BRUN: 384 /* Byte run compression: This chunk type only occurs in the first 385 * FLI frame and it will update the entire frame. */ 386 y_ptr = 0; 387 for (lines = 0; lines < s->avctx->height; lines++) { 388 pixel_ptr = y_ptr; 389 /* disregard the line packets; instead, iterate through all 390 * pixels on a row */ 391 bytestream2_skip(&g2, 1); 392 pixel_countdown = s->avctx->width; 393 while (pixel_countdown > 0) { 394 if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk) 395 break; 396 byte_run = sign_extend(bytestream2_get_byte(&g2), 8); 397 if (!byte_run) { 398 av_log(avctx, AV_LOG_ERROR, "Invalid byte run value.\n"); 399 return AVERROR_INVALIDDATA; 400 } 401 402 if (byte_run > 0) { 403 palette_idx1 = bytestream2_get_byte(&g2); 404 CHECK_PIXEL_PTR(byte_run); 405 for (j = 0; j < byte_run; j++) { 406 pixels[pixel_ptr++] = palette_idx1; 407 pixel_countdown--; 408 if (pixel_countdown < 0) 409 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n", 410 pixel_countdown, lines); 411 } 412 } else { /* copy bytes if byte_run < 0 */ 413 byte_run = -byte_run; 414 CHECK_PIXEL_PTR(byte_run); 415 if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk) 416 break; 417 for (j = 0; j < byte_run; j++) { 418 pixels[pixel_ptr++] = bytestream2_get_byte(&g2); 419 pixel_countdown--; 420 if (pixel_countdown < 0) 421 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n", 422 pixel_countdown, lines); 423 } 424 } 425 } 426 427 y_ptr += s->frame->linesize[0]; 428 } 429 break; 430 431 case FLI_COPY: 432 /* copy the chunk (uncompressed frame) */ 433 if (chunk_size - 6 != FFALIGN(s->avctx->width, 4) * s->avctx->height) { 434 av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \ 435 "has incorrect size, skipping chunk\n", chunk_size - 6); 436 bytestream2_skip(&g2, chunk_size - 6); 437 } else { 438 for (y_ptr = 0; y_ptr < s->frame->linesize[0] * s->avctx->height; 439 y_ptr += s->frame->linesize[0]) { 440 bytestream2_get_buffer(&g2, &pixels[y_ptr], 441 s->avctx->width); 442 if (s->avctx->width & 3) 443 bytestream2_skip(&g2, 4 - (s->avctx->width & 3)); 444 } 445 } 446 break; 447 448 case FLI_MINI: 449 /* some sort of a thumbnail? disregard this chunk... */ 450 break; 451 452 default: 453 av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type); 454 break; 455 } 456 457 if (stream_ptr_after_chunk - bytestream2_tell(&g2) >= 0) { 458 bytestream2_skip(&g2, stream_ptr_after_chunk - bytestream2_tell(&g2)); 459 } else { 460 av_log(avctx, AV_LOG_ERROR, "Chunk overread\n"); 461 break; 462 } 463 464 frame_size -= chunk_size; 465 num_chunks--; 466 } 467 468 /* by the end of the chunk, the stream ptr should equal the frame 469 * size (minus 1 or 2, possibly); if it doesn't, issue a warning */ 470 if (bytestream2_get_bytes_left(&g2) > 2) 471 av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \ 472 "and final chunk ptr = %d\n", buf_size, 473 buf_size - bytestream2_get_bytes_left(&g2)); 474 475 /* make the palette available on the way out */ 476 memcpy(s->frame->data[1], s->palette, AVPALETTE_SIZE); 477 if (s->new_palette) { 478 s->frame->palette_has_changed = 1; 479 s->new_palette = 0; 480 } 481 482 if ((ret = av_frame_ref(rframe, s->frame)) < 0) 483 return ret; 484 485 *got_frame = 1; 486 487 return buf_size; 488} 489 490static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, 491 AVFrame *rframe, int *got_frame, 492 const uint8_t *buf, int buf_size) 493{ 494 /* Note, the only difference between the 15Bpp and 16Bpp */ 495 /* Format is the pixel format, the packets are processed the same. */ 496 FlicDecodeContext *s = avctx->priv_data; 497 498 GetByteContext g2; 499 int pixel_ptr; 500 unsigned char palette_idx1; 501 502 unsigned int frame_size; 503 int num_chunks; 504 505 unsigned int chunk_size; 506 int chunk_type; 507 508 int i, j, ret; 509 510 int lines; 511 int compressed_lines; 512 int line_packets; 513 int y_ptr; 514 int byte_run; 515 int pixel_skip; 516 int pixel_countdown; 517 unsigned char *pixels; 518 int pixel; 519 unsigned int pixel_limit; 520 521 bytestream2_init(&g2, buf, buf_size); 522 523 if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0) 524 return ret; 525 526 pixels = s->frame->data[0]; 527 pixel_limit = s->avctx->height * s->frame->linesize[0]; 528 529 frame_size = bytestream2_get_le32(&g2); 530 bytestream2_skip(&g2, 2); /* skip the magic number */ 531 num_chunks = bytestream2_get_le16(&g2); 532 bytestream2_skip(&g2, 8); /* skip padding */ 533 if (frame_size > buf_size) 534 frame_size = buf_size; 535 536 if (frame_size < 16) 537 return AVERROR_INVALIDDATA; 538 frame_size -= 16; 539 540 /* iterate through the chunks */ 541 while ((frame_size > 0) && (num_chunks > 0) && 542 bytestream2_get_bytes_left(&g2) >= 4) { 543 int stream_ptr_after_chunk; 544 chunk_size = bytestream2_get_le32(&g2); 545 if (chunk_size > frame_size) { 546 av_log(avctx, AV_LOG_WARNING, 547 "Invalid chunk_size = %u > frame_size = %u\n", chunk_size, frame_size); 548 chunk_size = frame_size; 549 } 550 stream_ptr_after_chunk = bytestream2_tell(&g2) - 4 + chunk_size; 551 552 chunk_type = bytestream2_get_le16(&g2); 553 554 555 switch (chunk_type) { 556 case FLI_256_COLOR: 557 case FLI_COLOR: 558 /* For some reason, it seems that non-palettized flics do 559 * include one of these chunks in their first frame. 560 * Why I do not know, it seems rather extraneous. */ 561 ff_dlog(avctx, 562 "Unexpected Palette chunk %d in non-palettized FLC\n", 563 chunk_type); 564 bytestream2_skip(&g2, chunk_size - 6); 565 break; 566 567 case FLI_DELTA: 568 case FLI_DTA_LC: 569 y_ptr = 0; 570 compressed_lines = bytestream2_get_le16(&g2); 571 while (compressed_lines > 0) { 572 if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk) 573 break; 574 if (y_ptr > pixel_limit) 575 return AVERROR_INVALIDDATA; 576 line_packets = sign_extend(bytestream2_get_le16(&g2), 16); 577 if (line_packets < 0) { 578 line_packets = -line_packets; 579 if (line_packets > s->avctx->height) 580 return AVERROR_INVALIDDATA; 581 y_ptr += line_packets * s->frame->linesize[0]; 582 } else { 583 compressed_lines--; 584 pixel_ptr = y_ptr; 585 CHECK_PIXEL_PTR(0); 586 pixel_countdown = s->avctx->width; 587 for (i = 0; i < line_packets; i++) { 588 /* account for the skip bytes */ 589 if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk) 590 break; 591 pixel_skip = bytestream2_get_byte(&g2); 592 pixel_ptr += (pixel_skip*2); /* Pixel is 2 bytes wide */ 593 pixel_countdown -= pixel_skip; 594 byte_run = sign_extend(bytestream2_get_byte(&g2), 8); 595 if (byte_run < 0) { 596 byte_run = -byte_run; 597 pixel = bytestream2_get_le16(&g2); 598 CHECK_PIXEL_PTR(2 * byte_run); 599 for (j = 0; j < byte_run; j++, pixel_countdown -= 2) { 600 *((signed short*)(&pixels[pixel_ptr])) = pixel; 601 pixel_ptr += 2; 602 } 603 } else { 604 if (bytestream2_tell(&g2) + 2*byte_run > stream_ptr_after_chunk) 605 break; 606 CHECK_PIXEL_PTR(2 * byte_run); 607 for (j = 0; j < byte_run; j++, pixel_countdown--) { 608 *((signed short*)(&pixels[pixel_ptr])) = bytestream2_get_le16(&g2); 609 pixel_ptr += 2; 610 } 611 } 612 } 613 614 y_ptr += s->frame->linesize[0]; 615 } 616 } 617 break; 618 619 case FLI_LC: 620 av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-palettized FLC\n"); 621 bytestream2_skip(&g2, chunk_size - 6); 622 break; 623 624 case FLI_BLACK: 625 /* set the whole frame to 0x0000 which is black in both 15Bpp and 16Bpp modes. */ 626 memset(pixels, 0x0000, 627 s->frame->linesize[0] * s->avctx->height); 628 break; 629 630 case FLI_BRUN: 631 y_ptr = 0; 632 for (lines = 0; lines < s->avctx->height; lines++) { 633 pixel_ptr = y_ptr; 634 /* disregard the line packets; instead, iterate through all 635 * pixels on a row */ 636 bytestream2_skip(&g2, 1); 637 pixel_countdown = (s->avctx->width * 2); 638 639 while (pixel_countdown > 0) { 640 if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk) 641 break; 642 byte_run = sign_extend(bytestream2_get_byte(&g2), 8); 643 if (byte_run > 0) { 644 palette_idx1 = bytestream2_get_byte(&g2); 645 CHECK_PIXEL_PTR(byte_run); 646 for (j = 0; j < byte_run; j++) { 647 pixels[pixel_ptr++] = palette_idx1; 648 pixel_countdown--; 649 if (pixel_countdown < 0) 650 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) (linea%d)\n", 651 pixel_countdown, lines); 652 } 653 } else { /* copy bytes if byte_run < 0 */ 654 byte_run = -byte_run; 655 if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk) 656 break; 657 CHECK_PIXEL_PTR(byte_run); 658 for (j = 0; j < byte_run; j++) { 659 palette_idx1 = bytestream2_get_byte(&g2); 660 pixels[pixel_ptr++] = palette_idx1; 661 pixel_countdown--; 662 if (pixel_countdown < 0) 663 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n", 664 pixel_countdown, lines); 665 } 666 } 667 } 668 669 /* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed. 670 * This does not give us any good opportunity to perform word endian conversion 671 * during decompression. So if it is required (i.e., this is not a LE target, we do 672 * a second pass over the line here, swapping the bytes. 673 */ 674#if HAVE_BIGENDIAN 675 pixel_ptr = y_ptr; 676 pixel_countdown = s->avctx->width; 677 while (pixel_countdown > 0) { 678 *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[pixel_ptr]); 679 pixel_ptr += 2; 680 } 681#endif 682 y_ptr += s->frame->linesize[0]; 683 } 684 break; 685 686 case FLI_DTA_BRUN: 687 y_ptr = 0; 688 for (lines = 0; lines < s->avctx->height; lines++) { 689 pixel_ptr = y_ptr; 690 /* disregard the line packets; instead, iterate through all 691 * pixels on a row */ 692 bytestream2_skip(&g2, 1); 693 pixel_countdown = s->avctx->width; /* Width is in pixels, not bytes */ 694 695 while (pixel_countdown > 0) { 696 if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk) 697 break; 698 byte_run = sign_extend(bytestream2_get_byte(&g2), 8); 699 if (byte_run > 0) { 700 pixel = bytestream2_get_le16(&g2); 701 CHECK_PIXEL_PTR(2 * byte_run); 702 for (j = 0; j < byte_run; j++) { 703 *((signed short*)(&pixels[pixel_ptr])) = pixel; 704 pixel_ptr += 2; 705 pixel_countdown--; 706 if (pixel_countdown < 0) 707 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n", 708 pixel_countdown); 709 } 710 } else { /* copy pixels if byte_run < 0 */ 711 byte_run = -byte_run; 712 if (bytestream2_tell(&g2) + 2 * byte_run > stream_ptr_after_chunk) 713 break; 714 CHECK_PIXEL_PTR(2 * byte_run); 715 for (j = 0; j < byte_run; j++) { 716 *((signed short*)(&pixels[pixel_ptr])) = bytestream2_get_le16(&g2); 717 pixel_ptr += 2; 718 pixel_countdown--; 719 if (pixel_countdown < 0) 720 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n", 721 pixel_countdown); 722 } 723 } 724 } 725 726 y_ptr += s->frame->linesize[0]; 727 } 728 break; 729 730 case FLI_COPY: 731 case FLI_DTA_COPY: 732 /* copy the chunk (uncompressed frame) */ 733 if (chunk_size - 6 > (unsigned int)(FFALIGN(s->avctx->width, 2) * s->avctx->height)*2) { 734 av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \ 735 "bigger than image, skipping chunk\n", chunk_size - 6); 736 bytestream2_skip(&g2, chunk_size - 6); 737 } else { 738 739 if (bytestream2_get_bytes_left(&g2) < 2 * s->avctx->width * s->avctx->height ) 740 return AVERROR_INVALIDDATA; 741 for (y_ptr = 0; y_ptr < s->frame->linesize[0] * s->avctx->height; 742 y_ptr += s->frame->linesize[0]) { 743 744 pixel_countdown = s->avctx->width; 745 pixel_ptr = 0; 746 while (pixel_countdown > 0) { 747 *((signed short*)(&pixels[y_ptr + pixel_ptr])) = bytestream2_get_le16(&g2); 748 pixel_ptr += 2; 749 pixel_countdown--; 750 } 751 if (s->avctx->width & 1) 752 bytestream2_skip(&g2, 2); 753 } 754 } 755 break; 756 757 case FLI_MINI: 758 /* some sort of a thumbnail? disregard this chunk... */ 759 bytestream2_skip(&g2, chunk_size - 6); 760 break; 761 762 default: 763 av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type); 764 break; 765 } 766 767 if (stream_ptr_after_chunk - bytestream2_tell(&g2) >= 0) { 768 bytestream2_skip(&g2, stream_ptr_after_chunk - bytestream2_tell(&g2)); 769 } else { 770 av_log(avctx, AV_LOG_ERROR, "Chunk overread\n"); 771 break; 772 } 773 774 frame_size -= chunk_size; 775 num_chunks--; 776 } 777 778 /* by the end of the chunk, the stream ptr should equal the frame 779 * size (minus 1, possibly); if it doesn't, issue a warning */ 780 if ((bytestream2_get_bytes_left(&g2) != 0) && (bytestream2_get_bytes_left(&g2) != 1)) 781 av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \ 782 "and final chunk ptr = %d\n", buf_size, bytestream2_tell(&g2)); 783 784 if ((ret = av_frame_ref(rframe, s->frame)) < 0) 785 return ret; 786 787 *got_frame = 1; 788 789 return buf_size; 790} 791 792static int flic_decode_frame_24BPP(AVCodecContext *avctx, 793 AVFrame *rframe, int *got_frame, 794 const uint8_t *buf, int buf_size) 795{ 796 FlicDecodeContext *s = avctx->priv_data; 797 798 GetByteContext g2; 799 int pixel_ptr; 800 unsigned char palette_idx1; 801 802 unsigned int frame_size; 803 int num_chunks; 804 805 unsigned int chunk_size; 806 int chunk_type; 807 808 int i, j, ret; 809 810 int lines; 811 int compressed_lines; 812 int line_packets; 813 int y_ptr; 814 int byte_run; 815 int pixel_skip; 816 int pixel_countdown; 817 unsigned char *pixels; 818 int pixel; 819 unsigned int pixel_limit; 820 821 bytestream2_init(&g2, buf, buf_size); 822 823 if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0) 824 return ret; 825 826 pixels = s->frame->data[0]; 827 pixel_limit = s->avctx->height * s->frame->linesize[0]; 828 829 frame_size = bytestream2_get_le32(&g2); 830 bytestream2_skip(&g2, 2); /* skip the magic number */ 831 num_chunks = bytestream2_get_le16(&g2); 832 bytestream2_skip(&g2, 8); /* skip padding */ 833 if (frame_size > buf_size) 834 frame_size = buf_size; 835 836 if (frame_size < 16) 837 return AVERROR_INVALIDDATA; 838 frame_size -= 16; 839 840 /* iterate through the chunks */ 841 while ((frame_size > 0) && (num_chunks > 0) && 842 bytestream2_get_bytes_left(&g2) >= 4) { 843 int stream_ptr_after_chunk; 844 chunk_size = bytestream2_get_le32(&g2); 845 if (chunk_size > frame_size) { 846 av_log(avctx, AV_LOG_WARNING, 847 "Invalid chunk_size = %u > frame_size = %u\n", chunk_size, frame_size); 848 chunk_size = frame_size; 849 } 850 stream_ptr_after_chunk = bytestream2_tell(&g2) - 4 + chunk_size; 851 852 chunk_type = bytestream2_get_le16(&g2); 853 854 855 switch (chunk_type) { 856 case FLI_256_COLOR: 857 case FLI_COLOR: 858 /* For some reason, it seems that non-palettized flics do 859 * include one of these chunks in their first frame. 860 * Why I do not know, it seems rather extraneous. */ 861 ff_dlog(avctx, 862 "Unexpected Palette chunk %d in non-palettized FLC\n", 863 chunk_type); 864 bytestream2_skip(&g2, chunk_size - 6); 865 break; 866 867 case FLI_DELTA: 868 case FLI_DTA_LC: 869 y_ptr = 0; 870 compressed_lines = bytestream2_get_le16(&g2); 871 while (compressed_lines > 0) { 872 if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk) 873 break; 874 if (y_ptr > pixel_limit) 875 return AVERROR_INVALIDDATA; 876 line_packets = sign_extend(bytestream2_get_le16(&g2), 16); 877 if (line_packets < 0) { 878 line_packets = -line_packets; 879 if (line_packets > s->avctx->height) 880 return AVERROR_INVALIDDATA; 881 y_ptr += line_packets * s->frame->linesize[0]; 882 } else { 883 compressed_lines--; 884 pixel_ptr = y_ptr; 885 CHECK_PIXEL_PTR(0); 886 pixel_countdown = s->avctx->width; 887 for (i = 0; i < line_packets; i++) { 888 /* account for the skip bytes */ 889 if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk) 890 break; 891 pixel_skip = bytestream2_get_byte(&g2); 892 pixel_ptr += (pixel_skip*3); /* Pixel is 3 bytes wide */ 893 pixel_countdown -= pixel_skip; 894 byte_run = sign_extend(bytestream2_get_byte(&g2), 8); 895 if (byte_run < 0) { 896 byte_run = -byte_run; 897 pixel = bytestream2_get_le24(&g2); 898 CHECK_PIXEL_PTR(3 * byte_run); 899 for (j = 0; j < byte_run; j++, pixel_countdown -= 1) { 900 AV_WL24(&pixels[pixel_ptr], pixel); 901 pixel_ptr += 3; 902 } 903 } else { 904 if (bytestream2_tell(&g2) + 2*byte_run > stream_ptr_after_chunk) 905 break; 906 CHECK_PIXEL_PTR(3 * byte_run); 907 for (j = 0; j < byte_run; j++, pixel_countdown--) { 908 pixel = bytestream2_get_le24(&g2); 909 AV_WL24(&pixels[pixel_ptr], pixel); 910 pixel_ptr += 3; 911 } 912 } 913 } 914 915 y_ptr += s->frame->linesize[0]; 916 } 917 } 918 break; 919 920 case FLI_LC: 921 av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-palettized FLC\n"); 922 bytestream2_skip(&g2, chunk_size - 6); 923 break; 924 925 case FLI_BLACK: 926 /* set the whole frame to 0x00 which is black for 24 bit mode. */ 927 memset(pixels, 0x00, 928 s->frame->linesize[0] * s->avctx->height); 929 break; 930 931 case FLI_BRUN: 932 y_ptr = 0; 933 for (lines = 0; lines < s->avctx->height; lines++) { 934 pixel_ptr = y_ptr; 935 /* disregard the line packets; instead, iterate through all 936 * pixels on a row */ 937 bytestream2_skip(&g2, 1); 938 pixel_countdown = (s->avctx->width * 3); 939 940 while (pixel_countdown > 0) { 941 if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk) 942 break; 943 byte_run = sign_extend(bytestream2_get_byte(&g2), 8); 944 if (byte_run > 0) { 945 palette_idx1 = bytestream2_get_byte(&g2); 946 CHECK_PIXEL_PTR(byte_run); 947 for (j = 0; j < byte_run; j++) { 948 pixels[pixel_ptr++] = palette_idx1; 949 pixel_countdown--; 950 if (pixel_countdown < 0) 951 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) (linea%d)\n", 952 pixel_countdown, lines); 953 } 954 } else { /* copy bytes if byte_run < 0 */ 955 byte_run = -byte_run; 956 if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk) 957 break; 958 CHECK_PIXEL_PTR(byte_run); 959 for (j = 0; j < byte_run; j++) { 960 palette_idx1 = bytestream2_get_byte(&g2); 961 pixels[pixel_ptr++] = palette_idx1; 962 pixel_countdown--; 963 if (pixel_countdown < 0) 964 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n", 965 pixel_countdown, lines); 966 } 967 } 968 } 969 970 y_ptr += s->frame->linesize[0]; 971 } 972 break; 973 974 case FLI_DTA_BRUN: 975 y_ptr = 0; 976 for (lines = 0; lines < s->avctx->height; lines++) { 977 pixel_ptr = y_ptr; 978 /* disregard the line packets; instead, iterate through all 979 * pixels on a row */ 980 bytestream2_skip(&g2, 1); 981 pixel_countdown = s->avctx->width; /* Width is in pixels, not bytes */ 982 983 while (pixel_countdown > 0) { 984 if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk) 985 break; 986 byte_run = sign_extend(bytestream2_get_byte(&g2), 8); 987 if (byte_run > 0) { 988 pixel = bytestream2_get_le24(&g2); 989 CHECK_PIXEL_PTR(3 * byte_run); 990 for (j = 0; j < byte_run; j++) { 991 AV_WL24(pixels + pixel_ptr, pixel); 992 pixel_ptr += 3; 993 pixel_countdown--; 994 if (pixel_countdown < 0) 995 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n", 996 pixel_countdown); 997 } 998 } else { /* copy pixels if byte_run < 0 */ 999 byte_run = -byte_run; 1000 if (bytestream2_tell(&g2) + 3 * byte_run > stream_ptr_after_chunk) 1001 break; 1002 CHECK_PIXEL_PTR(3 * byte_run); 1003 for (j = 0; j < byte_run; j++) { 1004 pixel = bytestream2_get_le24(&g2); 1005 AV_WL24(pixels + pixel_ptr, pixel); 1006 pixel_ptr += 3; 1007 pixel_countdown--; 1008 if (pixel_countdown < 0) 1009 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n", 1010 pixel_countdown); 1011 } 1012 } 1013 } 1014 1015 y_ptr += s->frame->linesize[0]; 1016 } 1017 break; 1018 1019 case FLI_COPY: 1020 case FLI_DTA_COPY: 1021 /* copy the chunk (uncompressed frame) */ 1022 if (chunk_size - 6 > (unsigned int)(FFALIGN(s->avctx->width, 2) * s->avctx->height)*3) { 1023 av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \ 1024 "bigger than image, skipping chunk\n", chunk_size - 6); 1025 bytestream2_skip(&g2, chunk_size - 6); 1026 } else { 1027 for (y_ptr = 0; y_ptr < s->frame->linesize[0] * s->avctx->height; 1028 y_ptr += s->frame->linesize[0]) { 1029 1030 bytestream2_get_buffer(&g2, pixels + y_ptr, 3*s->avctx->width); 1031 if (s->avctx->width & 1) 1032 bytestream2_skip(&g2, 3); 1033 } 1034 } 1035 break; 1036 1037 case FLI_MINI: 1038 /* some sort of a thumbnail? disregard this chunk... */ 1039 bytestream2_skip(&g2, chunk_size - 6); 1040 break; 1041 1042 default: 1043 av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type); 1044 break; 1045 } 1046 1047 if (stream_ptr_after_chunk - bytestream2_tell(&g2) >= 0) { 1048 bytestream2_skip(&g2, stream_ptr_after_chunk - bytestream2_tell(&g2)); 1049 } else { 1050 av_log(avctx, AV_LOG_ERROR, "Chunk overread\n"); 1051 break; 1052 } 1053 1054 frame_size -= chunk_size; 1055 num_chunks--; 1056 } 1057 1058 /* by the end of the chunk, the stream ptr should equal the frame 1059 * size (minus 1, possibly); if it doesn't, issue a warning */ 1060 if ((bytestream2_get_bytes_left(&g2) != 0) && (bytestream2_get_bytes_left(&g2) != 1)) 1061 av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \ 1062 "and final chunk ptr = %d\n", buf_size, bytestream2_tell(&g2)); 1063 1064 if ((ret = av_frame_ref(rframe, s->frame)) < 0) 1065 return ret; 1066 1067 *got_frame = 1; 1068 1069 return buf_size; 1070} 1071 1072static int flic_decode_frame(AVCodecContext *avctx, AVFrame *frame, 1073 int *got_frame, AVPacket *avpkt) 1074{ 1075 const uint8_t *buf = avpkt->data; 1076 int buf_size = avpkt->size; 1077 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) { 1078 return flic_decode_frame_8BPP(avctx, frame, got_frame, 1079 buf, buf_size); 1080 } else if ((avctx->pix_fmt == AV_PIX_FMT_RGB555) || 1081 (avctx->pix_fmt == AV_PIX_FMT_RGB565)) { 1082 return flic_decode_frame_15_16BPP(avctx, frame, got_frame, 1083 buf, buf_size); 1084 } else if (avctx->pix_fmt == AV_PIX_FMT_BGR24) { 1085 return flic_decode_frame_24BPP(avctx, frame, got_frame, 1086 buf, buf_size); 1087 } 1088 1089 /* Should not get here, ever as the pix_fmt is processed */ 1090 /* in flic_decode_init and the above if should deal with */ 1091 /* the finite set of possibilities allowable by here. */ 1092 /* But in case we do, just error out. */ 1093 av_log(avctx, AV_LOG_ERROR, "Unknown FLC format, my science cannot explain how this happened.\n"); 1094 return AVERROR_BUG; 1095} 1096 1097 1098static av_cold int flic_decode_end(AVCodecContext *avctx) 1099{ 1100 FlicDecodeContext *s = avctx->priv_data; 1101 1102 av_frame_free(&s->frame); 1103 1104 return 0; 1105} 1106 1107const FFCodec ff_flic_decoder = { 1108 .p.name = "flic", 1109 .p.long_name = NULL_IF_CONFIG_SMALL("Autodesk Animator Flic video"), 1110 .p.type = AVMEDIA_TYPE_VIDEO, 1111 .p.id = AV_CODEC_ID_FLIC, 1112 .priv_data_size = sizeof(FlicDecodeContext), 1113 .init = flic_decode_init, 1114 .close = flic_decode_end, 1115 FF_CODEC_DECODE_CB(flic_decode_frame), 1116 .p.capabilities = AV_CODEC_CAP_DR1, 1117 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 1118}; 1119