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_freep(&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
;
146 int value
= get_bits1(gb
);
148 static const char transitions
[3][2] = { {2, 1}, {0, 2}, {1, 0} };
149 value
= get_bits1(gb
);
150 *codebook_index
= transitions
[*codebook_index
][value
];
153 depth
= s
->codebooks
[*codebook_index
].depth
;
155 // depth = 0 means that this shouldn't read any bits;
156 // in theory, this is the same as get_bits(gb, 0), but
157 // that doesn't actually work.
158 block_index
= depth
? get_bits(gb
, depth
) : 0;
160 if (*codebook_index
== 1) {
161 block_index
+= superblock_index
<< s
->codebooks
[1].depth
;
164 // This condition can occur with invalid bitstreams and
165 // *codebook_index == 2
166 if (block_index
>= s
->codebooks
[*codebook_index
].size
)
167 return (MacroBlock
) { { 0 } };
169 return s
->codebooks
[*codebook_index
].blocks
[block_index
];
172 static void insert_mb_into_sb(SuperBlock
* sb
, MacroBlock mb
, unsigned index
) {
173 // Formula: ((index / 4) * 16 + (index % 4) * 2) / 2
174 uint32_t *dst
= sb
->pixels32
+ index
+ (index
& -4);
176 // This technically violates C99 aliasing rules, but it should be safe.
177 dst
[0] = mb
.pixels32
[0];
178 dst
[4] = mb
.pixels32
[1];
181 static void copy_superblock(uint16_t* dest
, unsigned dest_stride
,
182 uint16_t* src
, unsigned src_stride
)
186 for (y
= 0; y
< 8; y
++)
187 memcpy(dest
+ y
* dest_stride
, src
+ y
* src_stride
,
188 sizeof(uint16_t) * 8);
190 for (y
= 0; y
< 8; y
++)
191 memset(dest
+ y
* dest_stride
, 0, sizeof(uint16_t) * 8);
194 static const uint16_t mask_matrix
[] = {0x1, 0x2, 0x10, 0x20,
195 0x4, 0x8, 0x40, 0x80,
196 0x100, 0x200, 0x1000, 0x2000,
197 0x400, 0x800, 0x4000, 0x8000};
199 static int escape124_decode_frame(AVCodecContext
*avctx
,
200 void *data
, int *got_frame
,
203 int buf_size
= avpkt
->size
;
204 Escape124Context
*s
= avctx
->priv_data
;
205 AVFrame
*frame
= data
;
208 unsigned frame_flags
, frame_size
;
211 unsigned superblock_index
, cb_index
= 1,
212 superblock_col_index
= 0,
213 superblocks_per_row
= avctx
->width
/ 8, skip
= -1;
215 uint16_t* old_frame_data
, *new_frame_data
;
216 unsigned old_stride
, new_stride
;
220 if ((ret
= init_get_bits8(&gb
, avpkt
->data
, avpkt
->size
)) < 0)
223 // This call also guards the potential depth reads for the
224 // codebook unpacking.
225 if (get_bits_left(&gb
) < 64)
228 frame_flags
= get_bits_long(&gb
, 32);
229 frame_size
= get_bits_long(&gb
, 32);
231 // Leave last frame unchanged
232 // FIXME: Is this necessary? I haven't seen it in any real samples
233 if (!(frame_flags
& 0x114) || !(frame_flags
& 0x7800000)) {
234 if (!s
->frame
->data
[0])
235 return AVERROR_INVALIDDATA
;
237 av_log(avctx
, AV_LOG_DEBUG
, "Skipping frame\n");
240 if ((ret
= av_frame_ref(frame
, s
->frame
)) < 0)
246 for (i
= 0; i
< 3; i
++) {
247 if (frame_flags
& (1 << (17 + i
))) {
248 unsigned cb_depth
, cb_size
;
250 // This codebook can be cut off at places other than
251 // powers of 2, leaving some of the entries undefined.
252 cb_size
= get_bits_long(&gb
, 20);
253 cb_depth
= av_log2(cb_size
- 1) + 1;
255 cb_depth
= get_bits(&gb
, 4);
257 // This is the most basic codebook: pow(2,depth) entries
258 // for a depth-length key
259 cb_size
= 1 << cb_depth
;
261 // This codebook varies per superblock
262 // FIXME: I don't think this handles integer overflow
264 cb_size
= s
->num_superblocks
<< cb_depth
;
267 av_freep(&s
->codebooks
[i
].blocks
);
268 s
->codebooks
[i
] = unpack_codebook(&gb
, cb_depth
, cb_size
);
269 if (!s
->codebooks
[i
].blocks
)
274 if ((ret
= ff_get_buffer(avctx
, frame
, AV_GET_BUFFER_FLAG_REF
)) < 0)
277 new_frame_data
= (uint16_t*)frame
->data
[0];
278 new_stride
= frame
->linesize
[0] / 2;
279 old_frame_data
= (uint16_t*)s
->frame
->data
[0];
280 old_stride
= s
->frame
->linesize
[0] / 2;
282 for (superblock_index
= 0; superblock_index
< s
->num_superblocks
;
283 superblock_index
++) {
286 unsigned multi_mask
= 0;
289 // Note that this call will make us skip the rest of the blocks
290 // if the frame prematurely ends
291 skip
= decode_skip_count(&gb
);
295 copy_superblock(new_frame_data
, new_stride
,
296 old_frame_data
, old_stride
);
298 copy_superblock(sb
.pixels
, 8,
299 old_frame_data
, old_stride
);
301 while (get_bits_left(&gb
) >= 1 && !get_bits1(&gb
)) {
303 mb
= decode_macroblock(s
, &gb
, &cb_index
, superblock_index
);
304 mask
= get_bits(&gb
, 16);
306 for (i
= 0; i
< 16; i
++) {
307 if (mask
& mask_matrix
[i
]) {
308 insert_mb_into_sb(&sb
, mb
, i
);
313 if (!get_bits1(&gb
)) {
314 unsigned inv_mask
= get_bits(&gb
, 4);
315 for (i
= 0; i
< 4; i
++) {
316 if (inv_mask
& (1 << i
)) {
317 multi_mask
^= 0xF << i
*4;
319 multi_mask
^= get_bits(&gb
, 4) << i
*4;
323 for (i
= 0; i
< 16; i
++) {
324 if (multi_mask
& mask_matrix
[i
]) {
325 mb
= decode_macroblock(s
, &gb
, &cb_index
,
327 insert_mb_into_sb(&sb
, mb
, i
);
330 } else if (frame_flags
& (1 << 16)) {
331 while (get_bits_left(&gb
) >= 1 && !get_bits1(&gb
)) {
332 mb
= decode_macroblock(s
, &gb
, &cb_index
, superblock_index
);
333 insert_mb_into_sb(&sb
, mb
, get_bits(&gb
, 4));
337 copy_superblock(new_frame_data
, new_stride
, sb
.pixels
, 8);
340 superblock_col_index
++;
344 if (superblock_col_index
== superblocks_per_row
) {
345 new_frame_data
+= new_stride
* 8 - superblocks_per_row
* 8;
347 old_frame_data
+= old_stride
* 8 - superblocks_per_row
* 8;
348 superblock_col_index
= 0;
353 av_log(avctx
, AV_LOG_DEBUG
,
354 "Escape sizes: %i, %i, %i\n",
355 frame_size
, buf_size
, get_bits_count(&gb
) / 8);
357 av_frame_unref(s
->frame
);
358 if ((ret
= av_frame_ref(s
->frame
, frame
)) < 0)
367 AVCodec ff_escape124_decoder
= {
369 .long_name
= NULL_IF_CONFIG_SMALL("Escape 124"),
370 .type
= AVMEDIA_TYPE_VIDEO
,
371 .id
= AV_CODEC_ID_ESCAPE124
,
372 .priv_data_size
= sizeof(Escape124Context
),
373 .init
= escape124_decode_init
,
374 .close
= escape124_decode_close
,
375 .decode
= escape124_decode_frame
,
376 .capabilities
= CODEC_CAP_DR1
,