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
25 #define BITSTREAM_READER_LE
28 typedef union MacroBlock
{
33 typedef union SuperBlock
{
35 uint32_t pixels32
[32];
38 typedef struct CodeBook
{
44 typedef struct Escape124Context
{
47 unsigned num_superblocks
;
49 CodeBook codebooks
[3];
53 * Initialize the decoder
54 * @param avctx decoder context
55 * @return 0 success, negative on error
57 static av_cold
int escape124_decode_init(AVCodecContext
*avctx
)
59 Escape124Context
*s
= avctx
->priv_data
;
61 avctx
->pix_fmt
= AV_PIX_FMT_RGB555
;
63 s
->num_superblocks
= ((unsigned)avctx
->width
/ 8) *
64 ((unsigned)avctx
->height
/ 8);
66 s
->frame
= av_frame_alloc();
68 return AVERROR(ENOMEM
);
73 static av_cold
int escape124_decode_close(AVCodecContext
*avctx
)
76 Escape124Context
*s
= avctx
->priv_data
;
78 for (i
= 0; i
< 3; i
++)
79 av_free(s
->codebooks
[i
].blocks
);
81 av_frame_free(&s
->frame
);
86 static CodeBook
unpack_codebook(GetBitContext
* gb
, unsigned depth
,
92 if (size
>= INT_MAX
/ 34 || get_bits_left(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 (get_bits_left(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};
198 static int escape124_decode_frame(AVCodecContext
*avctx
,
199 void *data
, int *got_frame
,
202 int buf_size
= avpkt
->size
;
203 Escape124Context
*s
= avctx
->priv_data
;
204 AVFrame
*frame
= data
;
207 unsigned frame_flags
, frame_size
;
210 unsigned superblock_index
, cb_index
= 1,
211 superblock_col_index
= 0,
212 superblocks_per_row
= avctx
->width
/ 8, skip
= -1;
214 uint16_t* old_frame_data
, *new_frame_data
;
215 unsigned old_stride
, new_stride
;
219 if ((ret
= init_get_bits8(&gb
, avpkt
->data
, avpkt
->size
)) < 0)
222 // This call also guards the potential depth reads for the
223 // codebook unpacking.
224 if (get_bits_left(&gb
) < 64)
227 frame_flags
= get_bits_long(&gb
, 32);
228 frame_size
= get_bits_long(&gb
, 32);
230 // Leave last frame unchanged
231 // FIXME: Is this necessary? I haven't seen it in any real samples
232 if (!(frame_flags
& 0x114) || !(frame_flags
& 0x7800000)) {
233 if (!s
->frame
->data
[0])
234 return AVERROR_INVALIDDATA
;
236 av_log(avctx
, AV_LOG_DEBUG
, "Skipping frame\n");
239 if ((ret
= av_frame_ref(frame
, s
->frame
)) < 0)
245 for (i
= 0; i
< 3; i
++) {
246 if (frame_flags
& (1 << (17 + i
))) {
247 unsigned cb_depth
, cb_size
;
249 // This codebook can be cut off at places other than
250 // powers of 2, leaving some of the entries undefined.
251 cb_size
= get_bits_long(&gb
, 20);
252 cb_depth
= av_log2(cb_size
- 1) + 1;
254 cb_depth
= get_bits(&gb
, 4);
256 // This is the most basic codebook: pow(2,depth) entries
257 // for a depth-length key
258 cb_size
= 1 << cb_depth
;
260 // This codebook varies per superblock
261 // FIXME: I don't think this handles integer overflow
263 cb_size
= s
->num_superblocks
<< cb_depth
;
266 av_free(s
->codebooks
[i
].blocks
);
267 s
->codebooks
[i
] = unpack_codebook(&gb
, cb_depth
, cb_size
);
268 if (!s
->codebooks
[i
].blocks
)
273 if ((ret
= ff_get_buffer(avctx
, frame
, AV_GET_BUFFER_FLAG_REF
)) < 0)
276 new_frame_data
= (uint16_t*)frame
->data
[0];
277 new_stride
= frame
->linesize
[0] / 2;
278 old_frame_data
= (uint16_t*)s
->frame
->data
[0];
279 old_stride
= s
->frame
->linesize
[0] / 2;
281 for (superblock_index
= 0; superblock_index
< s
->num_superblocks
;
282 superblock_index
++) {
285 unsigned multi_mask
= 0;
288 // Note that this call will make us skip the rest of the blocks
289 // if the frame prematurely ends
290 skip
= decode_skip_count(&gb
);
294 copy_superblock(new_frame_data
, new_stride
,
295 old_frame_data
, old_stride
);
297 copy_superblock(sb
.pixels
, 8,
298 old_frame_data
, old_stride
);
300 while (get_bits_left(&gb
) >= 1 && !get_bits1(&gb
)) {
302 mb
= decode_macroblock(s
, &gb
, &cb_index
, superblock_index
);
303 mask
= get_bits(&gb
, 16);
305 for (i
= 0; i
< 16; i
++) {
306 if (mask
& mask_matrix
[i
]) {
307 insert_mb_into_sb(&sb
, mb
, i
);
312 if (!get_bits1(&gb
)) {
313 unsigned inv_mask
= get_bits(&gb
, 4);
314 for (i
= 0; i
< 4; i
++) {
315 if (inv_mask
& (1 << i
)) {
316 multi_mask
^= 0xF << i
*4;
318 multi_mask
^= get_bits(&gb
, 4) << i
*4;
322 for (i
= 0; i
< 16; i
++) {
323 if (multi_mask
& mask_matrix
[i
]) {
324 mb
= decode_macroblock(s
, &gb
, &cb_index
,
326 insert_mb_into_sb(&sb
, mb
, i
);
329 } else if (frame_flags
& (1 << 16)) {
330 while (get_bits_left(&gb
) >= 1 && !get_bits1(&gb
)) {
331 mb
= decode_macroblock(s
, &gb
, &cb_index
, superblock_index
);
332 insert_mb_into_sb(&sb
, mb
, get_bits(&gb
, 4));
336 copy_superblock(new_frame_data
, new_stride
, sb
.pixels
, 8);
339 superblock_col_index
++;
343 if (superblock_col_index
== superblocks_per_row
) {
344 new_frame_data
+= new_stride
* 8 - superblocks_per_row
* 8;
346 old_frame_data
+= old_stride
* 8 - superblocks_per_row
* 8;
347 superblock_col_index
= 0;
352 av_log(avctx
, AV_LOG_DEBUG
,
353 "Escape sizes: %i, %i, %i\n",
354 frame_size
, buf_size
, get_bits_count(&gb
) / 8);
356 av_frame_unref(s
->frame
);
357 if ((ret
= av_frame_ref(s
->frame
, frame
)) < 0)
366 AVCodec ff_escape124_decoder
= {
368 .long_name
= NULL_IF_CONFIG_SMALL("Escape 124"),
369 .type
= AVMEDIA_TYPE_VIDEO
,
370 .id
= AV_CODEC_ID_ESCAPE124
,
371 .priv_data_size
= sizeof(Escape124Context
),
372 .init
= escape124_decode_init
,
373 .close
= escape124_decode_close
,
374 .decode
= escape124_decode_frame
,
375 .capabilities
= CODEC_CAP_DR1
,