1/* 2 * Escape 124 Video Decoder 3 * Copyright (C) 2008 Eli Friedman (eli.friedman@gmail.com) 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 "avcodec.h" 23 24#define ALT_BITSTREAM_READER_LE 25#include "get_bits.h" 26 27typedef union MacroBlock { 28 uint16_t pixels[4]; 29 uint32_t pixels32[2]; 30} MacroBlock; 31 32typedef union SuperBlock { 33 uint16_t pixels[64]; 34 uint32_t pixels32[32]; 35} SuperBlock; 36 37typedef struct CodeBook { 38 unsigned depth; 39 unsigned size; 40 MacroBlock* blocks; 41} CodeBook; 42 43typedef struct Escape124Context { 44 AVFrame frame; 45 46 unsigned num_superblocks; 47 48 CodeBook codebooks[3]; 49} Escape124Context; 50 51static int can_safely_read(GetBitContext* gb, int bits) { 52 return get_bits_count(gb) + bits <= gb->size_in_bits; 53} 54 55/** 56 * Initialize the decoder 57 * @param avctx decoder context 58 * @return 0 success, negative on error 59 */ 60static av_cold int escape124_decode_init(AVCodecContext *avctx) 61{ 62 Escape124Context *s = avctx->priv_data; 63 64 avctx->pix_fmt = PIX_FMT_RGB555; 65 66 s->num_superblocks = ((unsigned)avctx->width / 8) * 67 ((unsigned)avctx->height / 8); 68 69 return 0; 70} 71 72static av_cold int escape124_decode_close(AVCodecContext *avctx) 73{ 74 unsigned i; 75 Escape124Context *s = avctx->priv_data; 76 77 for (i = 0; i < 3; i++) 78 av_free(s->codebooks[i].blocks); 79 80 if (s->frame.data[0]) 81 avctx->release_buffer(avctx, &s->frame); 82 83 return 0; 84} 85 86static CodeBook unpack_codebook(GetBitContext* gb, unsigned depth, 87 unsigned size) 88{ 89 unsigned i, j; 90 CodeBook cb = { 0 }; 91 92 if (!can_safely_read(gb, size * 34)) 93 return cb; 94 95 if (size >= INT_MAX / sizeof(MacroBlock)) 96 return cb; 97 cb.blocks = av_malloc(size ? size * sizeof(MacroBlock) : 1); 98 if (!cb.blocks) 99 return cb; 100 101 cb.depth = depth; 102 cb.size = size; 103 for (i = 0; i < size; i++) { 104 unsigned mask_bits = get_bits(gb, 4); 105 unsigned color0 = get_bits(gb, 15); 106 unsigned color1 = get_bits(gb, 15); 107 108 for (j = 0; j < 4; j++) { 109 if (mask_bits & (1 << j)) 110 cb.blocks[i].pixels[j] = color1; 111 else 112 cb.blocks[i].pixels[j] = color0; 113 } 114 } 115 return cb; 116} 117 118static unsigned decode_skip_count(GetBitContext* gb) 119{ 120 unsigned value; 121 // This function reads a maximum of 23 bits, 122 // which is within the padding space 123 if (!can_safely_read(gb, 1)) 124 return -1; 125 value = get_bits1(gb); 126 if (!value) 127 return value; 128 129 value += get_bits(gb, 3); 130 if (value != (1 + ((1 << 3) - 1))) 131 return value; 132 133 value += get_bits(gb, 7); 134 if (value != (1 + ((1 << 3) - 1)) + ((1 << 7) - 1)) 135 return value; 136 137 return value + get_bits(gb, 12); 138} 139 140static MacroBlock decode_macroblock(Escape124Context* s, GetBitContext* gb, 141 int* codebook_index, int superblock_index) 142{ 143 // This function reads a maximum of 22 bits; the callers 144 // guard this function appropriately 145 unsigned block_index, depth; 146 147 if (get_bits1(gb)) { 148 static const char transitions[3][2] = { {2, 1}, {0, 2}, {1, 0} }; 149 *codebook_index = transitions[*codebook_index][get_bits1(gb)]; 150 } 151 152 depth = s->codebooks[*codebook_index].depth; 153 154 // depth = 0 means that this shouldn't read any bits; 155 // in theory, this is the same as get_bits(gb, 0), but 156 // that doesn't actually work. 157 block_index = depth ? get_bits(gb, depth) : 0; 158 159 if (*codebook_index == 1) { 160 block_index += superblock_index << s->codebooks[1].depth; 161 } 162 163 // This condition can occur with invalid bitstreams and 164 // *codebook_index == 2 165 if (block_index >= s->codebooks[*codebook_index].size) 166 return (MacroBlock) { { 0 } }; 167 168 return s->codebooks[*codebook_index].blocks[block_index]; 169} 170 171static void insert_mb_into_sb(SuperBlock* sb, MacroBlock mb, unsigned index) { 172 // Formula: ((index / 4) * 16 + (index % 4) * 2) / 2 173 uint32_t *dst = sb->pixels32 + index + (index & -4); 174 175 // This technically violates C99 aliasing rules, but it should be safe. 176 dst[0] = mb.pixels32[0]; 177 dst[4] = mb.pixels32[1]; 178} 179 180static void copy_superblock(uint16_t* dest, unsigned dest_stride, 181 uint16_t* src, unsigned src_stride) 182{ 183 unsigned y; 184 if (src) 185 for (y = 0; y < 8; y++) 186 memcpy(dest + y * dest_stride, src + y * src_stride, 187 sizeof(uint16_t) * 8); 188 else 189 for (y = 0; y < 8; y++) 190 memset(dest + y * dest_stride, 0, sizeof(uint16_t) * 8); 191} 192 193static const uint16_t mask_matrix[] = {0x1, 0x2, 0x10, 0x20, 194 0x4, 0x8, 0x40, 0x80, 195 0x100, 0x200, 0x1000, 0x2000, 196 0x400, 0x800, 0x4000, 0x8000}; 197 198/** 199 * Decode a single frame 200 * @param avctx decoder context 201 * @param data decoded frame 202 * @param data_size size of the decoded frame 203 * @param buf input buffer 204 * @param buf_size input buffer size 205 * @return 0 success, -1 on error 206 */ 207static int escape124_decode_frame(AVCodecContext *avctx, 208 void *data, int *data_size, 209 AVPacket *avpkt) 210{ 211 const uint8_t *buf = avpkt->data; 212 int buf_size = avpkt->size; 213 Escape124Context *s = avctx->priv_data; 214 215 GetBitContext gb; 216 unsigned frame_flags, frame_size; 217 unsigned i; 218 219 unsigned superblock_index, cb_index = 1, 220 superblock_col_index = 0, 221 superblocks_per_row = avctx->width / 8, skip = -1; 222 223 uint16_t* old_frame_data, *new_frame_data; 224 unsigned old_stride, new_stride; 225 226 AVFrame new_frame = { { 0 } }; 227 228 init_get_bits(&gb, buf, buf_size * 8); 229 230 // This call also guards the potential depth reads for the 231 // codebook unpacking. 232 if (!can_safely_read(&gb, 64)) 233 return -1; 234 235 frame_flags = get_bits_long(&gb, 32); 236 frame_size = get_bits_long(&gb, 32); 237 238 // Leave last frame unchanged 239 // FIXME: Is this necessary? I haven't seen it in any real samples 240 if (!(frame_flags & 0x114) || !(frame_flags & 0x7800000)) { 241 av_log(NULL, AV_LOG_DEBUG, "Skipping frame\n"); 242 243 *data_size = sizeof(AVFrame); 244 *(AVFrame*)data = s->frame; 245 246 return frame_size; 247 } 248 249 for (i = 0; i < 3; i++) { 250 if (frame_flags & (1 << (17 + i))) { 251 unsigned cb_depth, cb_size; 252 if (i == 2) { 253 // This codebook can be cut off at places other than 254 // powers of 2, leaving some of the entries undefined. 255 cb_size = get_bits_long(&gb, 20); 256 cb_depth = av_log2(cb_size - 1) + 1; 257 } else { 258 cb_depth = get_bits(&gb, 4); 259 if (i == 0) { 260 // This is the most basic codebook: pow(2,depth) entries 261 // for a depth-length key 262 cb_size = 1 << cb_depth; 263 } else { 264 // This codebook varies per superblock 265 // FIXME: I don't think this handles integer overflow 266 // properly 267 cb_size = s->num_superblocks << cb_depth; 268 } 269 } 270 av_free(s->codebooks[i].blocks); 271 s->codebooks[i] = unpack_codebook(&gb, cb_depth, cb_size); 272 if (!s->codebooks[i].blocks) 273 return -1; 274 } 275 } 276 277 new_frame.reference = 3; 278 if (avctx->get_buffer(avctx, &new_frame)) { 279 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 280 return -1; 281 } 282 283 new_frame_data = (uint16_t*)new_frame.data[0]; 284 new_stride = new_frame.linesize[0] / 2; 285 old_frame_data = (uint16_t*)s->frame.data[0]; 286 old_stride = s->frame.linesize[0] / 2; 287 288 for (superblock_index = 0; superblock_index < s->num_superblocks; 289 superblock_index++) { 290 MacroBlock mb; 291 SuperBlock sb; 292 unsigned multi_mask = 0; 293 294 if (skip == -1) { 295 // Note that this call will make us skip the rest of the blocks 296 // if the frame prematurely ends 297 skip = decode_skip_count(&gb); 298 } 299 300 if (skip) { 301 copy_superblock(new_frame_data, new_stride, 302 old_frame_data, old_stride); 303 } else { 304 copy_superblock(sb.pixels, 8, 305 old_frame_data, old_stride); 306 307 while (can_safely_read(&gb, 1) && !get_bits1(&gb)) { 308 unsigned mask; 309 mb = decode_macroblock(s, &gb, &cb_index, superblock_index); 310 mask = get_bits(&gb, 16); 311 multi_mask |= mask; 312 for (i = 0; i < 16; i++) { 313 if (mask & mask_matrix[i]) { 314 insert_mb_into_sb(&sb, mb, i); 315 } 316 } 317 } 318 319 if (can_safely_read(&gb, 1) && !get_bits1(&gb)) { 320 unsigned inv_mask = get_bits(&gb, 4); 321 for (i = 0; i < 4; i++) { 322 if (inv_mask & (1 << i)) { 323 multi_mask ^= 0xF << i*4; 324 } else { 325 multi_mask ^= get_bits(&gb, 4) << i*4; 326 } 327 } 328 329 for (i = 0; i < 16; i++) { 330 if (multi_mask & mask_matrix[i]) { 331 if (!can_safely_read(&gb, 1)) 332 break; 333 mb = decode_macroblock(s, &gb, &cb_index, 334 superblock_index); 335 insert_mb_into_sb(&sb, mb, i); 336 } 337 } 338 } else if (frame_flags & (1 << 16)) { 339 while (can_safely_read(&gb, 1) && !get_bits1(&gb)) { 340 mb = decode_macroblock(s, &gb, &cb_index, superblock_index); 341 insert_mb_into_sb(&sb, mb, get_bits(&gb, 4)); 342 } 343 } 344 345 copy_superblock(new_frame_data, new_stride, sb.pixels, 8); 346 } 347 348 superblock_col_index++; 349 new_frame_data += 8; 350 if (old_frame_data) 351 old_frame_data += 8; 352 if (superblock_col_index == superblocks_per_row) { 353 new_frame_data += new_stride * 8 - superblocks_per_row * 8; 354 if (old_frame_data) 355 old_frame_data += old_stride * 8 - superblocks_per_row * 8; 356 superblock_col_index = 0; 357 } 358 skip--; 359 } 360 361 av_log(NULL, AV_LOG_DEBUG, 362 "Escape sizes: %i, %i, %i\n", 363 frame_size, buf_size, get_bits_count(&gb) / 8); 364 365 if (s->frame.data[0]) 366 avctx->release_buffer(avctx, &s->frame); 367 368 *(AVFrame*)data = s->frame = new_frame; 369 *data_size = sizeof(AVFrame); 370 371 return frame_size; 372} 373 374 375AVCodec escape124_decoder = { 376 "escape124", 377 AVMEDIA_TYPE_VIDEO, 378 CODEC_ID_ESCAPE124, 379 sizeof(Escape124Context), 380 escape124_decode_init, 381 NULL, 382 escape124_decode_close, 383 escape124_decode_frame, 384 CODEC_CAP_DR1, 385 .long_name = NULL_IF_CONFIG_SMALL("Escape 124"), 386}; 387 388