FFmpeg
escape124.c
Go to the documentation of this file.
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 #define BITSTREAM_READER_LE
23 #include "avcodec.h"
24 #include "codec_internal.h"
25 #include "get_bits.h"
26 #include "internal.h"
27 
28 typedef union MacroBlock {
29  uint16_t pixels[4];
30  uint32_t pixels32[2];
31 } MacroBlock;
32 
33 typedef union SuperBlock {
34  uint16_t pixels[64];
35  uint32_t pixels32[32];
36 } SuperBlock;
37 
38 typedef struct CodeBook {
39  unsigned depth;
40  unsigned size;
42 } CodeBook;
43 
44 typedef struct Escape124Context {
46 
47  unsigned num_superblocks;
48 
51 
52 /**
53  * Initialize the decoder
54  * @param avctx decoder context
55  * @return 0 success, negative on error
56  */
58 {
59  Escape124Context *s = avctx->priv_data;
60 
61  avctx->pix_fmt = AV_PIX_FMT_RGB555;
62 
63  s->num_superblocks = ((unsigned)avctx->width / 8) *
64  ((unsigned)avctx->height / 8);
65 
66  s->frame = av_frame_alloc();
67  if (!s->frame)
68  return AVERROR(ENOMEM);
69 
70  return 0;
71 }
72 
74 {
75  unsigned i;
76  Escape124Context *s = avctx->priv_data;
77 
78  for (i = 0; i < 3; i++)
79  av_freep(&s->codebooks[i].blocks);
80 
81  av_frame_free(&s->frame);
82 
83  return 0;
84 }
85 
86 static CodeBook unpack_codebook(GetBitContext* gb, unsigned depth,
87  unsigned size)
88 {
89  unsigned i, j;
90  CodeBook cb = { 0 };
91 
92  if (size >= INT_MAX / 34 || get_bits_left(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 
118 static 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 (get_bits_left(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 
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  int value = get_bits1(gb);
147  if (value) {
148  static const int8_t transitions[3][2] = { {2, 1}, {0, 2}, {1, 0} };
149  value = get_bits1(gb);
150  *codebook_index = transitions[*codebook_index][value];
151  }
152 
153  depth = s->codebooks[*codebook_index].depth;
154 
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 = get_bitsz(gb, depth);
159 
160  if (*codebook_index == 1) {
161  block_index += superblock_index << s->codebooks[1].depth;
162  }
163 
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 } };
168 
169  return s->codebooks[*codebook_index].blocks[block_index];
170 }
171 
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);
175 
176  // This technically violates C99 aliasing rules, but it should be safe.
177  dst[0] = mb.pixels32[0];
178  dst[4] = mb.pixels32[1];
179 }
180 
181 static void copy_superblock(uint16_t* dest, unsigned dest_stride,
182  uint16_t* src, unsigned src_stride)
183 {
184  unsigned y;
185  if (src)
186  for (y = 0; y < 8; y++)
187  memcpy(dest + y * dest_stride, src + y * src_stride,
188  sizeof(uint16_t) * 8);
189  else
190  for (y = 0; y < 8; y++)
191  memset(dest + y * dest_stride, 0, sizeof(uint16_t) * 8);
192 }
193 
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};
198 
200  int *got_frame, AVPacket *avpkt)
201 {
202  int buf_size = avpkt->size;
203  Escape124Context *s = avctx->priv_data;
204 
205  GetBitContext gb;
206  unsigned frame_flags, frame_size;
207  unsigned i;
208 
209  unsigned superblock_index, cb_index = 1,
210  superblock_col_index = 0,
211  superblocks_per_row = avctx->width / 8, skip = -1;
212 
213  uint16_t* old_frame_data, *new_frame_data;
214  unsigned old_stride, new_stride;
215 
216  int ret;
217 
218  if ((ret = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0)
219  return ret;
220 
221  // This call also guards the potential depth reads for the
222  // codebook unpacking.
223  // Check if the amount we will read minimally is available on input.
224  // The 64 represent the immediately next 2 frame_* elements read, the 23/4320
225  // represent a lower bound of the space needed for skipped superblocks. Non
226  // skipped SBs need more space.
227  if (get_bits_left(&gb) < 64 + s->num_superblocks * 23LL / 4320)
228  return -1;
229 
230  frame_flags = get_bits_long(&gb, 32);
231  frame_size = get_bits_long(&gb, 32);
232 
233  // Leave last frame unchanged
234  // FIXME: Is this necessary? I haven't seen it in any real samples
235  if (!(frame_flags & 0x114) || !(frame_flags & 0x7800000)) {
236  if (!s->frame->data[0])
237  return AVERROR_INVALIDDATA;
238 
239  av_log(avctx, AV_LOG_DEBUG, "Skipping frame\n");
240 
241  *got_frame = 1;
242  if ((ret = av_frame_ref(frame, s->frame)) < 0)
243  return ret;
244 
245  return frame_size;
246  }
247 
248  for (i = 0; i < 3; i++) {
249  if (frame_flags & (1 << (17 + i))) {
250  unsigned cb_depth, cb_size;
251  if (i == 2) {
252  // This codebook can be cut off at places other than
253  // powers of 2, leaving some of the entries undefined.
254  cb_size = get_bits(&gb, 20);
255  if (!cb_size) {
256  av_log(avctx, AV_LOG_ERROR, "Invalid codebook size 0.\n");
257  return AVERROR_INVALIDDATA;
258  }
259  cb_depth = av_log2(cb_size - 1) + 1;
260  } else {
261  cb_depth = get_bits(&gb, 4);
262  if (i == 0) {
263  // This is the most basic codebook: pow(2,depth) entries
264  // for a depth-length key
265  cb_size = 1 << cb_depth;
266  } else {
267  // This codebook varies per superblock
268  // FIXME: I don't think this handles integer overflow
269  // properly
270  cb_size = s->num_superblocks << cb_depth;
271  }
272  }
273  if (s->num_superblocks >= INT_MAX >> cb_depth) {
274  av_log(avctx, AV_LOG_ERROR, "Depth or num_superblocks are too large\n");
275  return AVERROR_INVALIDDATA;
276  }
277 
278  av_freep(&s->codebooks[i].blocks);
279  s->codebooks[i] = unpack_codebook(&gb, cb_depth, cb_size);
280  if (!s->codebooks[i].blocks)
281  return -1;
282  }
283  }
284 
285  if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
286  return ret;
287 
288  new_frame_data = (uint16_t*)frame->data[0];
289  new_stride = frame->linesize[0] / 2;
290  old_frame_data = (uint16_t*)s->frame->data[0];
291  old_stride = s->frame->linesize[0] / 2;
292 
293  for (superblock_index = 0; superblock_index < s->num_superblocks;
294  superblock_index++) {
295  MacroBlock mb;
296  SuperBlock sb;
297  unsigned multi_mask = 0;
298 
299  if (skip == -1) {
300  // Note that this call will make us skip the rest of the blocks
301  // if the frame prematurely ends
302  skip = decode_skip_count(&gb);
303  }
304 
305  if (skip) {
306  copy_superblock(new_frame_data, new_stride,
307  old_frame_data, old_stride);
308  } else {
309  copy_superblock(sb.pixels, 8,
310  old_frame_data, old_stride);
311 
312  while (get_bits_left(&gb) >= 1 && !get_bits1(&gb)) {
313  unsigned mask;
314  mb = decode_macroblock(s, &gb, &cb_index, superblock_index);
315  mask = get_bits(&gb, 16);
316  multi_mask |= mask;
317  for (i = 0; i < 16; i++) {
318  if (mask & mask_matrix[i]) {
319  insert_mb_into_sb(&sb, mb, i);
320  }
321  }
322  }
323 
324  if (!get_bits1(&gb)) {
325  unsigned inv_mask = get_bits(&gb, 4);
326  for (i = 0; i < 4; i++) {
327  if (inv_mask & (1 << i)) {
328  multi_mask ^= 0xF << i*4;
329  } else {
330  multi_mask ^= get_bits(&gb, 4) << i*4;
331  }
332  }
333 
334  for (i = 0; i < 16; i++) {
335  if (multi_mask & mask_matrix[i]) {
336  mb = decode_macroblock(s, &gb, &cb_index,
337  superblock_index);
338  insert_mb_into_sb(&sb, mb, i);
339  }
340  }
341  } else if (frame_flags & (1 << 16)) {
342  while (get_bits_left(&gb) >= 1 && !get_bits1(&gb)) {
343  mb = decode_macroblock(s, &gb, &cb_index, superblock_index);
344  insert_mb_into_sb(&sb, mb, get_bits(&gb, 4));
345  }
346  }
347 
348  copy_superblock(new_frame_data, new_stride, sb.pixels, 8);
349  }
350 
351  superblock_col_index++;
352  new_frame_data += 8;
353  if (old_frame_data)
354  old_frame_data += 8;
355  if (superblock_col_index == superblocks_per_row) {
356  new_frame_data += new_stride * 8 - superblocks_per_row * 8;
357  if (old_frame_data)
358  old_frame_data += old_stride * 8 - superblocks_per_row * 8;
359  superblock_col_index = 0;
360  }
361  skip--;
362  }
363 
364  av_log(avctx, AV_LOG_DEBUG,
365  "Escape sizes: %i, %i, %i\n",
366  frame_size, buf_size, get_bits_count(&gb) / 8);
367 
368  av_frame_unref(s->frame);
369  if ((ret = av_frame_ref(s->frame, frame)) < 0)
370  return ret;
371 
372  *got_frame = 1;
373 
374  return frame_size;
375 }
376 
377 
379  .p.name = "escape124",
380  .p.long_name = NULL_IF_CONFIG_SMALL("Escape 124"),
381  .p.type = AVMEDIA_TYPE_VIDEO,
382  .p.id = AV_CODEC_ID_ESCAPE124,
383  .priv_data_size = sizeof(Escape124Context),
385  .close = escape124_decode_close,
387  .p.capabilities = AV_CODEC_CAP_DR1,
388 };
insert_mb_into_sb
static void insert_mb_into_sb(SuperBlock *sb, MacroBlock mb, unsigned index)
Definition: escape124.c:172
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
mask_matrix
static const uint16_t mask_matrix[]
Definition: escape124.c:194
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:239
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
MacroBlock::pixels32
uint32_t pixels32[2]
Definition: escape124.c:30
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
MacroBlock
Definition: escape124.c:28
FFCodec
Definition: codec_internal.h:118
SuperBlock::pixels
uint16_t pixels[64]
Definition: escape124.c:34
decode_macroblock
static MacroBlock decode_macroblock(Escape124Context *s, GetBitContext *gb, int *codebook_index, int superblock_index)
Definition: escape124.c:140
Escape124Context
Definition: escape124.c:44
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
init
static int init
Definition: av_tx.c:47
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
SuperBlock::pixels32
uint32_t pixels32[32]
Definition: escape124.c:35
GetBitContext
Definition: get_bits.h:61
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
mask
static const uint16_t mask[17]
Definition: lzw.c:38
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
MacroBlock::pixels
uint16_t pixels[4]
Definition: escape124.c:29
s
#define s(width, name)
Definition: cbs_vp9.c:256
Escape124Context::codebooks
CodeBook codebooks[3]
Definition: escape124.c:49
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:376
frame_size
int frame_size
Definition: mxfenc.c:2201
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
get_bits.h
Escape124Context::frame
AVFrame * frame
Definition: escape124.c:45
escape124_decode_frame
static int escape124_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: escape124.c:199
CodeBook::size
unsigned size
Definition: escape124.c:40
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
copy_superblock
static void copy_superblock(uint16_t *dest, unsigned dest_stride, uint16_t *src, unsigned src_stride)
Definition: escape124.c:181
index
int index
Definition: gxfenc.c:89
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1462
ff_escape124_decoder
const FFCodec ff_escape124_decoder
Definition: escape124.c:378
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:353
codec_internal.h
size
int size
Definition: twinvq_data.h:10344
mb
#define mb
Definition: vf_colormatrix.c:101
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
unpack_codebook
static CodeBook unpack_codebook(GetBitContext *gb, unsigned depth, unsigned size)
Definition: escape124.c:86
escape124_decode_close
static av_cold int escape124_decode_close(AVCodecContext *avctx)
Definition: escape124.c:73
SuperBlock
Definition: escape124.c:33
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:399
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:487
CodeBook::depth
unsigned depth
Definition: escape124.c:39
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AV_CODEC_ID_ESCAPE124
@ AV_CODEC_ID_ESCAPE124
Definition: codec_id.h:165
AVCodecContext
main external API structure.
Definition: avcodec.h:398
CodeBook::blocks
MacroBlock * blocks
Definition: escape124.c:41
escape124_decode_init
static av_cold int escape124_decode_init(AVCodecContext *avctx)
Initialize the decoder.
Definition: escape124.c:57
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
CodeBook
Definition: escape124.c:38
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
decode_skip_count
static unsigned decode_skip_count(GetBitContext *gb)
Definition: escape124.c:118
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
Escape124Context::num_superblocks
unsigned num_superblocks
Definition: escape124.c:47
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26