FFmpeg
g2meet.c
Go to the documentation of this file.
1 /*
2  * Go2Webinar / Go2Meeting decoder
3  * Copyright (c) 2012 Konstantin Shishkov
4  * Copyright (c) 2013 Maxim Poliakovski
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Go2Webinar / Go2Meeting decoder
26  */
27 
28 #include <inttypes.h>
29 #include <zlib.h>
30 
31 #include "libavutil/imgutils.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/mem_internal.h"
34 
35 #include "avcodec.h"
36 #include "blockdsp.h"
37 #include "bytestream.h"
38 #include "codec_internal.h"
39 #include "decode.h"
40 #include "elsdec.h"
41 #include "get_bits.h"
42 #include "idctdsp.h"
43 #include "jpegtables.h"
44 #include "mjpegdec.h"
45 
46 #define EPIC_PIX_STACK_SIZE 1024
47 #define EPIC_PIX_STACK_MAX (EPIC_PIX_STACK_SIZE - 1)
48 
49 enum ChunkType {
50  DISPLAY_INFO = 0xC8,
51  TILE_DATA,
52  CURSOR_POS,
53  CURSOR_SHAPE,
54  CHUNK_CC,
55  CHUNK_CD
56 };
57 
58 enum Compression {
59  COMPR_EPIC_J_B = 2,
60  COMPR_KEMPF_J_B,
61 };
62 
63 /* These tables are already permuted according to ff_zigzag_direct */
64 static const uint8_t luma_quant[64] = {
65  8, 6, 6, 7, 6, 5, 8, 7,
66  7, 7, 9, 9, 8, 10, 12, 20,
67  13, 12, 11, 11, 12, 25, 18, 19,
68  15, 20, 29, 26, 31, 30, 29, 26,
69  28, 28, 32, 36, 46, 39, 32, 34,
70  44, 35, 28, 28, 40, 55, 41, 44,
71  48, 49, 52, 52, 52, 31, 39, 57,
72  61, 56, 50, 60, 46, 51, 52, 50,
73 };
74 
75 static const uint8_t chroma_quant[64] = {
76  9, 9, 9, 12, 11, 12, 24, 13,
77  13, 24, 50, 33, 28, 33, 50, 50,
78  50, 50, 50, 50, 50, 50, 50, 50,
79  50, 50, 50, 50, 50, 50, 50, 50,
80  50, 50, 50, 50, 50, 50, 50, 50,
81  50, 50, 50, 50, 50, 50, 50, 50,
82  50, 50, 50, 50, 50, 50, 50, 50,
83  50, 50, 50, 50, 50, 50, 50, 50,
84 };
85 
86 typedef struct ePICPixListElem {
87  struct ePICPixListElem *next;
88  uint32_t pixel;
89  uint8_t rung;
90 } ePICPixListElem;
91 
92 typedef struct ePICPixHashElem {
93  uint32_t pix_id;
94  struct ePICPixListElem *list;
95 } ePICPixHashElem;
96 
97 #define EPIC_HASH_SIZE 256
98 typedef struct ePICPixHash {
99  ePICPixHashElem *bucket[EPIC_HASH_SIZE];
100  int bucket_size[EPIC_HASH_SIZE];
101  int bucket_fill[EPIC_HASH_SIZE];
102 } ePICPixHash;
103 
104 typedef struct ePICContext {
105  ElsDecCtx els_ctx;
106  int next_run_pos;
107  ElsUnsignedRung unsigned_rung;
108  uint8_t W_flag_rung;
109  uint8_t N_flag_rung;
110  uint8_t W_ctx_rung[256];
111  uint8_t N_ctx_rung[512];
112  uint8_t nw_pred_rung[256];
113  uint8_t ne_pred_rung[256];
114  uint8_t prev_row_rung[14];
115  uint8_t runlen_zeroes[14];
116  uint8_t runlen_one;
117  int stack_pos;
118  uint32_t stack[EPIC_PIX_STACK_SIZE];
119  ePICPixHash hash;
120 } ePICContext;
121 
122 typedef struct JPGContext {
123  BlockDSPContext bdsp;
124  IDCTDSPContext idsp;
125  uint8_t permutated_scantable[64];
126 
127  VLC dc_vlc[2], ac_vlc[2];
128  int prev_dc[3];
129  DECLARE_ALIGNED(32, int16_t, block)[6][64];
130 
131  uint8_t *buf;
132 } JPGContext;
133 
134 typedef struct G2MContext {
135  ePICContext ec;
136  JPGContext jc;
137 
138  int version;
139 
140  int compression;
141  int width, height, bpp;
142  int orig_width, orig_height;
143  int tile_width, tile_height;
144  int tiles_x, tiles_y, tile_x, tile_y;
145 
146  int got_header;
147 
148  uint8_t *framebuf;
149  int framebuf_stride;
150  unsigned int framebuf_allocated;
151 
152  uint8_t *synth_tile, *jpeg_tile, *epic_buf, *epic_buf_base;
153  int tile_stride, epic_buf_stride, old_tile_w, old_tile_h;
154  int swapuv;
155 
156  uint8_t *kempf_buf, *kempf_flags;
157 
158  uint8_t *cursor;
159  int cursor_stride;
160  int cursor_fmt;
161  int cursor_w, cursor_h, cursor_x, cursor_y;
162  int cursor_hot_x, cursor_hot_y;
163 } G2MContext;
164 
165 static av_cold int jpg_init(AVCodecContext *avctx, JPGContext *c)
166 {
167  int ret;
168 
169  ret = ff_mjpeg_build_vlc(&c->dc_vlc[0], ff_mjpeg_bits_dc_luminance,
170  ff_mjpeg_val_dc, 0, avctx);
171  if (ret)
172  return ret;
173  ret = ff_mjpeg_build_vlc(&c->dc_vlc[1], ff_mjpeg_bits_dc_chrominance,
174  ff_mjpeg_val_dc, 0, avctx);
175  if (ret)
176  return ret;
177  ret = ff_mjpeg_build_vlc(&c->ac_vlc[0], ff_mjpeg_bits_ac_luminance,
178  ff_mjpeg_val_ac_luminance, 1, avctx);
179  if (ret)
180  return ret;
181  ret = ff_mjpeg_build_vlc(&c->ac_vlc[1], ff_mjpeg_bits_ac_chrominance,
182  ff_mjpeg_val_ac_chrominance, 1, avctx);
183  if (ret)
184  return ret;
185 
186  ff_blockdsp_init(&c->bdsp);
187  ff_idctdsp_init(&c->idsp, avctx);
188  ff_permute_scantable(c->permutated_scantable, ff_zigzag_direct,
189  c->idsp.idct_permutation);
190 
191  return 0;
192 }
193 
194 static av_cold void jpg_free_context(JPGContext *ctx)
195 {
196  int i;
197 
198  for (i = 0; i < 2; i++) {
199  ff_vlc_free(&ctx->dc_vlc[i]);
200  ff_vlc_free(&ctx->ac_vlc[i]);
201  }
202 
203  av_freep(&ctx->buf);
204 }
205 
206 static void jpg_unescape(const uint8_t *src, int src_size,
207  uint8_t *dst, int *dst_size)
208 {
209  const uint8_t *src_end = src + src_size;
210  uint8_t *dst_start = dst;
211 
212  while (src < src_end) {
213  uint8_t x = *src++;
214 
215  *dst++ = x;
216 
217  if (x == 0xFF && !*src)
218  src++;
219  }
220  *dst_size = dst - dst_start;
221 }
222 
223 static int jpg_decode_block(JPGContext *c, GetBitContext *gb,
224  int plane, int16_t *block)
225 {
226  int dc, val, pos;
227  const int is_chroma = !!plane;
228  const uint8_t *qmat = is_chroma ? chroma_quant : luma_quant;
229 
230  if (get_bits_left(gb) < 1)
231  return AVERROR_INVALIDDATA;
232 
233  c->bdsp.clear_block(block);
234  dc = get_vlc2(gb, c->dc_vlc[is_chroma].table, 9, 2);
235  if (dc < 0)
236  return AVERROR_INVALIDDATA;
237  if (dc)
238  dc = get_xbits(gb, dc);
239  dc = dc * qmat[0] + c->prev_dc[plane];
240  block[0] = dc;
241  c->prev_dc[plane] = dc;
242 
243  pos = 0;
244  while (pos < 63) {
245  val = get_vlc2(gb, c->ac_vlc[is_chroma].table, 9, 2);
246  if (val < 0)
247  return AVERROR_INVALIDDATA;
248  pos += val >> 4;
249  val &= 0xF;
250  if (pos > 63)
251  return val ? AVERROR_INVALIDDATA : 0;
252  if (val) {
253  int nbits = val;
254 
255  val = get_xbits(gb, nbits);
256  val *= qmat[pos];
257  block[c->permutated_scantable[pos]] = val;
258  }
259  }
260  return 0;
261 }
262 
263 static inline void yuv2rgb(uint8_t *out, int ridx, int Y, int U, int V)
264 {
265  out[ridx] = av_clip_uint8(Y + (91881 * V + 32768 >> 16));
266  out[1] = av_clip_uint8(Y + (-22554 * U - 46802 * V + 32768 >> 16));
267  out[2 - ridx] = av_clip_uint8(Y + (116130 * U + 32768 >> 16));
268 }
269 
270 static int jpg_decode_data(JPGContext *c, int width, int height,
271  const uint8_t *src, int src_size,
272  uint8_t *dst, int dst_stride,
273  const uint8_t *mask, int mask_stride, int num_mbs,
274  int swapuv)
275 {
276  GetBitContext gb;
277  int mb_w, mb_h, mb_x, mb_y, i, j;
278  int bx, by;
279  int unesc_size;
280  int ret;
281  const int ridx = swapuv ? 2 : 0;
282 
283  if ((ret = av_reallocp(&c->buf,
284  src_size + AV_INPUT_BUFFER_PADDING_SIZE)) < 0)
285  return ret;
286  jpg_unescape(src, src_size, c->buf, &unesc_size);
287  memset(c->buf + unesc_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
288  if((ret = init_get_bits8(&gb, c->buf, unesc_size)) < 0)
289  return ret;
290 
291  width = FFALIGN(width, 16);
292  mb_w = width >> 4;
293  mb_h = (height + 15) >> 4;
294 
295  if (!num_mbs)
296  num_mbs = mb_w * mb_h * 4;
297 
298  for (i = 0; i < 3; i++)
299  c->prev_dc[i] = 1024;
300  bx =
301  by = 0;
302  c->bdsp.clear_blocks(c->block[0]);
303  for (mb_y = 0; mb_y < mb_h; mb_y++) {
304  for (mb_x = 0; mb_x < mb_w; mb_x++) {
305  if (mask && !mask[mb_x * 2] && !mask[mb_x * 2 + 1] &&
306  !mask[mb_x * 2 + mask_stride] &&
307  !mask[mb_x * 2 + 1 + mask_stride]) {
308  bx += 16;
309  continue;
310  }
311  for (j = 0; j < 2; j++) {
312  for (i = 0; i < 2; i++) {
313  if (mask && !mask[mb_x * 2 + i + j * mask_stride])
314  continue;
315  num_mbs--;
316  if ((ret = jpg_decode_block(c, &gb, 0,
317  c->block[i + j * 2])) != 0)
318  return ret;
319  c->idsp.idct(c->block[i + j * 2]);
320  }
321  }
322  for (i = 1; i < 3; i++) {
323  if ((ret = jpg_decode_block(c, &gb, i, c->block[i + 3])) != 0)
324  return ret;
325  c->idsp.idct(c->block[i + 3]);
326  }
327 
328  for (j = 0; j < 16; j++) {
329  uint8_t *out = dst + bx * 3 + (by + j) * dst_stride;
330  for (i = 0; i < 16; i++) {
331  int Y, U, V;
332 
333  Y = c->block[(j >> 3) * 2 + (i >> 3)][(i & 7) + (j & 7) * 8];
334  U = c->block[4][(i >> 1) + (j >> 1) * 8] - 128;
335  V = c->block[5][(i >> 1) + (j >> 1) * 8] - 128;
336  yuv2rgb(out + i * 3, ridx, Y, U, V);
337  }
338  }
339 
340  if (!num_mbs)
341  return 0;
342  bx += 16;
343  }
344  bx = 0;
345  by += 16;
346  if (mask)
347  mask += mask_stride * 2;
348  }
349 
350  return 0;
351 }
352 
353 #define LOAD_NEIGHBOURS(x) \
354  W = curr_row[(x) - 1]; \
355  N = above_row[(x)]; \
356  WW = curr_row[(x) - 2]; \
357  NW = above_row[(x) - 1]; \
358  NE = above_row[(x) + 1]; \
359  NN = above2_row[(x)]; \
360  NNW = above2_row[(x) - 1]; \
361  NWW = above_row[(x) - 2]; \
362  NNE = above2_row[(x) + 1]
363 
364 #define UPDATE_NEIGHBOURS(x) \
365  NNW = NN; \
366  NN = NNE; \
367  NWW = NW; \
368  NW = N; \
369  N = NE; \
370  NE = above_row[(x) + 1]; \
371  NNE = above2_row[(x) + 1]
372 
373 #define R_shift 16
374 #define G_shift 8
375 #define B_shift 0
376 
377 /* improved djb2 hash from http://www.cse.yorku.ca/~oz/hash.html */
378 static int djb2_hash(uint32_t key)
379 {
380  uint32_t h = 5381;
381 
382  h = (h * 33) ^ ((key >> 24) & 0xFF); // xxx: probably not needed at all
383  h = (h * 33) ^ ((key >> 16) & 0xFF);
384  h = (h * 33) ^ ((key >> 8) & 0xFF);
385  h = (h * 33) ^ (key & 0xFF);
386 
387  return h & (EPIC_HASH_SIZE - 1);
388 }
389 
390 static void epic_hash_init(ePICPixHash *hash)
391 {
392  memset(hash, 0, sizeof(*hash));
393 }
394 
395 static ePICPixHashElem *epic_hash_find(const ePICPixHash *hash, uint32_t key)
396 {
397  int i, idx = djb2_hash(key);
398  ePICPixHashElem *bucket = hash->bucket[idx];
399 
400  for (i = 0; i < hash->bucket_fill[idx]; i++)
401  if (bucket[i].pix_id == key)
402  return &bucket[i];
403 
404  return NULL;
405 }
406 
407 static ePICPixHashElem *epic_hash_add(ePICPixHash *hash, uint32_t key)
408 {
409  ePICPixHashElem *bucket, *ret;
410  int idx = djb2_hash(key);
411 
412  if (hash->bucket_size[idx] > INT_MAX / sizeof(**hash->bucket))
413  return NULL;
414 
415  if (!(hash->bucket_fill[idx] < hash->bucket_size[idx])) {
416  int new_size = hash->bucket_size[idx] + 16;
417  bucket = av_realloc(hash->bucket[idx], new_size * sizeof(*bucket));
418  if (!bucket)
419  return NULL;
420  hash->bucket[idx] = bucket;
421  hash->bucket_size[idx] = new_size;
422  }
423 
424  ret = &hash->bucket[idx][hash->bucket_fill[idx]++];
425  memset(ret, 0, sizeof(*ret));
426  ret->pix_id = key;
427  return ret;
428 }
429 
430 static int epic_add_pixel_to_cache(ePICPixHash *hash, uint32_t key, uint32_t pix)
431 {
432  ePICPixListElem *new_elem;
433  ePICPixHashElem *hash_elem = epic_hash_find(hash, key);
434 
435  if (!hash_elem) {
436  if (!(hash_elem = epic_hash_add(hash, key)))
437  return AVERROR(ENOMEM);
438  }
439 
440  new_elem = av_mallocz(sizeof(*new_elem));
441  if (!new_elem)
442  return AVERROR(ENOMEM);
443 
444  new_elem->pixel = pix;
445  new_elem->next = hash_elem->list;
446  hash_elem->list = new_elem;
447 
448  return 0;
449 }
450 
451 static inline int epic_cache_entries_for_pixel(const ePICPixHash *hash,
452  uint32_t pix)
453 {
454  ePICPixHashElem *hash_elem = epic_hash_find(hash, pix);
455 
456  if (hash_elem != NULL && hash_elem->list != NULL)
457  return 1;
458 
459  return 0;
460 }
461 
462 static void epic_free_pixel_cache(ePICPixHash *hash)
463 {
464  int i, j;
465 
466  for (i = 0; i < EPIC_HASH_SIZE; i++) {
467  for (j = 0; j < hash->bucket_fill[i]; j++) {
468  ePICPixListElem *list_elem = hash->bucket[i][j].list;
469  while (list_elem) {
470  ePICPixListElem *tmp = list_elem->next;
471  av_free(list_elem);
472  list_elem = tmp;
473  }
474  }
475  av_freep(&hash->bucket[i]);
476  hash->bucket_size[i] =
477  hash->bucket_fill[i] = 0;
478  }
479 }
480 
481 static inline int is_pixel_on_stack(const ePICContext *dc, uint32_t pix)
482 {
483  int i;
484 
485  for (i = 0; i < dc->stack_pos; i++)
486  if (dc->stack[i] == pix)
487  break;
488 
489  return i != dc->stack_pos;
490 }
491 
492 #define TOSIGNED(val) (((val) >> 1) ^ -((val) & 1))
493 
494 static inline int epic_decode_component_pred(ePICContext *dc,
495  int N, int W, int NW)
496 {
497  unsigned delta = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);
498  return mid_pred(N, N + W - NW, W) - TOSIGNED(delta);
499 }
500 
501 static uint32_t epic_decode_pixel_pred(ePICContext *dc, int x, int y,
502  const uint32_t *curr_row,
503  const uint32_t *above_row)
504 {
505  uint32_t N, W, NW, pred;
506  unsigned delta;
507  int GN, GW, GNW, R, G, B;
508 
509  if (x && y) {
510  W = curr_row[x - 1];
511  N = above_row[x];
512  NW = above_row[x - 1];
513 
514  GN = (N >> G_shift) & 0xFF;
515  GW = (W >> G_shift) & 0xFF;
516  GNW = (NW >> G_shift) & 0xFF;
517 
518  G = epic_decode_component_pred(dc, GN, GW, GNW);
519 
520  R = G + epic_decode_component_pred(dc,
521  ((N >> R_shift) & 0xFF) - GN,
522  ((W >> R_shift) & 0xFF) - GW,
523  ((NW >> R_shift) & 0xFF) - GNW);
524 
525  B = G + epic_decode_component_pred(dc,
526  ((N >> B_shift) & 0xFF) - GN,
527  ((W >> B_shift) & 0xFF) - GW,
528  ((NW >> B_shift) & 0xFF) - GNW);
529  } else {
530  if (x)
531  pred = curr_row[x - 1];
532  else
533  pred = above_row[x];
534 
535  delta = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);
536  R = ((pred >> R_shift) & 0xFF) - TOSIGNED(delta);
537 
538  delta = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);
539  G = ((pred >> G_shift) & 0xFF) - TOSIGNED(delta);
540 
541  delta = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);
542  B = ((pred >> B_shift) & 0xFF) - TOSIGNED(delta);
543  }
544 
545  if (R<0 || G<0 || B<0 || R > 255 || G > 255 || B > 255) {
546  avpriv_request_sample(NULL, "RGB %d %d %d (out of range)", R, G, B);
547  return 0;
548  }
549 
550  return (R << R_shift) | (G << G_shift) | (B << B_shift);
551 }
552 
553 static int epic_predict_pixel(ePICContext *dc, uint8_t *rung,
554  uint32_t *pPix, uint32_t pix)
555 {
556  if (!ff_els_decode_bit(&dc->els_ctx, rung)) {
557  *pPix = pix;
558  return 1;
559  }
560  dc->stack[dc->stack_pos++ & EPIC_PIX_STACK_MAX] = pix;
561  return 0;
562 }
563 
564 static int epic_handle_edges(ePICContext *dc, int x, int y,
565  const uint32_t *curr_row,
566  const uint32_t *above_row, uint32_t *pPix)
567 {
568  uint32_t pix;
569 
570  if (!x && !y) { /* special case: top-left pixel */
571  /* the top-left pixel is coded independently with 3 unsigned numbers */
572  *pPix = (ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung) << R_shift) |
573  (ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung) << G_shift) |
574  (ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung) << B_shift);
575  return 1;
576  }
577 
578  if (x) { /* predict from W first */
579  pix = curr_row[x - 1];
580  if (epic_predict_pixel(dc, &dc->W_flag_rung, pPix, pix))
581  return 1;
582  }
583 
584  if (y) { /* then try to predict from N */
585  pix = above_row[x];
586  if (!dc->stack_pos || dc->stack[0] != pix) {
587  if (epic_predict_pixel(dc, &dc->N_flag_rung, pPix, pix))
588  return 1;
589  }
590  }
591 
592  return 0;
593 }
594 
595 static int epic_decode_run_length(ePICContext *dc, int x, int y, int tile_width,
596  const uint32_t *curr_row,
597  const uint32_t *above_row,
598  const uint32_t *above2_row,
599  uint32_t *pPix, int *pRun)
600 {
601  int idx, got_pixel = 0, WWneW, old_WWneW = 0;
602  uint32_t W, WW, N, NN, NW, NE, NWW, NNW, NNE;
603 
604  *pRun = 0;
605 
606  LOAD_NEIGHBOURS(x);
607 
608  if (dc->next_run_pos == x) {
609  /* can't reuse W for the new pixel in this case */
610  WWneW = 1;
611  } else {
612  idx = (WW != W) << 7 |
613  (NW != W) << 6 |
614  (N != NE) << 5 |
615  (NW != N) << 4 |
616  (NWW != NW) << 3 |
617  (NNE != NE) << 2 |
618  (NN != N) << 1 |
619  (NNW != NW);
620  WWneW = ff_els_decode_bit(&dc->els_ctx, &dc->W_ctx_rung[idx]);
621  if (WWneW < 0)
622  return WWneW;
623  }
624 
625  if (WWneW)
626  dc->stack[dc->stack_pos++ & EPIC_PIX_STACK_MAX] = W;
627  else {
628  *pPix = W;
629  got_pixel = 1;
630  }
631 
632  do {
633  int NWneW = 1;
634  if (got_pixel) // pixel value already known (derived from either W or N)
635  NWneW = *pPix != N;
636  else { // pixel value is unknown and will be decoded later
637  NWneW = *pRun ? NWneW : NW != W;
638 
639  /* TODO: RFC this mess! */
640  switch (((NW != N) << 2) | (NWneW << 1) | WWneW) {
641  case 0:
642  break; // do nothing here
643  case 3:
644  case 5:
645  case 6:
646  case 7:
647  if (!is_pixel_on_stack(dc, N)) {
648  idx = WWneW << 8 |
649  (*pRun ? old_WWneW : WW != W) << 7 |
650  NWneW << 6 |
651  (N != NE) << 5 |
652  (NW != N) << 4 |
653  (NWW != NW) << 3 |
654  (NNE != NE) << 2 |
655  (NN != N) << 1 |
656  (NNW != NW);
657  if (!ff_els_decode_bit(&dc->els_ctx, &dc->N_ctx_rung[idx])) {
658  NWneW = 0;
659  *pPix = N;
660  got_pixel = 1;
661  break;
662  }
663  }
664  /* fall through */
665  default:
666  NWneW = 1;
667  old_WWneW = WWneW;
668  if (!is_pixel_on_stack(dc, N))
669  dc->stack[dc->stack_pos++ & EPIC_PIX_STACK_MAX] = N;
670  }
671  }
672 
673  (*pRun)++;
674  if (x + *pRun >= tile_width - 1)
675  break;
676 
677  UPDATE_NEIGHBOURS(x + *pRun);
678 
679  if (!NWneW && NW == N && N == NE) {
680  int pos, run, rle;
681  int start_pos = x + *pRun;
682 
683  /* scan for a run of pix in the line above */
684  uint32_t pix = above_row[start_pos + 1];
685  for (pos = start_pos + 2; pos < tile_width; pos++)
686  if (!(above_row[pos] == pix))
687  break;
688  run = pos - start_pos - 1;
689  idx = av_ceil_log2(run);
690  if (ff_els_decode_bit(&dc->els_ctx, &dc->prev_row_rung[idx]))
691  *pRun += run;
692  else {
693  int flag;
694  /* run-length is coded as plain binary number of idx - 1 bits */
695  for (pos = idx - 1, rle = 0, flag = 0; pos >= 0; pos--) {
696  if ((1 << pos) + rle < run &&
697  ff_els_decode_bit(&dc->els_ctx,
698  flag ? &dc->runlen_one
699  : &dc->runlen_zeroes[pos])) {
700  flag = 1;
701  rle |= 1 << pos;
702  }
703  }
704  *pRun += rle;
705  break; // return immediately
706  }
707  if (x + *pRun >= tile_width - 1)
708  break;
709 
710  LOAD_NEIGHBOURS(x + *pRun);
711  WWneW = 0;
712  NWneW = 0;
713  }
714 
715  idx = WWneW << 7 |
716  NWneW << 6 |
717  (N != NE) << 5 |
718  (NW != N) << 4 |
719  (NWW != NW) << 3 |
720  (NNE != NE) << 2 |
721  (NN != N) << 1 |
722  (NNW != NW);
723  WWneW = ff_els_decode_bit(&dc->els_ctx, &dc->W_ctx_rung[idx]);
724  } while (!WWneW);
725 
726  dc->next_run_pos = x + *pRun;
727  return got_pixel;
728 }
729 
730 static int epic_predict_pixel2(ePICContext *dc, uint8_t *rung,
731  uint32_t *pPix, uint32_t pix)
732 {
733  if (ff_els_decode_bit(&dc->els_ctx, rung)) {
734  *pPix = pix;
735  return 1;
736  }
737  dc->stack[dc->stack_pos++ & EPIC_PIX_STACK_MAX] = pix;
738  return 0;
739 }
740 
741 static int epic_predict_from_NW_NE(ePICContext *dc, int x, int y, int run,
742  int tile_width, const uint32_t *curr_row,
743  const uint32_t *above_row, uint32_t *pPix)
744 {
745  int pos;
746 
747  /* try to reuse the NW pixel first */
748  if (x && y) {
749  uint32_t NW = above_row[x - 1];
750  if (NW != curr_row[x - 1] && NW != above_row[x] && !is_pixel_on_stack(dc, NW)) {
751  if (epic_predict_pixel2(dc, &dc->nw_pred_rung[NW & 0xFF], pPix, NW))
752  return 1;
753  }
754  }
755 
756  /* try to reuse the NE[x + run, y] pixel */
757  pos = x + run - 1;
758  if (pos < tile_width - 1 && y) {
759  uint32_t NE = above_row[pos + 1];
760  if (NE != above_row[pos] && !is_pixel_on_stack(dc, NE)) {
761  if (epic_predict_pixel2(dc, &dc->ne_pred_rung[NE & 0xFF], pPix, NE))
762  return 1;
763  }
764  }
765 
766  return 0;
767 }
768 
769 static int epic_decode_from_cache(ePICContext *dc, uint32_t W, uint32_t *pPix)
770 {
771  ePICPixListElem *list, *prev = NULL;
772  ePICPixHashElem *hash_elem = epic_hash_find(&dc->hash, W);
773 
774  if (!hash_elem || !hash_elem->list)
775  return 0;
776 
777  list = hash_elem->list;
778  while (list) {
779  if (!is_pixel_on_stack(dc, list->pixel)) {
780  if (ff_els_decode_bit(&dc->els_ctx, &list->rung)) {
781  *pPix = list->pixel;
782  if (list != hash_elem->list) {
783  prev->next = list->next;
784  list->next = hash_elem->list;
785  hash_elem->list = list;
786  }
787  return 1;
788  }
789  dc->stack[dc->stack_pos++ & EPIC_PIX_STACK_MAX] = list->pixel;
790  }
791  prev = list;
792  list = list->next;
793  }
794 
795  return 0;
796 }
797 
798 static int epic_decode_tile(ePICContext *dc, uint8_t *out, int tile_height,
799  int tile_width, int stride)
800 {
801  int x, y;
802  uint32_t pix;
803  uint32_t *curr_row = NULL, *above_row = NULL, *above2_row;
804 
805  for (y = 0; y < tile_height; y++, out += stride) {
806  above2_row = above_row;
807  above_row = curr_row;
808  curr_row = (uint32_t *) out;
809 
810  for (x = 0, dc->next_run_pos = 0; x < tile_width;) {
811  if (dc->els_ctx.err)
812  return AVERROR_INVALIDDATA; // bail out in the case of ELS overflow
813 
814  pix = curr_row[x - 1]; // get W pixel
815 
816  if (y >= 1 && x >= 2 &&
817  pix != curr_row[x - 2] && pix != above_row[x - 1] &&
818  pix != above_row[x - 2] && pix != above_row[x] &&
819  !epic_cache_entries_for_pixel(&dc->hash, pix)) {
820  curr_row[x] = epic_decode_pixel_pred(dc, x, y, curr_row, above_row);
821  x++;
822  } else {
823  int got_pixel, run;
824  dc->stack_pos = 0; // empty stack
825 
826  if (y < 2 || x < 2 || x == tile_width - 1) {
827  run = 1;
828  got_pixel = epic_handle_edges(dc, x, y, curr_row, above_row, &pix);
829  } else {
830  got_pixel = epic_decode_run_length(dc, x, y, tile_width,
831  curr_row, above_row,
832  above2_row, &pix, &run);
833  if (got_pixel < 0)
834  return got_pixel;
835  }
836 
837  if (!got_pixel && !epic_predict_from_NW_NE(dc, x, y, run,
838  tile_width, curr_row,
839  above_row, &pix)) {
840  uint32_t ref_pix = curr_row[x - 1];
841  if (!x || !epic_decode_from_cache(dc, ref_pix, &pix)) {
842  pix = epic_decode_pixel_pred(dc, x, y, curr_row, above_row);
843  if (is_pixel_on_stack(dc, pix))
844  return AVERROR_INVALIDDATA;
845 
846  if (x) {
847  int ret = epic_add_pixel_to_cache(&dc->hash,
848  ref_pix,
849  pix);
850  if (ret)
851  return ret;
852  }
853  }
854  }
855  for (; run > 0; x++, run--)
856  curr_row[x] = pix;
857  }
858  }
859  }
860 
861  return 0;
862 }
863 
864 static int epic_jb_decode_tile(G2MContext *c, int tile_x, int tile_y,
865  const uint8_t *src, size_t src_size,
866  AVCodecContext *avctx)
867 {
868  uint8_t prefix, mask = 0x80;
869  int extrabytes, tile_width, tile_height, awidth, aheight;
870  size_t els_dsize;
871  uint8_t *dst;
872 
873  if (!src_size)
874  return 0;
875 
876  /* get data size of the ELS partition as unsigned variable-length integer */
877  prefix = *src++;
878  src_size--;
879  for (extrabytes = 0; (prefix & mask) && (extrabytes < 7); extrabytes++)
880  mask >>= 1;
881  if (extrabytes > 3 || src_size < extrabytes) {
882  av_log(avctx, AV_LOG_ERROR, "ePIC: invalid data size VLI\n");
883  return AVERROR_INVALIDDATA;
884  }
885 
886  els_dsize = prefix & ((0x80 >> extrabytes) - 1); // mask out the length prefix
887  while (extrabytes-- > 0) {
888  els_dsize = (els_dsize << 8) | *src++;
889  src_size--;
890  }
891 
892  if (src_size < els_dsize) {
893  av_log(avctx, AV_LOG_ERROR, "ePIC: data too short, needed %"SIZE_SPECIFIER", got %"SIZE_SPECIFIER"\n",
894  els_dsize, src_size);
895  return AVERROR_INVALIDDATA;
896  }
897 
898  tile_width = FFMIN(c->width - tile_x * c->tile_width, c->tile_width);
899  tile_height = FFMIN(c->height - tile_y * c->tile_height, c->tile_height);
900  awidth = FFALIGN(tile_width, 16);
901  aheight = FFALIGN(tile_height, 16);
902 
903  if (tile_width > (1 << FF_ARRAY_ELEMS(c->ec.prev_row_rung))) {
904  avpriv_request_sample(avctx, "large tile width");
905  return AVERROR_INVALIDDATA;
906  }
907 
908  if (els_dsize) {
909  int ret, i, j, k;
910  uint8_t tr_r, tr_g, tr_b, *buf;
911  uint32_t *in;
912  /* ELS decoder initializations */
913  memset(&c->ec, 0, sizeof(c->ec));
914  ff_els_decoder_init(&c->ec.els_ctx, src, els_dsize);
915  epic_hash_init(&c->ec.hash);
916 
917  /* decode transparent pixel value */
918  tr_r = ff_els_decode_unsigned(&c->ec.els_ctx, &c->ec.unsigned_rung);
919  tr_g = ff_els_decode_unsigned(&c->ec.els_ctx, &c->ec.unsigned_rung);
920  tr_b = ff_els_decode_unsigned(&c->ec.els_ctx, &c->ec.unsigned_rung);
921  if (c->ec.els_ctx.err != 0) {
922  av_log(avctx, AV_LOG_ERROR,
923  "ePIC: couldn't decode transparency pixel!\n");
924  ff_els_decoder_uninit(&c->ec.unsigned_rung);
925  return AVERROR_INVALIDDATA;
926  }
927 
928  ret = epic_decode_tile(&c->ec, c->epic_buf, tile_height, tile_width,
929  c->epic_buf_stride);
930 
931  epic_free_pixel_cache(&c->ec.hash);
932  ff_els_decoder_uninit(&c->ec.unsigned_rung);
933 
934  if (ret) {
935  av_log(avctx, AV_LOG_ERROR,
936  "ePIC: tile decoding failed, frame=%"PRId64", tile_x=%d, tile_y=%d\n",
937  avctx->frame_num, tile_x, tile_y);
938  return AVERROR_INVALIDDATA;
939  }
940 
941  buf = c->epic_buf;
942  dst = c->framebuf + tile_x * c->tile_width * 3 +
943  tile_y * c->tile_height * c->framebuf_stride;
944 
945  for (j = 0; j < tile_height; j++) {
946  uint8_t *out = dst;
947  in = (uint32_t *) buf;
948  for (i = 0; i < tile_width; i++) {
949  out[0] = (in[i] >> R_shift) & 0xFF;
950  out[1] = (in[i] >> G_shift) & 0xFF;
951  out[2] = (in[i] >> B_shift) & 0xFF;
952  out += 3;
953  }
954  buf += c->epic_buf_stride;
955  dst += c->framebuf_stride;
956  }
957 
958  if (src_size > els_dsize) {
959  uint8_t *jpg;
960  uint32_t tr;
961  int bstride = FFALIGN(tile_width, 16) >> 3;
962  int nblocks = 0;
963  int estride = c->epic_buf_stride >> 2;
964 
965  src += els_dsize;
966  src_size -= els_dsize;
967 
968  in = (uint32_t *) c->epic_buf;
969  tr = (tr_r << R_shift) | (tr_g << G_shift) | (tr_b << B_shift);
970 
971  memset(c->kempf_flags, 0,
972  (aheight >> 3) * bstride * sizeof(*c->kempf_flags));
973  for (j = 0; j < tile_height; j += 8) {
974  for (i = 0; i < tile_width; i += 8) {
975  c->kempf_flags[(i >> 3) + (j >> 3) * bstride] = 0;
976  for (k = 0; k < 8 * 8; k++) {
977  if (in[i + (k & 7) + (k >> 3) * estride] == tr) {
978  c->kempf_flags[(i >> 3) + (j >> 3) * bstride] = 1;
979  nblocks++;
980  break;
981  }
982  }
983  }
984  in += 8 * estride;
985  }
986 
987  memset(c->jpeg_tile, 0, c->tile_stride * aheight);
988  jpg_decode_data(&c->jc, awidth, aheight, src, src_size,
989  c->jpeg_tile, c->tile_stride,
990  c->kempf_flags, bstride, nblocks, c->swapuv);
991 
992  in = (uint32_t *) c->epic_buf;
993  dst = c->framebuf + tile_x * c->tile_width * 3 +
994  tile_y * c->tile_height * c->framebuf_stride;
995  jpg = c->jpeg_tile;
996  for (j = 0; j < tile_height; j++) {
997  for (i = 0; i < tile_width; i++)
998  if (in[i] == tr)
999  memcpy(dst + i * 3, jpg + i * 3, 3);
1000  in += c->epic_buf_stride >> 2;
1001  dst += c->framebuf_stride;
1002  jpg += c->tile_stride;
1003  }
1004  }
1005  } else {
1006  dst = c->framebuf + tile_x * c->tile_width * 3 +
1007  tile_y * c->tile_height * c->framebuf_stride;
1008  return jpg_decode_data(&c->jc, tile_width, tile_height, src, src_size,
1009  dst, c->framebuf_stride, NULL, 0, 0, c->swapuv);
1010  }
1011 
1012  return 0;
1013 }
1014 
1015 static int kempf_restore_buf(const uint8_t *src, int len,
1016  uint8_t *dst, int stride,
1017  const uint8_t *jpeg_tile, int tile_stride,
1018  int width, int height,
1019  const uint8_t *pal, int npal, int tidx)
1020 {
1021  GetBitContext gb;
1022  int i, j, nb, col;
1023  int ret;
1024  int align_width = FFALIGN(width, 16);
1025 
1026  if ((ret = init_get_bits8(&gb, src, len)) < 0)
1027  return ret;
1028 
1029  if (npal <= 2) nb = 1;
1030  else if (npal <= 4) nb = 2;
1031  else if (npal <= 16) nb = 4;
1032  else nb = 8;
1033 
1034  for (j = 0; j < height; j++, dst += stride, jpeg_tile = FF_PTR_ADD(jpeg_tile, tile_stride)) {
1035  if (get_bits(&gb, 8))
1036  continue;
1037  for (i = 0; i < width; i++) {
1038  col = get_bits(&gb, nb);
1039  if (col != tidx)
1040  memcpy(dst + i * 3, pal + col * 3, 3);
1041  else
1042  memcpy(dst + i * 3, jpeg_tile + i * 3, 3);
1043  }
1044  skip_bits_long(&gb, nb * (align_width - width));
1045  }
1046 
1047  return 0;
1048 }
1049 
1050 static int kempf_decode_tile(G2MContext *c, int tile_x, int tile_y,
1051  const uint8_t *src, int src_size)
1052 {
1053  int width, height;
1054  int hdr, zsize, npal, tidx = -1, ret;
1055  int i, j;
1056  const uint8_t *src_end = src + src_size;
1057  uint8_t pal[768], transp[3];
1058  uLongf dlen = (c->tile_width + 1) * c->tile_height;
1059  int sub_type;
1060  int nblocks, cblocks, bstride;
1061  int bits, bitbuf, coded;
1062  uint8_t *dst = c->framebuf + tile_x * c->tile_width * 3 +
1063  tile_y * c->tile_height * c->framebuf_stride;
1064 
1065  if (src_size < 2)
1066  return AVERROR_INVALIDDATA;
1067 
1068  width = FFMIN(c->width - tile_x * c->tile_width, c->tile_width);
1069  height = FFMIN(c->height - tile_y * c->tile_height, c->tile_height);
1070 
1071  hdr = *src++;
1072  sub_type = hdr >> 5;
1073  if (sub_type == 0) {
1074  int j;
1075  memcpy(transp, src, 3);
1076  src += 3;
1077  for (j = 0; j < height; j++, dst += c->framebuf_stride)
1078  for (i = 0; i < width; i++)
1079  memcpy(dst + i * 3, transp, 3);
1080  return 0;
1081  } else if (sub_type == 1) {
1082  return jpg_decode_data(&c->jc, width, height, src, src_end - src,
1083  dst, c->framebuf_stride, NULL, 0, 0, 0);
1084  }
1085 
1086  if (sub_type != 2) {
1087  memcpy(transp, src, 3);
1088  src += 3;
1089  }
1090  npal = *src++ + 1;
1091  if (src_end - src < npal * 3)
1092  return AVERROR_INVALIDDATA;
1093  memcpy(pal, src, npal * 3);
1094  src += npal * 3;
1095  if (sub_type != 2) {
1096  for (i = 0; i < npal; i++) {
1097  if (!memcmp(pal + i * 3, transp, 3)) {
1098  tidx = i;
1099  break;
1100  }
1101  }
1102  }
1103 
1104  if (src_end - src < 2)
1105  return 0;
1106  zsize = (src[0] << 8) | src[1];
1107  src += 2;
1108 
1109  if (src_end - src < zsize + (sub_type != 2))
1110  return AVERROR_INVALIDDATA;
1111 
1112  ret = uncompress(c->kempf_buf, &dlen, src, zsize);
1113  if (ret)
1114  return AVERROR_INVALIDDATA;
1115  src += zsize;
1116 
1117  if (sub_type == 2) {
1118  kempf_restore_buf(c->kempf_buf, dlen, dst, c->framebuf_stride,
1119  NULL, 0, width, height, pal, npal, tidx);
1120  return 0;
1121  }
1122 
1123  nblocks = *src++ + 1;
1124  cblocks = 0;
1125  bstride = FFALIGN(width, 16) >> 3;
1126  // blocks are coded LSB and we need normal bitreader for JPEG data
1127  bits = 0;
1128  for (i = 0; i < (FFALIGN(height, 16) >> 4); i++) {
1129  for (j = 0; j < (FFALIGN(width, 16) >> 4); j++) {
1130  if (!bits) {
1131  if (src >= src_end)
1132  return AVERROR_INVALIDDATA;
1133  bitbuf = *src++;
1134  bits = 8;
1135  }
1136  coded = bitbuf & 1;
1137  bits--;
1138  bitbuf >>= 1;
1139  cblocks += coded;
1140  if (cblocks > nblocks)
1141  return AVERROR_INVALIDDATA;
1142  c->kempf_flags[j * 2 + i * 2 * bstride] =
1143  c->kempf_flags[j * 2 + 1 + i * 2 * bstride] =
1144  c->kempf_flags[j * 2 + (i * 2 + 1) * bstride] =
1145  c->kempf_flags[j * 2 + 1 + (i * 2 + 1) * bstride] = coded;
1146  }
1147  }
1148 
1149  memset(c->jpeg_tile, 0, c->tile_stride * height);
1150  jpg_decode_data(&c->jc, width, height, src, src_end - src,
1151  c->jpeg_tile, c->tile_stride,
1152  c->kempf_flags, bstride, nblocks * 4, 0);
1153 
1154  kempf_restore_buf(c->kempf_buf, dlen, dst, c->framebuf_stride,
1155  c->jpeg_tile, c->tile_stride,
1156  width, height, pal, npal, tidx);
1157 
1158  return 0;
1159 }
1160 
1161 static int g2m_init_buffers(G2MContext *c)
1162 {
1163  int aligned_height;
1164 
1165  c->framebuf_stride = FFALIGN(c->width + 15, 16) * 3;
1166  aligned_height = c->height + 15;
1167 
1168  av_fast_mallocz(&c->framebuf, &c->framebuf_allocated, c->framebuf_stride * aligned_height);
1169  if (!c->framebuf)
1170  return AVERROR(ENOMEM);
1171 
1172  if (!c->synth_tile || !c->jpeg_tile ||
1173  (c->compression == 2 && !c->epic_buf_base) ||
1174  c->old_tile_w < c->tile_width ||
1175  c->old_tile_h < c->tile_height) {
1176  c->tile_stride = FFALIGN(c->tile_width, 16) * 3;
1177  c->epic_buf_stride = FFALIGN(c->tile_width * 4, 16);
1178  aligned_height = FFALIGN(c->tile_height, 16);
1179  av_freep(&c->synth_tile);
1180  av_freep(&c->jpeg_tile);
1181  av_freep(&c->kempf_buf);
1182  av_freep(&c->kempf_flags);
1183  av_freep(&c->epic_buf_base);
1184  c->epic_buf = NULL;
1185  c->synth_tile = av_mallocz(c->tile_stride * aligned_height);
1186  c->jpeg_tile = av_mallocz(c->tile_stride * aligned_height);
1187  c->kempf_buf = av_mallocz((c->tile_width + 1) * aligned_height +
1188  AV_INPUT_BUFFER_PADDING_SIZE);
1189  c->kempf_flags = av_mallocz(c->tile_width * aligned_height);
1190  if (!c->synth_tile || !c->jpeg_tile ||
1191  !c->kempf_buf || !c->kempf_flags)
1192  return AVERROR(ENOMEM);
1193  if (c->compression == 2) {
1194  c->epic_buf_base = av_mallocz(c->epic_buf_stride * aligned_height + 4);
1195  if (!c->epic_buf_base)
1196  return AVERROR(ENOMEM);
1197  c->epic_buf = c->epic_buf_base + 4;
1198  }
1199  }
1200 
1201  return 0;
1202 }
1203 
1204 static int g2m_load_cursor(AVCodecContext *avctx, G2MContext *c,
1205  GetByteContext *gb)
1206 {
1207  int i, j, k;
1208  uint8_t *dst;
1209  uint32_t bits;
1210  uint32_t cur_size, cursor_w, cursor_h, cursor_stride;
1211  uint32_t cursor_hot_x, cursor_hot_y;
1212  int cursor_fmt, err;
1213 
1214  cur_size = bytestream2_get_be32(gb);
1215  cursor_w = bytestream2_get_byte(gb);
1216  cursor_h = bytestream2_get_byte(gb);
1217  cursor_hot_x = bytestream2_get_byte(gb);
1218  cursor_hot_y = bytestream2_get_byte(gb);
1219  cursor_fmt = bytestream2_get_byte(gb);
1220 
1221  cursor_stride = FFALIGN(cursor_w, cursor_fmt==1 ? 32 : 1) * 4;
1222 
1223  if (cursor_w < 1 || cursor_w > 256 ||
1224  cursor_h < 1 || cursor_h > 256) {
1225  av_log(avctx, AV_LOG_ERROR, "Invalid cursor dimensions %"PRIu32"x%"PRIu32"\n",
1226  cursor_w, cursor_h);
1227  return AVERROR_INVALIDDATA;
1228  }
1229  if (cursor_hot_x > cursor_w || cursor_hot_y > cursor_h) {
1230  av_log(avctx, AV_LOG_WARNING, "Invalid hotspot position %"PRIu32",%"PRIu32"\n",
1231  cursor_hot_x, cursor_hot_y);
1232  cursor_hot_x = FFMIN(cursor_hot_x, cursor_w - 1);
1233  cursor_hot_y = FFMIN(cursor_hot_y, cursor_h - 1);
1234  }
1235  if (cur_size - 9 > bytestream2_get_bytes_left(gb) ||
1236  c->cursor_w * c->cursor_h / 4 > cur_size) {
1237  av_log(avctx, AV_LOG_ERROR, "Invalid cursor data size %"PRIu32"/%u\n",
1238  cur_size, bytestream2_get_bytes_left(gb));
1239  return AVERROR_INVALIDDATA;
1240  }
1241  if (cursor_fmt != 1 && cursor_fmt != 32) {
1242  avpriv_report_missing_feature(avctx, "Cursor format %d",
1243  cursor_fmt);
1244  return AVERROR_PATCHWELCOME;
1245  }
1246 
1247  if ((err = av_reallocp(&c->cursor, cursor_stride * cursor_h)) < 0) {
1248  av_log(avctx, AV_LOG_ERROR, "Cannot allocate cursor buffer\n");
1249  return err;
1250  }
1251 
1252  c->cursor_w = cursor_w;
1253  c->cursor_h = cursor_h;
1254  c->cursor_hot_x = cursor_hot_x;
1255  c->cursor_hot_y = cursor_hot_y;
1256  c->cursor_fmt = cursor_fmt;
1257  c->cursor_stride = cursor_stride;
1258 
1259  dst = c->cursor;
1260  switch (c->cursor_fmt) {
1261  case 1: // old monochrome
1262  for (j = 0; j < c->cursor_h; j++) {
1263  for (i = 0; i < c->cursor_w; i += 32) {
1264  bits = bytestream2_get_be32(gb);
1265  for (k = 0; k < 32; k++) {
1266  dst[0] = !!(bits & 0x80000000);
1267  dst += 4;
1268  bits <<= 1;
1269  }
1270  }
1271  }
1272 
1273  dst = c->cursor;
1274  for (j = 0; j < c->cursor_h; j++) {
1275  for (i = 0; i < c->cursor_w; i += 32) {
1276  bits = bytestream2_get_be32(gb);
1277  for (k = 0; k < 32; k++) {
1278  int mask_bit = !!(bits & 0x80000000);
1279  switch (dst[0] * 2 + mask_bit) {
1280  case 0:
1281  dst[0] = 0xFF;
1282  dst[1] = 0x00;
1283  dst[2] = 0x00;
1284  dst[3] = 0x00;
1285  break;
1286  case 1:
1287  dst[0] = 0xFF;
1288  dst[1] = 0xFF;
1289  dst[2] = 0xFF;
1290  dst[3] = 0xFF;
1291  break;
1292  default:
1293  dst[0] = 0x00;
1294  dst[1] = 0x00;
1295  dst[2] = 0x00;
1296  dst[3] = 0x00;
1297  }
1298  dst += 4;
1299  bits <<= 1;
1300  }
1301  }
1302  }
1303  break;
1304  case 32: // full colour
1305  /* skip monochrome version of the cursor and decode RGBA instead */
1306  bytestream2_skip(gb, c->cursor_h * (FFALIGN(c->cursor_w, 32) >> 3));
1307  for (j = 0; j < c->cursor_h; j++) {
1308  for (i = 0; i < c->cursor_w; i++) {
1309  int val = bytestream2_get_be32(gb);
1310  *dst++ = val >> 0;
1311  *dst++ = val >> 8;
1312  *dst++ = val >> 16;
1313  *dst++ = val >> 24;
1314  }
1315  }
1316  break;
1317  default:
1318  return AVERROR_PATCHWELCOME;
1319  }
1320  return 0;
1321 }
1322 
1323 #define APPLY_ALPHA(src, new, alpha) \
1324  src = (src * (256 - alpha) + new * alpha) >> 8
1325 
1326 static void g2m_paint_cursor(G2MContext *c, uint8_t *dst, int stride)
1327 {
1328  int i, j;
1329  int x, y, w, h;
1330  const uint8_t *cursor;
1331 
1332  if (!c->cursor)
1333  return;
1334 
1335  x = c->cursor_x - c->cursor_hot_x;
1336  y = c->cursor_y - c->cursor_hot_y;
1337 
1338  cursor = c->cursor;
1339  w = c->cursor_w;
1340  h = c->cursor_h;
1341 
1342  if (x + w > c->width)
1343  w = c->width - x;
1344  if (y + h > c->height)
1345  h = c->height - y;
1346  if (x < 0) {
1347  w += x;
1348  cursor += -x * 4;
1349  } else {
1350  dst += x * 3;
1351  }
1352 
1353  if (y < 0)
1354  h += y;
1355  if (w < 0 || h < 0)
1356  return;
1357  if (y < 0) {
1358  cursor += -y * c->cursor_stride;
1359  } else {
1360  dst += y * stride;
1361  }
1362 
1363  for (j = 0; j < h; j++) {
1364  for (i = 0; i < w; i++) {
1365  uint8_t alpha = cursor[i * 4];
1366  APPLY_ALPHA(dst[i * 3 + 0], cursor[i * 4 + 1], alpha);
1367  APPLY_ALPHA(dst[i * 3 + 1], cursor[i * 4 + 2], alpha);
1368  APPLY_ALPHA(dst[i * 3 + 2], cursor[i * 4 + 3], alpha);
1369  }
1370  dst += stride;
1371  cursor += c->cursor_stride;
1372  }
1373 }
1374 
1375 static int g2m_decode_frame(AVCodecContext *avctx, AVFrame *pic,
1376  int *got_picture_ptr, AVPacket *avpkt)
1377 {
1378  const uint8_t *buf = avpkt->data;
1379  int buf_size = avpkt->size;
1380  G2MContext *c = avctx->priv_data;
1381  GetByteContext bc, tbc;
1382  int magic;
1383  int got_header = 0;
1384  uint32_t chunk_size, r_mask, g_mask, b_mask;
1385  int chunk_type, chunk_start;
1386  int i;
1387  int ret;
1388 
1389  if (buf_size < 12) {
1390  av_log(avctx, AV_LOG_ERROR,
1391  "Frame should have at least 12 bytes, got %d instead\n",
1392  buf_size);
1393  return AVERROR_INVALIDDATA;
1394  }
1395 
1396  bytestream2_init(&bc, buf, buf_size);
1397 
1398  magic = bytestream2_get_be32(&bc);
1399  if ((magic & ~0xF) != MKBETAG('G', '2', 'M', '0') ||
1400  (magic & 0xF) < 2 || (magic & 0xF) > 5) {
1401  av_log(avctx, AV_LOG_ERROR, "Wrong magic %08X\n", magic);
1402  return AVERROR_INVALIDDATA;
1403  }
1404 
1405  c->swapuv = magic == MKBETAG('G', '2', 'M', '2');
1406 
1407  while (bytestream2_get_bytes_left(&bc) > 5) {
1408  chunk_size = bytestream2_get_le32(&bc) - 1;
1409  chunk_type = bytestream2_get_byte(&bc);
1410  chunk_start = bytestream2_tell(&bc);
1411  if (chunk_size > bytestream2_get_bytes_left(&bc)) {
1412  av_log(avctx, AV_LOG_ERROR, "Invalid chunk size %"PRIu32" type %02X\n",
1413  chunk_size, chunk_type);
1414  break;
1415  }
1416  switch (chunk_type) {
1417  case DISPLAY_INFO:
1418  got_header =
1419  c->got_header = 0;
1420  if (chunk_size < 21) {
1421  av_log(avctx, AV_LOG_ERROR, "Invalid display info size %"PRIu32"\n",
1422  chunk_size);
1423  break;
1424  }
1425  c->width = bytestream2_get_be32(&bc);
1426  c->height = bytestream2_get_be32(&bc);
1427  if (c->width < 16 || c->height < 16) {
1428  av_log(avctx, AV_LOG_ERROR,
1429  "Invalid frame dimensions %dx%d\n",
1430  c->width, c->height);
1431  ret = AVERROR_INVALIDDATA;
1432  goto header_fail;
1433  }
1434  if (c->width != avctx->width || c->height != avctx->height) {
1435  ret = ff_set_dimensions(avctx, c->width, c->height);
1436  if (ret < 0)
1437  goto header_fail;
1438  }
1439  c->compression = bytestream2_get_be32(&bc);
1440  if (c->compression != 2 && c->compression != 3) {
1441  avpriv_report_missing_feature(avctx, "Compression method %d",
1442  c->compression);
1443  ret = AVERROR_PATCHWELCOME;
1444  goto header_fail;
1445  }
1446  c->tile_width = bytestream2_get_be32(&bc);
1447  c->tile_height = bytestream2_get_be32(&bc);
1448  if (c->tile_width <= 0 || c->tile_height <= 0 ||
1449  ((c->tile_width | c->tile_height) & 0xF) ||
1450  c->tile_width * (uint64_t)c->tile_height >= INT_MAX / 4 ||
1451  av_image_check_size2(c->tile_width, c->tile_height, avctx->max_pixels, avctx->pix_fmt, 0, avctx) < 0
1452  ) {
1453  av_log(avctx, AV_LOG_ERROR,
1454  "Invalid tile dimensions %dx%d\n",
1455  c->tile_width, c->tile_height);
1456  ret = AVERROR_INVALIDDATA;
1457  goto header_fail;
1458  }
1459  c->tiles_x = (c->width + c->tile_width - 1) / c->tile_width;
1460  c->tiles_y = (c->height + c->tile_height - 1) / c->tile_height;
1461  c->bpp = bytestream2_get_byte(&bc);
1462  if (c->bpp == 32) {
1463  if (bytestream2_get_bytes_left(&bc) < 16 ||
1464  (chunk_size - 21) < 16) {
1465  av_log(avctx, AV_LOG_ERROR,
1466  "Display info: missing bitmasks!\n");
1467  ret = AVERROR_INVALIDDATA;
1468  goto header_fail;
1469  }
1470  r_mask = bytestream2_get_be32(&bc);
1471  g_mask = bytestream2_get_be32(&bc);
1472  b_mask = bytestream2_get_be32(&bc);
1473  if (r_mask != 0xFF0000 || g_mask != 0xFF00 || b_mask != 0xFF) {
1474  avpriv_report_missing_feature(avctx,
1475  "Bitmasks: R=%"PRIX32", G=%"PRIX32", B=%"PRIX32,
1476  r_mask, g_mask, b_mask);
1477  ret = AVERROR_PATCHWELCOME;
1478  goto header_fail;
1479  }
1480  } else {
1481  avpriv_request_sample(avctx, "bpp=%d", c->bpp);
1482  ret = AVERROR_PATCHWELCOME;
1483  goto header_fail;
1484  }
1485  if (g2m_init_buffers(c)) {
1486  ret = AVERROR(ENOMEM);
1487  goto header_fail;
1488  }
1489  got_header = 1;
1490  break;
1491  case TILE_DATA:
1492  if (!c->tiles_x || !c->tiles_y) {
1493  av_log(avctx, AV_LOG_WARNING,
1494  "No display info - skipping tile\n");
1495  break;
1496  }
1497  if (chunk_size < 2) {
1498  av_log(avctx, AV_LOG_ERROR, "Invalid tile data size %"PRIu32"\n",
1499  chunk_size);
1500  break;
1501  }
1502  c->tile_x = bytestream2_get_byte(&bc);
1503  c->tile_y = bytestream2_get_byte(&bc);
1504  if (c->tile_x >= c->tiles_x || c->tile_y >= c->tiles_y) {
1505  av_log(avctx, AV_LOG_ERROR,
1506  "Invalid tile pos %d,%d (in %dx%d grid)\n",
1507  c->tile_x, c->tile_y, c->tiles_x, c->tiles_y);
1508  break;
1509  }
1510  ret = 0;
1511  switch (c->compression) {
1512  case COMPR_EPIC_J_B:
1513  ret = epic_jb_decode_tile(c, c->tile_x, c->tile_y,
1514  buf + bytestream2_tell(&bc),
1515  chunk_size - 2, avctx);
1516  break;
1517  case COMPR_KEMPF_J_B:
1518  ret = kempf_decode_tile(c, c->tile_x, c->tile_y,
1519  buf + bytestream2_tell(&bc),
1520  chunk_size - 2);
1521  break;
1522  }
1523  if (ret && c->framebuf)
1524  av_log(avctx, AV_LOG_ERROR, "Error decoding tile %d,%d\n",
1525  c->tile_x, c->tile_y);
1526  break;
1527  case CURSOR_POS:
1528  if (chunk_size < 5) {
1529  av_log(avctx, AV_LOG_ERROR, "Invalid cursor pos size %"PRIu32"\n",
1530  chunk_size);
1531  break;
1532  }
1533  c->cursor_x = bytestream2_get_be16(&bc);
1534  c->cursor_y = bytestream2_get_be16(&bc);
1535  break;
1536  case CURSOR_SHAPE:
1537  if (chunk_size < 8) {
1538  av_log(avctx, AV_LOG_ERROR, "Invalid cursor data size %"PRIu32"\n",
1539  chunk_size);
1540  break;
1541  }
1542  bytestream2_init(&tbc, buf + bytestream2_tell(&bc),
1543  chunk_size - 4);
1544  g2m_load_cursor(avctx, c, &tbc);
1545  break;
1546  case CHUNK_CC:
1547  case CHUNK_CD:
1548  break;
1549  default:
1550  av_log(avctx, AV_LOG_WARNING, "Skipping chunk type %02d\n",
1551  chunk_type);
1552  }
1553 
1554  /* navigate to next chunk */
1555  bytestream2_skip(&bc, chunk_start + chunk_size - bytestream2_tell(&bc));
1556  }
1557  if (got_header)
1558  c->got_header = 1;
1559 
1560  if (c->width && c->height && c->framebuf) {
1561  if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
1562  return ret;
1563 
1564  if (got_header)
1565  pic->flags |= AV_FRAME_FLAG_KEY;
1566  else
1567  pic->flags &= ~AV_FRAME_FLAG_KEY;
1568  pic->pict_type = got_header ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1569 
1570  for (i = 0; i < avctx->height; i++)
1571  memcpy(pic->data[0] + i * pic->linesize[0],
1572  c->framebuf + i * c->framebuf_stride,
1573  c->width * 3);
1574  g2m_paint_cursor(c, pic->data[0], pic->linesize[0]);
1575 
1576  *got_picture_ptr = 1;
1577  }
1578 
1579  return buf_size;
1580 
1581 header_fail:
1582  c->width =
1583  c->height = 0;
1584  c->tiles_x =
1585  c->tiles_y = 0;
1586  c->tile_width =
1587  c->tile_height = 0;
1588  return ret;
1589 }
1590 
1591 static av_cold int g2m_decode_init(AVCodecContext *avctx)
1592 {
1593  G2MContext *const c = avctx->priv_data;
1594  int ret;
1595 
1596  if ((ret = jpg_init(avctx, &c->jc)) != 0) {
1597  av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
1598  return AVERROR(ENOMEM);
1599  }
1600 
1601  avctx->pix_fmt = AV_PIX_FMT_RGB24;
1602 
1603  // store original sizes and check against those if resize happens
1604  c->orig_width = avctx->width;
1605  c->orig_height = avctx->height;
1606 
1607  return 0;
1608 }
1609 
1610 static av_cold int g2m_decode_end(AVCodecContext *avctx)
1611 {
1612  G2MContext *const c = avctx->priv_data;
1613 
1614  jpg_free_context(&c->jc);
1615 
1616  av_freep(&c->epic_buf_base);
1617  c->epic_buf = NULL;
1618  av_freep(&c->kempf_buf);
1619  av_freep(&c->kempf_flags);
1620  av_freep(&c->synth_tile);
1621  av_freep(&c->jpeg_tile);
1622  av_freep(&c->cursor);
1623  av_freep(&c->framebuf);
1624  c->framebuf_allocated = 0;
1625 
1626  return 0;
1627 }
1628 
1629 const FFCodec ff_g2m_decoder = {
1630  .p.name = "g2m",
1631  CODEC_LONG_NAME("Go2Meeting"),
1632  .p.type = AVMEDIA_TYPE_VIDEO,
1633  .p.id = AV_CODEC_ID_G2M,
1634  .priv_data_size = sizeof(G2MContext),
1635  .init = g2m_decode_init,
1636  .close = g2m_decode_end,
1637  FF_CODEC_DECODE_CB(g2m_decode_frame),
1638  .p.capabilities = AV_CODEC_CAP_DR1,
1639  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1640 };
EPIC_PIX_STACK_SIZE
#define EPIC_PIX_STACK_SIZE
Definition: g2meet.c:46
COMPR_KEMPF_J_B
@ COMPR_KEMPF_J_B
Definition: g2meet.c:60
ff_els_decode_unsigned
unsigned ff_els_decode_unsigned(ElsDecCtx *ctx, ElsUnsignedRung *ur)
Definition: elsdec.c:352
ePICPixListElem::pixel
uint32_t pixel
Definition: g2meet.c:88
epic_add_pixel_to_cache
static int epic_add_pixel_to_cache(ePICPixHash *hash, uint32_t key, uint32_t pix)
Definition: g2meet.c:430
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ePICContext::els_ctx
ElsDecCtx els_ctx
Definition: g2meet.c:105
jpegtables.h
ePICPixHashElem::list
struct ePICPixListElem * list
Definition: g2meet.c:94
ff_els_decode_bit
int ff_els_decode_bit(ElsDecCtx *ctx, uint8_t *rung)
Definition: elsdec.c:293
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
chunk_start
static int chunk_start(AVFormatContext *s)
Definition: webm_chunk.c:167
blockdsp.h
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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
G2MContext::orig_height
int orig_height
Definition: g2meet.c:142
mem_internal.h
out
FILE * out
Definition: movenc.c:55
G2MContext::epic_buf_base
uint8_t * epic_buf_base
Definition: g2meet.c:152
GetByteContext
Definition: bytestream.h:33
ff_els_decoder_init
void ff_els_decoder_init(ElsDecCtx *ctx, const uint8_t *in, size_t data_size)
Definition: elsdec.c:249
ePICContext::stack_pos
int stack_pos
Definition: g2meet.c:117
G2MContext::old_tile_w
int old_tile_w
Definition: g2meet.c:153
EPIC_HASH_SIZE
#define EPIC_HASH_SIZE
Definition: g2meet.c:97
jpg_decode_block
static int jpg_decode_block(JPGContext *c, GetBitContext *gb, int plane, int16_t *block)
Definition: g2meet.c:223
mjpegdec.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
JPGContext::permutated_scantable
uint8_t permutated_scantable[64]
Definition: g2meet.c:125
w
uint8_t w
Definition: llviddspenc.c:38
AVPacket::data
uint8_t * data
Definition: packet.h:524
NN
#define NN(type, name)
Definition: vf_shear.c:115
epic_predict_from_NW_NE
static int epic_predict_from_NW_NE(ePICContext *dc, int x, int y, int run, int tile_width, const uint32_t *curr_row, const uint32_t *above_row, uint32_t *pPix)
Definition: g2meet.c:741
R
#define R
Definition: huffyuv.h:44
G2MContext::tile_width
int tile_width
Definition: g2meet.c:143
ff_mjpeg_val_dc
const uint8_t ff_mjpeg_val_dc[]
Definition: jpegtabs.h:34
FFCodec
Definition: codec_internal.h:126
G2MContext::jpeg_tile
uint8_t * jpeg_tile
Definition: g2meet.c:152
ePICPixListElem::rung
uint8_t rung
Definition: g2meet.c:89
B_shift
#define B_shift
Definition: g2meet.c:375
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:646
ff_mjpeg_bits_ac_chrominance
const uint8_t ff_mjpeg_bits_ac_chrominance[]
Definition: jpegtabs.h:66
BlockDSPContext
Definition: blockdsp.h:32
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
hash
uint8_t hash[HASH_SIZE]
Definition: movenc.c:58
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:228
R_shift
#define R_shift
Definition: g2meet.c:373
rle
static int rle(uint8_t *dst, const uint8_t *src, int compressed_size, int uncompressed_size)
Definition: exr.c:217
ePICContext::N_ctx_rung
uint8_t N_ctx_rung[512]
Definition: g2meet.c:111
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
jpg_unescape
static void jpg_unescape(const uint8_t *src, int src_size, uint8_t *dst, int *dst_size)
Definition: g2meet.c:206
g2m_decode_init
static av_cold int g2m_decode_init(AVCodecContext *avctx)
Definition: g2meet.c:1591
ff_permute_scantable
av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])
Definition: idctdsp.c:30
ePICPixHash::bucket_size
int bucket_size[EPIC_HASH_SIZE]
Definition: g2meet.c:100
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
epic_hash_find
static ePICPixHashElem * epic_hash_find(const ePICPixHash *hash, uint32_t key)
Definition: g2meet.c:395
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
JPGContext
Definition: g2meet.c:122
epic_decode_tile
static int epic_decode_tile(ePICContext *dc, uint8_t *out, int tile_height, int tile_width, int stride)
Definition: g2meet.c:798
av_ceil_log2
#define av_ceil_log2
Definition: common.h:96
ePICContext::prev_row_rung
uint8_t prev_row_rung[14]
Definition: g2meet.c:114
GetBitContext
Definition: get_bits.h:108
TOSIGNED
#define TOSIGNED(val)
Definition: g2meet.c:492
val
static double val(void *priv, double ch)
Definition: aeval.c:78
G2MContext::swapuv
int swapuv
Definition: g2meet.c:154
epic_handle_edges
static int epic_handle_edges(ePICContext *dc, int x, int y, const uint32_t *curr_row, const uint32_t *above_row, uint32_t *pPix)
Definition: g2meet.c:564
g2m_paint_cursor
static void g2m_paint_cursor(G2MContext *c, uint8_t *dst, int stride)
Definition: g2meet.c:1326
av_image_check_size2
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:289
JPGContext::prev_dc
int prev_dc[3]
Definition: g2meet.c:128
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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:545
ePICPixListElem
Definition: g2meet.c:86
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
G2MContext::version
int version
Definition: g2meet.c:138
mask
static const uint16_t mask[17]
Definition: lzw.c:38
G2MContext::tiles_y
int tiles_y
Definition: g2meet.c:144
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
ePICPixHashElem
Definition: g2meet.c:92
G2MContext::jc
JPGContext jc
Definition: g2meet.c:136
ePICContext::nw_pred_rung
uint8_t nw_pred_rung[256]
Definition: g2meet.c:112
bits
uint8_t bits
Definition: vp3data.h:128
ePICPixHash
Definition: g2meet.c:98
bucket
static FFFrameBucket * bucket(FFFrameQueue *fq, size_t idx)
Definition: framequeue.c:26
B
#define B
Definition: huffyuv.h:42
ePICContext::hash
ePICPixHash hash
Definition: g2meet.c:119
ePICContext::W_ctx_rung
uint8_t W_ctx_rung[256]
Definition: g2meet.c:110
ctx
AVFormatContext * ctx
Definition: movenc.c:49
G2MContext::cursor
uint8_t * cursor
Definition: g2meet.c:158
decode.h
get_bits.h
APPLY_ALPHA
#define APPLY_ALPHA(src, new, alpha)
Definition: g2meet.c:1323
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1934
CHUNK_CC
@ CHUNK_CC
Definition: g2meet.c:54
epic_decode_from_cache
static int epic_decode_from_cache(ePICContext *dc, uint32_t W, uint32_t *pPix)
Definition: g2meet.c:769
key
const char * key
Definition: hwcontext_opencl.c:189
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
g2m_decode_end
static av_cold int g2m_decode_end(AVCodecContext *avctx)
Definition: g2meet.c:1610
if
if(ret)
Definition: filter_design.txt:179
G2MContext::cursor_hot_x
int cursor_hot_x
Definition: g2meet.c:162
ePICContext::next_run_pos
int next_run_pos
Definition: g2meet.c:106
G2MContext::kempf_buf
uint8_t * kempf_buf
Definition: g2meet.c:156
TILE_DATA
@ TILE_DATA
Definition: g2meet.c:51
epic_jb_decode_tile
static int epic_jb_decode_tile(G2MContext *c, int tile_x, int tile_y, const uint8_t *src, size_t src_size, AVCodecContext *avctx)
Definition: g2meet.c:864
COMPR_EPIC_J_B
@ COMPR_EPIC_J_B
Definition: g2meet.c:59
NULL
#define NULL
Definition: coverity.c:32
CURSOR_SHAPE
@ CURSOR_SHAPE
Definition: g2meet.c:53
ePICPixHash::bucket
ePICPixHashElem * bucket[EPIC_HASH_SIZE]
Definition: g2meet.c:99
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:204
ePICContext::W_flag_rung
uint8_t W_flag_rung
Definition: g2meet.c:108
ePICContext::unsigned_rung
ElsUnsignedRung unsigned_rung
Definition: g2meet.c:107
epic_hash_add
static ePICPixHashElem * epic_hash_add(ePICPixHash *hash, uint32_t key)
Definition: g2meet.c:407
ff_g2m_decoder
const FFCodec ff_g2m_decoder
Definition: g2meet.c:1629
G2MContext::old_tile_h
int old_tile_h
Definition: g2meet.c:153
V
#define V
Definition: avdct.c:31
jpg_init
static av_cold int jpg_init(AVCodecContext *avctx, JPGContext *c)
Definition: g2meet.c:165
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
Compression
Compression
Definition: g2meet.c:58
av_fast_mallocz
void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
Allocate and clear a buffer, reusing the given one if large enough.
Definition: mem.c:562
FF_PTR_ADD
#define FF_PTR_ADD(ptr, off)
Definition: internal.h:80
list
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 list
Definition: filter_design.txt:25
G2MContext::cursor_stride
int cursor_stride
Definition: g2meet.c:159
EPIC_PIX_STACK_MAX
#define EPIC_PIX_STACK_MAX
Definition: g2meet.c:47
CURSOR_POS
@ CURSOR_POS
Definition: g2meet.c:52
g2m_load_cursor
static int g2m_load_cursor(AVCodecContext *avctx, G2MContext *c, GetByteContext *gb)
Definition: g2meet.c:1204
ff_mjpeg_val_ac_chrominance
const uint8_t ff_mjpeg_val_ac_chrominance[]
Definition: jpegtabs.h:69
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
epic_predict_pixel2
static int epic_predict_pixel2(ePICContext *dc, uint8_t *rung, uint32_t *pPix, uint32_t pix)
Definition: g2meet.c:730
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
g2m_decode_frame
static int g2m_decode_frame(AVCodecContext *avctx, AVFrame *pic, int *got_picture_ptr, AVPacket *avpkt)
Definition: g2meet.c:1375
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
G2MContext::epic_buf_stride
int epic_buf_stride
Definition: g2meet.c:153
G2MContext::epic_buf
uint8_t * epic_buf
Definition: g2meet.c:152
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:476
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1556
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
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
ff_mjpeg_val_ac_luminance
const uint8_t ff_mjpeg_val_ac_luminance[]
Definition: jpegtabs.h:42
AVPacket::size
int size
Definition: packet.h:525
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
ePICContext::N_flag_rung
uint8_t N_flag_rung
Definition: g2meet.c:109
ff_mjpeg_bits_ac_luminance
const uint8_t ff_mjpeg_bits_ac_luminance[]
Definition: jpegtabs.h:40
G_shift
#define G_shift
Definition: g2meet.c:374
ePICPixListElem::next
struct ePICPixListElem * next
Definition: g2meet.c:87
av_reallocp
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:188
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
ElsUnsignedRung
Definition: elsdec.h:48
height
#define height
G2MContext::cursor_y
int cursor_y
Definition: g2meet.c:161
G2MContext::compression
int compression
Definition: g2meet.c:140
ElsDecCtx
Definition: elsdec.h:36
get_xbits
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
Definition: get_bits.h:292
ff_els_decoder_uninit
void ff_els_decoder_uninit(ElsUnsignedRung *rung)
Definition: elsdec.c:274
N
#define N
Definition: af_mcompand.c:54
JPGContext::idsp
IDCTDSPContext idsp
Definition: g2meet.c:124
Y
#define Y
Definition: boxblur.h:37
JPGContext::ac_vlc
VLC ac_vlc[2]
Definition: g2meet.c:127
ePICPixHashElem::pix_id
uint32_t pix_id
Definition: g2meet.c:93
G2MContext::framebuf_allocated
unsigned int framebuf_allocated
Definition: g2meet.c:150
flag
#define flag(name)
Definition: cbs_av1.c:466
ePICPixHash::bucket_fill
int bucket_fill[EPIC_HASH_SIZE]
Definition: g2meet.c:101
kempf_decode_tile
static int kempf_decode_tile(G2MContext *c, int tile_x, int tile_y, const uint8_t *src, int src_size)
Definition: g2meet.c:1050
JPGContext::buf
uint8_t * buf
Definition: g2meet.c:131
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
djb2_hash
static int djb2_hash(uint32_t key)
Definition: g2meet.c:378
G2MContext::height
int height
Definition: g2meet.c:141
G2MContext::cursor_w
int cursor_w
Definition: g2meet.c:161
delta
float delta
Definition: vorbis_enc_data.h:430
jpg_free_context
static av_cold void jpg_free_context(JPGContext *ctx)
Definition: g2meet.c:194
G2MContext::cursor_h
int cursor_h
Definition: g2meet.c:161
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
G2MContext::cursor_x
int cursor_x
Definition: g2meet.c:161
G2MContext::bpp
int bpp
Definition: g2meet.c:141
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
G2MContext::tile_stride
int tile_stride
Definition: g2meet.c:153
len
int len
Definition: vorbis_enc_data.h:426
luma_quant
static const uint8_t luma_quant[64]
Definition: g2meet.c:64
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
G2MContext::tile_x
int tile_x
Definition: g2meet.c:144
W
@ W
Definition: vf_addroi.c:27
idctdsp.h
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2030
mid_pred
#define mid_pred
Definition: mathops.h:98
ff_vlc_free
void ff_vlc_free(VLC *vlc)
Definition: vlc.c:580
ret
ret
Definition: filter_design.txt:187
kempf_restore_buf
static int kempf_restore_buf(const uint8_t *src, int len, uint8_t *dst, int stride, const uint8_t *jpeg_tile, int tile_stride, int width, int height, const uint8_t *pal, int npal, int tidx)
Definition: g2meet.c:1015
pred
static const float pred[4]
Definition: siprdata.h:259
G2MContext::width
int width
Definition: g2meet.c:141
pos
unsigned int pos
Definition: spdifenc.c:414
IDCTDSPContext
Definition: idctdsp.h:43
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
ePICContext::ne_pred_rung
uint8_t ne_pred_rung[256]
Definition: g2meet.c:113
U
#define U(x)
Definition: vpx_arith.h:37
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
G2MContext::ec
ePICContext ec
Definition: g2meet.c:135
AVCodecContext
main external API structure.
Definition: avcodec.h:445
G2MContext::framebuf
uint8_t * framebuf
Definition: g2meet.c:148
ePICContext::runlen_one
uint8_t runlen_one
Definition: g2meet.c:116
G2MContext::cursor_fmt
int cursor_fmt
Definition: g2meet.c:160
epic_hash_init
static void epic_hash_init(ePICPixHash *hash)
Definition: g2meet.c:390
g2m_init_buffers
static int g2m_init_buffers(G2MContext *c)
Definition: g2meet.c:1161
G2MContext
Definition: g2meet.c:134
ePICContext::runlen_zeroes
uint8_t runlen_zeroes[14]
Definition: g2meet.c:115
VLC
Definition: vlc.h:36
epic_predict_pixel
static int epic_predict_pixel(ePICContext *dc, uint8_t *rung, uint32_t *pPix, uint32_t pix)
Definition: g2meet.c:553
G2MContext::tiles_x
int tiles_x
Definition: g2meet.c:144
JPGContext::bdsp
BlockDSPContext bdsp
Definition: g2meet.c:123
JPGContext::dc_vlc
VLC dc_vlc[2]
Definition: g2meet.c:127
DISPLAY_INFO
@ DISPLAY_INFO
Definition: g2meet.c:50
av_clip_uint8
#define av_clip_uint8
Definition: common.h:105
ePICContext
Definition: g2meet.c:104
G
#define G
Definition: huffyuv.h:43
ff_mjpeg_bits_dc_chrominance
const uint8_t ff_mjpeg_bits_dc_chrominance[]
Definition: jpegtabs.h:37
G2MContext::tile_height
int tile_height
Definition: g2meet.c:143
JPGContext::block
int16_t block[6][64]
Definition: g2meet.c:129
UPDATE_NEIGHBOURS
#define UPDATE_NEIGHBOURS(x)
Definition: g2meet.c:364
jpg_decode_data
static int jpg_decode_data(JPGContext *c, int width, int height, const uint8_t *src, int src_size, uint8_t *dst, int dst_stride, const uint8_t *mask, int mask_stride, int num_mbs, int swapuv)
Definition: g2meet.c:270
CHUNK_CD
@ CHUNK_CD
Definition: g2meet.c:55
LOAD_NEIGHBOURS
#define LOAD_NEIGHBOURS(x)
Definition: g2meet.c:353
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
chroma_quant
static const uint8_t chroma_quant[64]
Definition: g2meet.c:75
G2MContext::tile_y
int tile_y
Definition: g2meet.c:144
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
epic_cache_entries_for_pixel
static int epic_cache_entries_for_pixel(const ePICPixHash *hash, uint32_t pix)
Definition: g2meet.c:451
AV_CODEC_ID_G2M
@ AV_CODEC_ID_G2M
Definition: codec_id.h:223
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
ff_mjpeg_bits_dc_luminance
const FF_VISIBILITY_PUSH_HIDDEN uint8_t ff_mjpeg_bits_dc_luminance[]
Definition: jpegtabs.h:32
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
ff_mjpeg_build_vlc
int ff_mjpeg_build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, int is_ac, void *logctx)
Definition: mjpegdec_common.c:41
G2MContext::framebuf_stride
int framebuf_stride
Definition: g2meet.c:149
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:501
G2MContext::got_header
int got_header
Definition: g2meet.c:146
G2MContext::cursor_hot_y
int cursor_hot_y
Definition: g2meet.c:162
epic_decode_component_pred
static int epic_decode_component_pred(ePICContext *dc, int N, int W, int NW)
Definition: g2meet.c:494
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
epic_decode_run_length
static int epic_decode_run_length(ePICContext *dc, int x, int y, int tile_width, const uint32_t *curr_row, const uint32_t *above_row, const uint32_t *above2_row, uint32_t *pPix, int *pRun)
Definition: g2meet.c:595
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
ePICContext::stack
uint32_t stack[EPIC_PIX_STACK_SIZE]
Definition: g2meet.c:118
bytestream.h
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
G2MContext::orig_width
int orig_width
Definition: g2meet.c:142
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:419
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
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
ChunkType
ChunkType
Definition: g2meet.c:49
h
h
Definition: vp9dsp_template.c:2038
epic_free_pixel_cache
static void epic_free_pixel_cache(ePICPixHash *hash)
Definition: g2meet.c:462
epic_decode_pixel_pred
static uint32_t epic_decode_pixel_pred(ePICContext *dc, int x, int y, const uint32_t *curr_row, const uint32_t *above_row)
Definition: g2meet.c:501
yuv2rgb
static void yuv2rgb(uint8_t *out, int ridx, int Y, int U, int V)
Definition: g2meet.c:263
G2MContext::synth_tile
uint8_t * synth_tile
Definition: g2meet.c:152
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:155
G2MContext::kempf_flags
uint8_t * kempf_flags
Definition: g2meet.c:156
elsdec.h
is_pixel_on_stack
static int is_pixel_on_stack(const ePICContext *dc, uint32_t pix)
Definition: g2meet.c:481
Generated on Fri Apr 19 2024 19:21:39 for FFmpeg by   doxygen 1.8.17