2 * Escape 124 Video Decoder
3 * Copyright (C) 2008 Eli Friedman (eli.friedman@gmail.com)
5 * This file is part of FFmpeg.
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.
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.
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
24 #define ALT_BITSTREAM_READER_LE
25 #include "bitstream.h"
27 typedef union MacroBlock
{
32 typedef union SuperBlock
{
34 uint32_t pixels32
[32];
37 typedef struct CodeBook
{
43 typedef struct Escape124Context
{
46 unsigned num_superblocks
;
48 CodeBook codebooks
[3];
51 static int can_safely_read(GetBitContext
* gb
, int bits
) {
52 return get_bits_count(gb
) + bits
<= gb
->size_in_bits
;
56 * Initialize the decoder
57 * @param avctx decoder context
58 * @return 0 success, negative on error
60 static av_cold
int escape124_decode_init(AVCodecContext
*avctx
)
62 Escape124Context
*s
= avctx
->priv_data
;
64 avctx
->pix_fmt
= PIX_FMT_RGB555
;
66 s
->num_superblocks
= ((unsigned)avctx
->width
/ 8) *
67 ((unsigned)avctx
->height
/ 8);
72 static av_cold
int escape124_decode_close(AVCodecContext
*avctx
)
75 Escape124Context
*s
= avctx
->priv_data
;
77 for (i
= 0; i
< 3; i
++)
78 av_free(s
->codebooks
[i
].blocks
);
81 avctx
->release_buffer(avctx
, &s
->frame
);
86 static CodeBook
unpack_codebook(GetBitContext
* gb
, unsigned depth
,
92 if (!can_safely_read(gb
, size
* 34))
95 if (size
>= INT_MAX
/ sizeof(MacroBlock
))
97 cb
.blocks
= av_malloc(size
? size
* sizeof(MacroBlock
) : 1);
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);
108 for (j
= 0; j
< 4; j
++) {
109 if (mask_bits
& (1 << j
))
110 cb
.blocks
[i
].pixels
[j
] = color1
;
112 cb
.blocks
[i
].pixels
[j
] = color0
;
118 static unsigned decode_skip_count(GetBitContext
* gb
)
121 // This function reads a maximum of 23 bits,
122 // which is within the padding space
123 if (!can_safely_read(gb
, 1))
125 value
= get_bits1(gb
);
129 value
+= get_bits(gb
, 3);
130 if (value
!= (1 + ((1 << 3) - 1)))
133 value
+= get_bits(gb
, 7);
134 if (value
!= (1 + ((1 << 3) - 1)) + ((1 << 7) - 1))
137 return value
+ get_bits(gb
, 12);
140 static MacroBlock
decode_macroblock(Escape124Context
* s
, GetBitContext
* gb
,
141 int* codebook_index
, int superblock_index
)
143 // This function reads a maximum of 22 bits; the callers
144 // guard this function appropriately
145 unsigned block_index
, depth
;
148 static const char transitions
[3][2] = { {2, 1}, {0, 2}, {1, 0} };
149 *codebook_index
= transitions
[*codebook_index
][get_bits1(gb
)];
152 depth
= s
->codebooks
[*codebook_index
].depth
;
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;
159 if (*codebook_index
== 1) {
160 block_index
+= superblock_index
<< s
->codebooks
[1].depth
;
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 } };
168 return s
->codebooks
[*codebook_index
].blocks
[block_index
];
171 static 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);
175 // This technically violates C99 aliasing rules, but it should be safe.
176 dst
[0] = mb
.pixels32
[0];
177 dst
[4] = mb
.pixels32
[1];
180 static void copy_superblock(uint16_t* dest
, unsigned dest_stride
,
181 uint16_t* src
, unsigned src_stride
)
185 for (y
= 0; y
< 8; y
++)
186 memcpy(dest
+ y
* dest_stride
, src
+ y
* src_stride
,
187 sizeof(uint16_t) * 8);
189 for (y
= 0; y
< 8; y
++)
190 memset(dest
+ y
* dest_stride
, 0, sizeof(uint16_t) * 8);
193 static const uint16_t mask_matrix
[] = {0x1, 0x2, 0x10, 0x20,
194 0x4, 0x8, 0x40, 0x80,
195 0x100, 0x200, 0x1000, 0x2000,
196 0x400, 0x800, 0x4000, 0x8000};
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
207 static int escape124_decode_frame(AVCodecContext
*avctx
,
208 void *data
, int *data_size
,
209 const uint8_t *buf
, int buf_size
)
211 Escape124Context
*s
= avctx
->priv_data
;
214 unsigned frame_flags
, frame_size
;
217 unsigned superblock_index
, cb_index
= 1,
218 superblock_col_index
= 0,
219 superblocks_per_row
= avctx
->width
/ 8, skip
= -1;
221 uint16_t* old_frame_data
, *new_frame_data
;
222 unsigned old_stride
, new_stride
;
224 AVFrame new_frame
= { { 0 } };
226 init_get_bits(&gb
, buf
, buf_size
* 8);
228 // This call also guards the potential depth reads for the
229 // codebook unpacking.
230 if (!can_safely_read(&gb
, 64))
233 frame_flags
= get_bits_long(&gb
, 32);
234 frame_size
= get_bits_long(&gb
, 32);
236 // Leave last frame unchanged
237 // FIXME: Is this necessary? I haven't seen it in any real samples
238 if (!(frame_flags
& 0x114) || !(frame_flags
& 0x7800000)) {
239 av_log(NULL
, AV_LOG_DEBUG
, "Skipping frame\n");
241 *data_size
= sizeof(AVFrame
);
242 *(AVFrame
*)data
= s
->frame
;
247 for (i
= 0; i
< 3; i
++) {
248 if (frame_flags
& (1 << (17 + i
))) {
249 unsigned cb_depth
, cb_size
;
251 // This codebook can be cut off at places other than
252 // powers of 2, leaving some of the entries undefined.
253 cb_size
= get_bits_long(&gb
, 20);
254 cb_depth
= av_log2(cb_size
- 1) + 1;
256 cb_depth
= get_bits(&gb
, 4);
258 // This is the most basic codebook: pow(2,depth) entries
259 // for a depth-length key
260 cb_size
= 1 << cb_depth
;
262 // This codebook varies per superblock
263 // FIXME: I don't think this handles integer overflow
265 cb_size
= s
->num_superblocks
<< cb_depth
;
268 av_free(s
->codebooks
[i
].blocks
);
269 s
->codebooks
[i
] = unpack_codebook(&gb
, cb_depth
, cb_size
);
270 if (!s
->codebooks
[i
].blocks
)
275 new_frame
.reference
= 3;
276 if (avctx
->get_buffer(avctx
, &new_frame
)) {
277 av_log(avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
281 new_frame_data
= (uint16_t*)new_frame
.data
[0];
282 new_stride
= new_frame
.linesize
[0] / 2;
283 old_frame_data
= (uint16_t*)s
->frame
.data
[0];
284 old_stride
= s
->frame
.linesize
[0] / 2;
286 for (superblock_index
= 0; superblock_index
< s
->num_superblocks
;
287 superblock_index
++) {
290 unsigned multi_mask
= 0;
293 // Note that this call will make us skip the rest of the blocks
294 // if the frame prematurely ends
295 skip
= decode_skip_count(&gb
);
299 copy_superblock(new_frame_data
, new_stride
,
300 old_frame_data
, old_stride
);
302 copy_superblock(sb
.pixels
, 8,
303 old_frame_data
, old_stride
);
305 while (can_safely_read(&gb
, 1) && !get_bits1(&gb
)) {
307 mb
= decode_macroblock(s
, &gb
, &cb_index
, superblock_index
);
308 mask
= get_bits(&gb
, 16);
310 for (i
= 0; i
< 16; i
++) {
311 if (mask
& mask_matrix
[i
]) {
312 insert_mb_into_sb(&sb
, mb
, i
);
317 if (can_safely_read(&gb
, 1) && !get_bits1(&gb
)) {
318 unsigned inv_mask
= get_bits(&gb
, 4);
319 for (i
= 0; i
< 4; i
++) {
320 if (inv_mask
& (1 << i
)) {
321 multi_mask
^= 0xF << i
*4;
323 multi_mask
^= get_bits(&gb
, 4) << i
*4;
327 for (i
= 0; i
< 16; i
++) {
328 if (multi_mask
& mask_matrix
[i
]) {
329 if (!can_safely_read(&gb
, 1))
331 mb
= decode_macroblock(s
, &gb
, &cb_index
,
333 insert_mb_into_sb(&sb
, mb
, i
);
336 } else if (frame_flags
& (1 << 16)) {
337 while (can_safely_read(&gb
, 1) && !get_bits1(&gb
)) {
338 mb
= decode_macroblock(s
, &gb
, &cb_index
, superblock_index
);
339 insert_mb_into_sb(&sb
, mb
, get_bits(&gb
, 4));
343 copy_superblock(new_frame_data
, new_stride
, sb
.pixels
, 8);
346 superblock_col_index
++;
350 if (superblock_col_index
== superblocks_per_row
) {
351 new_frame_data
+= new_stride
* 8 - superblocks_per_row
* 8;
353 old_frame_data
+= old_stride
* 8 - superblocks_per_row
* 8;
354 superblock_col_index
= 0;
359 av_log(NULL
, AV_LOG_DEBUG
,
360 "Escape sizes: %i, %i, %i\n",
361 frame_size
, buf_size
, get_bits_count(&gb
) / 8);
363 if (s
->frame
.data
[0])
364 avctx
->release_buffer(avctx
, &s
->frame
);
366 *(AVFrame
*)data
= s
->frame
= new_frame
;
367 *data_size
= sizeof(AVFrame
);
373 AVCodec escape124_decoder
= {
377 sizeof(Escape124Context
),
378 escape124_decode_init
,
380 escape124_decode_close
,
381 escape124_decode_frame
,
383 .long_name
= NULL_IF_CONFIG_SMALL("Escape 124"),