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/attributes.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/mem_internal.h"
35 
36 #include "avcodec.h"
37 #include "blockdsp.h"
38 #include "bytestream.h"
39 #include "codec_internal.h"
40 #include "decode.h"
41 #include "elsdec.h"
42 #include "get_bits.h"
43 #include "idctdsp.h"
44 #include "jpegtables.h"
45 #include "mjpegdec.h"
46 
47 #define EPIC_PIX_STACK_SIZE 1024
48 #define EPIC_PIX_STACK_MAX (EPIC_PIX_STACK_SIZE - 1)
49 
50 enum ChunkType {
51  DISPLAY_INFO = 0xC8,
52  TILE_DATA,
53  CURSOR_POS,
54  CURSOR_SHAPE,
55  CHUNK_CC,
56  CHUNK_CD
57 };
58 
59 enum Compression {
60  COMPR_EPIC_J_B = 2,
61  COMPR_KEMPF_J_B,
62 };
63 
64 /* These tables are already permuted according to ff_zigzag_direct */
65 static const uint8_t luma_quant[64] = {
66  8, 6, 6, 7, 6, 5, 8, 7,
67  7, 7, 9, 9, 8, 10, 12, 20,
68  13, 12, 11, 11, 12, 25, 18, 19,
69  15, 20, 29, 26, 31, 30, 29, 26,
70  28, 28, 32, 36, 46, 39, 32, 34,
71  44, 35, 28, 28, 40, 55, 41, 44,
72  48, 49, 52, 52, 52, 31, 39, 57,
73  61, 56, 50, 60, 46, 51, 52, 50,
74 };
75 
76 static const uint8_t chroma_quant[64] = {
77  9, 9, 9, 12, 11, 12, 24, 13,
78  13, 24, 50, 33, 28, 33, 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  50, 50, 50, 50, 50, 50, 50, 50,
85 };
86 
87 typedef struct ePICPixListElem {
88  struct ePICPixListElem *next;
89  uint32_t pixel;
90  uint8_t rung;
91 } ePICPixListElem;
92 
93 typedef struct ePICPixHashElem {
94  uint32_t pix_id;
95  struct ePICPixListElem *list;
96 } ePICPixHashElem;
97 
98 #define EPIC_HASH_SIZE 256
99 typedef struct ePICPixHash {
100  ePICPixHashElem *bucket[EPIC_HASH_SIZE];
101  int bucket_size[EPIC_HASH_SIZE];
102  int bucket_fill[EPIC_HASH_SIZE];
103 } ePICPixHash;
104 
105 typedef struct ePICContext {
106  ElsDecCtx els_ctx;
107  int next_run_pos;
108  ElsUnsignedRung unsigned_rung;
109  uint8_t W_flag_rung;
110  uint8_t N_flag_rung;
111  uint8_t W_ctx_rung[256];
112  uint8_t N_ctx_rung[512];
113  uint8_t nw_pred_rung[256];
114  uint8_t ne_pred_rung[256];
115  uint8_t prev_row_rung[14];
116  uint8_t runlen_zeroes[14];
117  uint8_t runlen_one;
118  int stack_pos;
119  uint32_t stack[EPIC_PIX_STACK_SIZE];
120  ePICPixHash hash;
121 } ePICContext;
122 
123 typedef struct JPGContext {
124  BlockDSPContext bdsp;
125  IDCTDSPContext idsp;
126  uint8_t permutated_scantable[64];
127 
128  VLC dc_vlc[2], ac_vlc[2];
129  int prev_dc[3];
130  DECLARE_ALIGNED(32, int16_t, block)[6][64];
131 
132  uint8_t *buf;
133 } JPGContext;
134 
135 typedef struct G2MContext {
136  ePICContext ec;
137  JPGContext jc;
138 
139  int version;
140 
141  int compression;
142  int width, height, bpp;
143  int orig_width, orig_height;
144  int tile_width, tile_height;
145  int tiles_x, tiles_y, tile_x, tile_y;
146 
147  int got_header;
148 
149  uint8_t *framebuf;
150  int framebuf_stride;
151  unsigned int framebuf_allocated;
152 
153  uint8_t *synth_tile, *jpeg_tile, *epic_buf, *epic_buf_base;
154  int tile_stride, epic_buf_stride, old_tile_w, old_tile_h;
155  int swapuv;
156 
157  uint8_t *kempf_buf, *kempf_flags;
158 
159  uint8_t *cursor;
160  int cursor_stride;
161  int cursor_fmt;
162  int cursor_w, cursor_h, cursor_x, cursor_y;
163  int cursor_hot_x, cursor_hot_y;
164 } G2MContext;
165 
166 static av_cold int jpg_init(AVCodecContext *avctx, JPGContext *c)
167 {
168  int ret;
169 
170  ret = ff_mjpeg_build_vlc(&c->dc_vlc[0], ff_mjpeg_bits_dc_luminance,
171  ff_mjpeg_val_dc, 0, avctx);
172  if (ret)
173  return ret;
174  ret = ff_mjpeg_build_vlc(&c->dc_vlc[1], ff_mjpeg_bits_dc_chrominance,
175  ff_mjpeg_val_dc, 0, avctx);
176  if (ret)
177  return ret;
178  ret = ff_mjpeg_build_vlc(&c->ac_vlc[0], ff_mjpeg_bits_ac_luminance,
179  ff_mjpeg_val_ac_luminance, 1, avctx);
180  if (ret)
181  return ret;
182  ret = ff_mjpeg_build_vlc(&c->ac_vlc[1], ff_mjpeg_bits_ac_chrominance,
183  ff_mjpeg_val_ac_chrominance, 1, avctx);
184  if (ret)
185  return ret;
186 
187  ff_blockdsp_init(&c->bdsp);
188  ff_idctdsp_init(&c->idsp, avctx);
189  ff_permute_scantable(c->permutated_scantable, ff_zigzag_direct,
190  c->idsp.idct_permutation);
191 
192  return 0;
193 }
194 
195 static av_cold void jpg_free_context(JPGContext *ctx)
196 {
197  int i;
198 
199  for (i = 0; i < 2; i++) {
200  ff_vlc_free(&ctx->dc_vlc[i]);
201  ff_vlc_free(&ctx->ac_vlc[i]);
202  }
203 
204  av_freep(&ctx->buf);
205 }
206 
207 static void jpg_unescape(const uint8_t *src, int src_size,
208  uint8_t *dst, int *dst_size)
209 {
210  const uint8_t *src_end = src + src_size;
211  uint8_t *dst_start = dst;
212 
213  while (src < src_end) {
214  uint8_t x = *src++;
215 
216  *dst++ = x;
217 
218  if (x == 0xFF && !*src)
219  src++;
220  }
221  *dst_size = dst - dst_start;
222 }
223 
224 static int jpg_decode_block(JPGContext *c, GetBitContext *gb,
225  int plane, int16_t *block)
226 {
227  int dc, val, pos;
228  const int is_chroma = !!plane;
229  const uint8_t *qmat = is_chroma ? chroma_quant : luma_quant;
230 
231  if (get_bits_left(gb) < 1)
232  return AVERROR_INVALIDDATA;
233 
234  c->bdsp.clear_block(block);
235  dc = get_vlc2(gb, c->dc_vlc[is_chroma].table, 9, 2);
236  if (dc < 0)
237  return AVERROR_INVALIDDATA;
238  if (dc)
239  dc = get_xbits(gb, dc);
240  dc = dc * qmat[0] + c->prev_dc[plane];
241  block[0] = dc;
242  c->prev_dc[plane] = dc;
243 
244  pos = 0;
245  while (pos < 63) {
246  val = get_vlc2(gb, c->ac_vlc[is_chroma].table, 9, 2);
247  if (val < 0)
248  return AVERROR_INVALIDDATA;
249  pos += val >> 4;
250  val &= 0xF;
251  if (pos > 63)
252  return val ? AVERROR_INVALIDDATA : 0;
253  if (val) {
254  int nbits = val;
255 
256  val = get_xbits(gb, nbits);
257  val *= qmat[pos];
258  block[c->permutated_scantable[pos]] = val;
259  }
260  }
261  return 0;
262 }
263 
264 static inline void yuv2rgb(uint8_t *out, int ridx, int Y, int U, int V)
265 {
266  out[ridx] = av_clip_uint8(Y + (91881 * V + 32768 >> 16));
267  out[1] = av_clip_uint8(Y + (-22554 * U - 46802 * V + 32768 >> 16));
268  out[2 - ridx] = av_clip_uint8(Y + (116130 * U + 32768 >> 16));
269 }
270 
271 static int jpg_decode_data(JPGContext *c, int width, int height,
272  const uint8_t *src, int src_size,
273  uint8_t *dst, int dst_stride,
274  const uint8_t *mask, int mask_stride, int num_mbs,
275  int swapuv)
276 {
277  GetBitContext gb;
278  int mb_w, mb_h, mb_x, mb_y, i, j;
279  int bx, by;
280  int unesc_size;
281  int ret;
282  const int ridx = swapuv ? 2 : 0;
283 
284  if ((ret = av_reallocp(&c->buf,
285  src_size + AV_INPUT_BUFFER_PADDING_SIZE)) < 0)
286  return ret;
287  jpg_unescape(src, src_size, c->buf, &unesc_size);
288  memset(c->buf + unesc_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
289  if((ret = init_get_bits8(&gb, c->buf, unesc_size)) < 0)
290  return ret;
291 
292  width = FFALIGN(width, 16);
293  mb_w = width >> 4;
294  mb_h = (height + 15) >> 4;
295 
296  if (!num_mbs)
297  num_mbs = mb_w * mb_h * 4;
298 
299  for (i = 0; i < 3; i++)
300  c->prev_dc[i] = 1024;
301  bx =
302  by = 0;
303  c->bdsp.clear_blocks(c->block[0]);
304  for (mb_y = 0; mb_y < mb_h; mb_y++) {
305  for (mb_x = 0; mb_x < mb_w; mb_x++) {
306  if (mask && !mask[mb_x * 2] && !mask[mb_x * 2 + 1] &&
307  !mask[mb_x * 2 + mask_stride] &&
308  !mask[mb_x * 2 + 1 + mask_stride]) {
309  bx += 16;
310  continue;
311  }
312  for (j = 0; j < 2; j++) {
313  for (i = 0; i < 2; i++) {
314  if (mask && !mask[mb_x * 2 + i + j * mask_stride])
315  continue;
316  num_mbs--;
317  if ((ret = jpg_decode_block(c, &gb, 0,
318  c->block[i + j * 2])) != 0)
319  return ret;
320  c->idsp.idct(c->block[i + j * 2]);
321  }
322  }
323  for (i = 1; i < 3; i++) {
324  if ((ret = jpg_decode_block(c, &gb, i, c->block[i + 3])) != 0)
325  return ret;
326  c->idsp.idct(c->block[i + 3]);
327  }
328 
329  for (j = 0; j < 16; j++) {
330  uint8_t *out = dst + bx * 3 + (by + j) * dst_stride;
331  for (i = 0; i < 16; i++) {
332  int Y, U, V;
333 
334  Y = c->block[(j >> 3) * 2 + (i >> 3)][(i & 7) + (j & 7) * 8];
335  U = c->block[4][(i >> 1) + (j >> 1) * 8] - 128;
336  V = c->block[5][(i >> 1) + (j >> 1) * 8] - 128;
337  yuv2rgb(out + i * 3, ridx, Y, U, V);
338  }
339  }
340 
341  if (!num_mbs)
342  return 0;
343  bx += 16;
344  }
345  bx = 0;
346  by += 16;
347  if (mask)
348  mask += mask_stride * 2;
349  }
350 
351  return 0;
352 }
353 
354 #define LOAD_NEIGHBOURS(x) \
355  W = curr_row[(x) - 1]; \
356  N = above_row[(x)]; \
357  WW = curr_row[(x) - 2]; \
358  NW = above_row[(x) - 1]; \
359  NE = above_row[(x) + 1]; \
360  NN = above2_row[(x)]; \
361  NNW = above2_row[(x) - 1]; \
362  NWW = above_row[(x) - 2]; \
363  NNE = above2_row[(x) + 1]
364 
365 #define UPDATE_NEIGHBOURS(x) \
366  NNW = NN; \
367  NN = NNE; \
368  NWW = NW; \
369  NW = N; \
370  N = NE; \
371  NE = above_row[(x) + 1]; \
372  NNE = above2_row[(x) + 1]
373 
374 #define R_shift 16
375 #define G_shift 8
376 #define B_shift 0
377 
378 /* improved djb2 hash from http://www.cse.yorku.ca/~oz/hash.html */
379 static int djb2_hash(uint32_t key)
380 {
381  uint32_t h = 5381;
382 
383  h = (h * 33) ^ ((key >> 24) & 0xFF); // xxx: probably not needed at all
384  h = (h * 33) ^ ((key >> 16) & 0xFF);
385  h = (h * 33) ^ ((key >> 8) & 0xFF);
386  h = (h * 33) ^ (key & 0xFF);
387 
388  return h & (EPIC_HASH_SIZE - 1);
389 }
390 
391 static void epic_hash_init(ePICPixHash *hash)
392 {
393  memset(hash, 0, sizeof(*hash));
394 }
395 
396 static ePICPixHashElem *epic_hash_find(const ePICPixHash *hash, uint32_t key)
397 {
398  int i, idx = djb2_hash(key);
399  ePICPixHashElem *bucket = hash->bucket[idx];
400 
401  for (i = 0; i < hash->bucket_fill[idx]; i++)
402  if (bucket[i].pix_id == key)
403  return &bucket[i];
404 
405  return NULL;
406 }
407 
408 static ePICPixHashElem *epic_hash_add(ePICPixHash *hash, uint32_t key)
409 {
410  ePICPixHashElem *bucket, *ret;
411  int idx = djb2_hash(key);
412 
413  if (hash->bucket_size[idx] > INT_MAX / sizeof(**hash->bucket))
414  return NULL;
415 
416  if (!(hash->bucket_fill[idx] < hash->bucket_size[idx])) {
417  int new_size = hash->bucket_size[idx] + 16;
418  bucket = av_realloc(hash->bucket[idx], new_size * sizeof(*bucket));
419  if (!bucket)
420  return NULL;
421  hash->bucket[idx] = bucket;
422  hash->bucket_size[idx] = new_size;
423  }
424 
425  ret = &hash->bucket[idx][hash->bucket_fill[idx]++];
426  memset(ret, 0, sizeof(*ret));
427  ret->pix_id = key;
428  return ret;
429 }
430 
431 static int epic_add_pixel_to_cache(ePICPixHash *hash, uint32_t key, uint32_t pix)
432 {
433  ePICPixListElem *new_elem;
434  ePICPixHashElem *hash_elem = epic_hash_find(hash, key);
435 
436  if (!hash_elem) {
437  if (!(hash_elem = epic_hash_add(hash, key)))
438  return AVERROR(ENOMEM);
439  }
440 
441  new_elem = av_mallocz(sizeof(*new_elem));
442  if (!new_elem)
443  return AVERROR(ENOMEM);
444 
445  new_elem->pixel = pix;
446  new_elem->next = hash_elem->list;
447  hash_elem->list = new_elem;
448 
449  return 0;
450 }
451 
452 static inline int epic_cache_entries_for_pixel(const ePICPixHash *hash,
453  uint32_t pix)
454 {
455  ePICPixHashElem *hash_elem = epic_hash_find(hash, pix);
456 
457  if (hash_elem != NULL && hash_elem->list != NULL)
458  return 1;
459 
460  return 0;
461 }
462 
463 static void epic_free_pixel_cache(ePICPixHash *hash)
464 {
465  int i, j;
466 
467  for (i = 0; i < EPIC_HASH_SIZE; i++) {
468  for (j = 0; j < hash->bucket_fill[i]; j++) {
469  ePICPixListElem *list_elem = hash->bucket[i][j].list;
470  while (list_elem) {
471  ePICPixListElem *tmp = list_elem->next;
472  av_free(list_elem);
473  list_elem = tmp;
474  }
475  }
476  av_freep(&hash->bucket[i]);
477  hash->bucket_size[i] =
478  hash->bucket_fill[i] = 0;
479  }
480 }
481 
482 static inline int is_pixel_on_stack(const ePICContext *dc, uint32_t pix)
483 {
484  int i;
485  int n = FFMIN(dc->stack_pos, EPIC_PIX_STACK_SIZE);
486 
487  for (i = 0; i < n; i++)
488  if (dc->stack[i] == pix)
489  break;
490 
491  return i != n;
492 }
493 
494 #define TOSIGNED(val) (((val) >> 1) ^ -((val) & 1))
495 
496 static inline int epic_decode_component_pred(ePICContext *dc,
497  int N, int W, int NW)
498 {
499  unsigned delta = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);
500  return mid_pred(N, N + W - NW, W) - TOSIGNED(delta);
501 }
502 
503 static uint32_t epic_decode_pixel_pred(ePICContext *dc, int x, int y,
504  const uint32_t *curr_row,
505  const uint32_t *above_row)
506 {
507  uint32_t N, W, NW, pred;
508  unsigned delta;
509  int GN, GW, GNW, R, G, B;
510 
511  if (x && y) {
512  W = curr_row[x - 1];
513  N = above_row[x];
514  NW = above_row[x - 1];
515 
516  GN = (N >> G_shift) & 0xFF;
517  GW = (W >> G_shift) & 0xFF;
518  GNW = (NW >> G_shift) & 0xFF;
519 
520  G = epic_decode_component_pred(dc, GN, GW, GNW);
521 
522  R = G + epic_decode_component_pred(dc,
523  ((N >> R_shift) & 0xFF) - GN,
524  ((W >> R_shift) & 0xFF) - GW,
525  ((NW >> R_shift) & 0xFF) - GNW);
526 
527  B = G + epic_decode_component_pred(dc,
528  ((N >> B_shift) & 0xFF) - GN,
529  ((W >> B_shift) & 0xFF) - GW,
530  ((NW >> B_shift) & 0xFF) - GNW);
531  } else {
532  if (x)
533  pred = curr_row[x - 1];
534  else
535  pred = above_row[x];
536 
537  delta = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);
538  R = ((pred >> R_shift) & 0xFF) - TOSIGNED(delta);
539 
540  delta = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);
541  G = ((pred >> G_shift) & 0xFF) - TOSIGNED(delta);
542 
543  delta = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);
544  B = ((pred >> B_shift) & 0xFF) - TOSIGNED(delta);
545  }
546 
547  if (R<0 || G<0 || B<0 || R > 255 || G > 255 || B > 255) {
548  avpriv_request_sample(NULL, "RGB %d %d %d (out of range)", R, G, B);
549  return 0;
550  }
551 
552  return (R << R_shift) | (G << G_shift) | (B << B_shift);
553 }
554 
555 static int epic_predict_pixel(ePICContext *dc, uint8_t *rung,
556  uint32_t *pPix, uint32_t pix)
557 {
558  if (!ff_els_decode_bit(&dc->els_ctx, rung)) {
559  *pPix = pix;
560  return 1;
561  }
562  dc->stack[dc->stack_pos++ & EPIC_PIX_STACK_MAX] = pix;
563  return 0;
564 }
565 
566 static int epic_handle_edges(ePICContext *dc, int x, int y,
567  const uint32_t *curr_row,
568  const uint32_t *above_row, uint32_t *pPix)
569 {
570  uint32_t pix;
571 
572  if (!x && !y) { /* special case: top-left pixel */
573  /* the top-left pixel is coded independently with 3 unsigned numbers */
574  *pPix = (ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung) << R_shift) |
575  (ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung) << G_shift) |
576  (ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung) << B_shift);
577  return 1;
578  }
579 
580  if (x) { /* predict from W first */
581  pix = curr_row[x - 1];
582  if (epic_predict_pixel(dc, &dc->W_flag_rung, pPix, pix))
583  return 1;
584  }
585 
586  if (y) { /* then try to predict from N */
587  pix = above_row[x];
588  if (!dc->stack_pos || dc->stack[0] != pix) {
589  if (epic_predict_pixel(dc, &dc->N_flag_rung, pPix, pix))
590  return 1;
591  }
592  }
593 
594  return 0;
595 }
596 
597 static int epic_decode_run_length(ePICContext *dc, int x, int y, int tile_width,
598  const uint32_t *curr_row,
599  const uint32_t *above_row,
600  const uint32_t *above2_row,
601  uint32_t *pPix, int *pRun)
602 {
603  int idx, got_pixel = 0, WWneW, old_WWneW = 0;
604  uint32_t W, WW, N, NN, NW, NE, NWW, NNW, NNE;
605 
606  *pRun = 0;
607 
608  LOAD_NEIGHBOURS(x);
609 
610  if (dc->next_run_pos == x) {
611  /* can't reuse W for the new pixel in this case */
612  WWneW = 1;
613  } else {
614  idx = (WW != W) << 7 |
615  (NW != W) << 6 |
616  (N != NE) << 5 |
617  (NW != N) << 4 |
618  (NWW != NW) << 3 |
619  (NNE != NE) << 2 |
620  (NN != N) << 1 |
621  (NNW != NW);
622  WWneW = ff_els_decode_bit(&dc->els_ctx, &dc->W_ctx_rung[idx]);
623  if (WWneW < 0)
624  return WWneW;
625  }
626 
627  if (WWneW)
628  dc->stack[dc->stack_pos++ & EPIC_PIX_STACK_MAX] = W;
629  else {
630  *pPix = W;
631  got_pixel = 1;
632  }
633 
634  do {
635  int NWneW = 1;
636  if (got_pixel) // pixel value already known (derived from either W or N)
637  NWneW = *pPix != N;
638  else { // pixel value is unknown and will be decoded later
639  NWneW = *pRun ? NWneW : NW != W;
640 
641  /* TODO: RFC this mess! */
642  switch (((NW != N) << 2) | (NWneW << 1) | WWneW) {
643  case 0:
644  break; // do nothing here
645  case 3:
646  case 5:
647  case 6:
648  case 7:
649  if (!is_pixel_on_stack(dc, N)) {
650  idx = WWneW << 8 |
651  (*pRun ? old_WWneW : WW != W) << 7 |
652  NWneW << 6 |
653  (N != NE) << 5 |
654  (NW != N) << 4 |
655  (NWW != NW) << 3 |
656  (NNE != NE) << 2 |
657  (NN != N) << 1 |
658  (NNW != NW);
659  if (!ff_els_decode_bit(&dc->els_ctx, &dc->N_ctx_rung[idx])) {
660  NWneW = 0;
661  *pPix = N;
662  got_pixel = 1;
663  break;
664  }
665  }
666  av_fallthrough;
667  default:
668  NWneW = 1;
669  old_WWneW = WWneW;
670  if (!is_pixel_on_stack(dc, N))
671  dc->stack[dc->stack_pos++ & EPIC_PIX_STACK_MAX] = N;
672  }
673  }
674 
675  (*pRun)++;
676  if (x + *pRun >= tile_width - 1)
677  break;
678 
679  UPDATE_NEIGHBOURS(x + *pRun);
680 
681  if (!NWneW && NW == N && N == NE) {
682  int pos, run, rle;
683  int start_pos = x + *pRun;
684 
685  /* scan for a run of pix in the line above */
686  uint32_t pix = above_row[start_pos + 1];
687  for (pos = start_pos + 2; pos < tile_width; pos++)
688  if (!(above_row[pos] == pix))
689  break;
690  run = pos - start_pos - 1;
691  idx = av_ceil_log2(run);
692  if (ff_els_decode_bit(&dc->els_ctx, &dc->prev_row_rung[idx]))
693  *pRun += run;
694  else {
695  int flag;
696  /* run-length is coded as plain binary number of idx - 1 bits */
697  for (pos = idx - 1, rle = 0, flag = 0; pos >= 0; pos--) {
698  if ((1 << pos) + rle < run &&
699  ff_els_decode_bit(&dc->els_ctx,
700  flag ? &dc->runlen_one
701  : &dc->runlen_zeroes[pos])) {
702  flag = 1;
703  rle |= 1 << pos;
704  }
705  }
706  *pRun += rle;
707  break; // return immediately
708  }
709  if (x + *pRun >= tile_width - 1)
710  break;
711 
712  LOAD_NEIGHBOURS(x + *pRun);
713  WWneW = 0;
714  NWneW = 0;
715  }
716 
717  idx = WWneW << 7 |
718  NWneW << 6 |
719  (N != NE) << 5 |
720  (NW != N) << 4 |
721  (NWW != NW) << 3 |
722  (NNE != NE) << 2 |
723  (NN != N) << 1 |
724  (NNW != NW);
725  WWneW = ff_els_decode_bit(&dc->els_ctx, &dc->W_ctx_rung[idx]);
726  } while (!WWneW);
727 
728  dc->next_run_pos = x + *pRun;
729  return got_pixel;
730 }
731 
732 static int epic_predict_pixel2(ePICContext *dc, uint8_t *rung,
733  uint32_t *pPix, uint32_t pix)
734 {
735  if (ff_els_decode_bit(&dc->els_ctx, rung)) {
736  *pPix = pix;
737  return 1;
738  }
739  dc->stack[dc->stack_pos++ & EPIC_PIX_STACK_MAX] = pix;
740  return 0;
741 }
742 
743 static int epic_predict_from_NW_NE(ePICContext *dc, int x, int y, int run,
744  int tile_width, const uint32_t *curr_row,
745  const uint32_t *above_row, uint32_t *pPix)
746 {
747  int pos;
748 
749  /* try to reuse the NW pixel first */
750  if (x && y) {
751  uint32_t NW = above_row[x - 1];
752  if (NW != curr_row[x - 1] && NW != above_row[x] && !is_pixel_on_stack(dc, NW)) {
753  if (epic_predict_pixel2(dc, &dc->nw_pred_rung[NW & 0xFF], pPix, NW))
754  return 1;
755  }
756  }
757 
758  /* try to reuse the NE[x + run, y] pixel */
759  pos = x + run - 1;
760  if (pos < tile_width - 1 && y) {
761  uint32_t NE = above_row[pos + 1];
762  if (NE != above_row[pos] && !is_pixel_on_stack(dc, NE)) {
763  if (epic_predict_pixel2(dc, &dc->ne_pred_rung[NE & 0xFF], pPix, NE))
764  return 1;
765  }
766  }
767 
768  return 0;
769 }
770 
771 static int epic_decode_from_cache(ePICContext *dc, uint32_t W, uint32_t *pPix)
772 {
773  ePICPixListElem *list, *prev = NULL;
774  ePICPixHashElem *hash_elem = epic_hash_find(&dc->hash, W);
775 
776  if (!hash_elem || !hash_elem->list)
777  return 0;
778 
779  list = hash_elem->list;
780  while (list) {
781  if (!is_pixel_on_stack(dc, list->pixel)) {
782  if (ff_els_decode_bit(&dc->els_ctx, &list->rung)) {
783  *pPix = list->pixel;
784  if (list != hash_elem->list) {
785  prev->next = list->next;
786  list->next = hash_elem->list;
787  hash_elem->list = list;
788  }
789  return 1;
790  }
791  dc->stack[dc->stack_pos++ & EPIC_PIX_STACK_MAX] = list->pixel;
792  }
793  prev = list;
794  list = list->next;
795  }
796 
797  return 0;
798 }
799 
800 static int epic_decode_tile(ePICContext *dc, uint8_t *out, int tile_height,
801  int tile_width, int stride)
802 {
803  int x, y;
804  uint32_t pix;
805  uint32_t *curr_row = NULL, *above_row = NULL, *above2_row;
806 
807  for (y = 0; y < tile_height; y++, out += stride) {
808  above2_row = above_row;
809  above_row = curr_row;
810  curr_row = (uint32_t *) out;
811 
812  for (x = 0, dc->next_run_pos = 0; x < tile_width;) {
813  if (dc->els_ctx.err)
814  return AVERROR_INVALIDDATA; // bail out in the case of ELS overflow
815 
816  pix = curr_row[x - 1]; // get W pixel
817 
818  if (y >= 1 && x >= 2 &&
819  pix != curr_row[x - 2] && pix != above_row[x - 1] &&
820  pix != above_row[x - 2] && pix != above_row[x] &&
821  !epic_cache_entries_for_pixel(&dc->hash, pix)) {
822  curr_row[x] = epic_decode_pixel_pred(dc, x, y, curr_row, above_row);
823  x++;
824  } else {
825  int got_pixel, run;
826  dc->stack_pos = 0; // empty stack
827 
828  if (y < 2 || x < 2 || x == tile_width - 1) {
829  run = 1;
830  got_pixel = epic_handle_edges(dc, x, y, curr_row, above_row, &pix);
831  } else {
832  got_pixel = epic_decode_run_length(dc, x, y, tile_width,
833  curr_row, above_row,
834  above2_row, &pix, &run);
835  if (got_pixel < 0)
836  return got_pixel;
837  }
838 
839  if (!got_pixel && !epic_predict_from_NW_NE(dc, x, y, run,
840  tile_width, curr_row,
841  above_row, &pix)) {
842  uint32_t ref_pix = curr_row[x - 1];
843  if (!x || !epic_decode_from_cache(dc, ref_pix, &pix)) {
844  pix = epic_decode_pixel_pred(dc, x, y, curr_row, above_row);
845  if (is_pixel_on_stack(dc, pix))
846  return AVERROR_INVALIDDATA;
847 
848  if (x) {
849  int ret = epic_add_pixel_to_cache(&dc->hash,
850  ref_pix,
851  pix);
852  if (ret)
853  return ret;
854  }
855  }
856  }
857  for (; run > 0; x++, run--)
858  curr_row[x] = pix;
859  }
860  }
861  }
862 
863  return 0;
864 }
865 
866 static int epic_jb_decode_tile(G2MContext *c, int tile_x, int tile_y,
867  const uint8_t *src, size_t src_size,
868  AVCodecContext *avctx)
869 {
870  uint8_t prefix, mask = 0x80;
871  int extrabytes, tile_width, tile_height, awidth, aheight;
872  size_t els_dsize;
873  uint8_t *dst;
874 
875  if (!src_size)
876  return 0;
877 
878  /* get data size of the ELS partition as unsigned variable-length integer */
879  prefix = *src++;
880  src_size--;
881  for (extrabytes = 0; (prefix & mask) && (extrabytes < 7); extrabytes++)
882  mask >>= 1;
883  if (extrabytes > 3 || src_size < extrabytes) {
884  av_log(avctx, AV_LOG_ERROR, "ePIC: invalid data size VLI\n");
885  return AVERROR_INVALIDDATA;
886  }
887 
888  els_dsize = prefix & ((0x80 >> extrabytes) - 1); // mask out the length prefix
889  while (extrabytes-- > 0) {
890  els_dsize = (els_dsize << 8) | *src++;
891  src_size--;
892  }
893 
894  if (src_size < els_dsize) {
895  av_log(avctx, AV_LOG_ERROR, "ePIC: data too short, needed %zu, got %zu\n",
896  els_dsize, src_size);
897  return AVERROR_INVALIDDATA;
898  }
899 
900  tile_width = FFMIN(c->width - tile_x * c->tile_width, c->tile_width);
901  tile_height = FFMIN(c->height - tile_y * c->tile_height, c->tile_height);
902  awidth = FFALIGN(tile_width, 16);
903  aheight = FFALIGN(tile_height, 16);
904 
905  if (tile_width > (1 << FF_ARRAY_ELEMS(c->ec.prev_row_rung))) {
906  avpriv_request_sample(avctx, "large tile width");
907  return AVERROR_INVALIDDATA;
908  }
909 
910  if (els_dsize) {
911  int ret, i, j, k;
912  uint8_t tr_r, tr_g, tr_b, *buf;
913  uint32_t *in;
914  /* ELS decoder initializations */
915  memset(&c->ec, 0, sizeof(c->ec));
916  ff_els_decoder_init(&c->ec.els_ctx, src, els_dsize);
917  epic_hash_init(&c->ec.hash);
918 
919  /* decode transparent pixel value */
920  tr_r = ff_els_decode_unsigned(&c->ec.els_ctx, &c->ec.unsigned_rung);
921  tr_g = ff_els_decode_unsigned(&c->ec.els_ctx, &c->ec.unsigned_rung);
922  tr_b = ff_els_decode_unsigned(&c->ec.els_ctx, &c->ec.unsigned_rung);
923  if (c->ec.els_ctx.err != 0) {
924  av_log(avctx, AV_LOG_ERROR,
925  "ePIC: couldn't decode transparency pixel!\n");
926  ff_els_decoder_uninit(&c->ec.unsigned_rung);
927  return AVERROR_INVALIDDATA;
928  }
929 
930  ret = epic_decode_tile(&c->ec, c->epic_buf, tile_height, tile_width,
931  c->epic_buf_stride);
932 
933  epic_free_pixel_cache(&c->ec.hash);
934  ff_els_decoder_uninit(&c->ec.unsigned_rung);
935 
936  if (ret) {
937  av_log(avctx, AV_LOG_ERROR,
938  "ePIC: tile decoding failed, frame=%"PRId64", tile_x=%d, tile_y=%d\n",
939  avctx->frame_num, tile_x, tile_y);
940  return AVERROR_INVALIDDATA;
941  }
942 
943  buf = c->epic_buf;
944  dst = c->framebuf + tile_x * c->tile_width * 3 +
945  tile_y * c->tile_height * c->framebuf_stride;
946 
947  for (j = 0; j < tile_height; j++) {
948  uint8_t *out = dst;
949  in = (uint32_t *) buf;
950  for (i = 0; i < tile_width; i++) {
951  out[0] = (in[i] >> R_shift) & 0xFF;
952  out[1] = (in[i] >> G_shift) & 0xFF;
953  out[2] = (in[i] >> B_shift) & 0xFF;
954  out += 3;
955  }
956  buf += c->epic_buf_stride;
957  dst += c->framebuf_stride;
958  }
959 
960  if (src_size > els_dsize) {
961  uint8_t *jpg;
962  uint32_t tr;
963  int bstride = FFALIGN(tile_width, 16) >> 3;
964  int nblocks = 0;
965  int estride = c->epic_buf_stride >> 2;
966 
967  src += els_dsize;
968  src_size -= els_dsize;
969 
970  in = (uint32_t *) c->epic_buf;
971  tr = (tr_r << R_shift) | (tr_g << G_shift) | (tr_b << B_shift);
972 
973  memset(c->kempf_flags, 0,
974  (aheight >> 3) * bstride * sizeof(*c->kempf_flags));
975  for (j = 0; j < tile_height; j += 8) {
976  for (i = 0; i < tile_width; i += 8) {
977  c->kempf_flags[(i >> 3) + (j >> 3) * bstride] = 0;
978  for (k = 0; k < 8 * 8; k++) {
979  if (in[i + (k & 7) + (k >> 3) * estride] == tr) {
980  c->kempf_flags[(i >> 3) + (j >> 3) * bstride] = 1;
981  nblocks++;
982  break;
983  }
984  }
985  }
986  in += 8 * estride;
987  }
988 
989  memset(c->jpeg_tile, 0, c->tile_stride * aheight);
990  jpg_decode_data(&c->jc, awidth, aheight, src, src_size,
991  c->jpeg_tile, c->tile_stride,
992  c->kempf_flags, bstride, nblocks, c->swapuv);
993 
994  in = (uint32_t *) c->epic_buf;
995  dst = c->framebuf + tile_x * c->tile_width * 3 +
996  tile_y * c->tile_height * c->framebuf_stride;
997  jpg = c->jpeg_tile;
998  for (j = 0; j < tile_height; j++) {
999  for (i = 0; i < tile_width; i++)
1000  if (in[i] == tr)
1001  memcpy(dst + i * 3, jpg + i * 3, 3);
1002  in += c->epic_buf_stride >> 2;
1003  dst += c->framebuf_stride;
1004  jpg += c->tile_stride;
1005  }
1006  }
1007  } else {
1008  dst = c->framebuf + tile_x * c->tile_width * 3 +
1009  tile_y * c->tile_height * c->framebuf_stride;
1010  return jpg_decode_data(&c->jc, tile_width, tile_height, src, src_size,
1011  dst, c->framebuf_stride, NULL, 0, 0, c->swapuv);
1012  }
1013 
1014  return 0;
1015 }
1016 
1017 static int kempf_restore_buf(const uint8_t *src, int len,
1018  uint8_t *dst, int stride,
1019  const uint8_t *jpeg_tile, int tile_stride,
1020  int width, int height,
1021  const uint8_t *pal, int npal, int tidx)
1022 {
1023  GetBitContext gb;
1024  int i, j, nb, col;
1025  int ret;
1026  int align_width = FFALIGN(width, 16);
1027 
1028  if ((ret = init_get_bits8(&gb, src, len)) < 0)
1029  return ret;
1030 
1031  if (npal <= 2) nb = 1;
1032  else if (npal <= 4) nb = 2;
1033  else if (npal <= 16) nb = 4;
1034  else nb = 8;
1035 
1036  for (j = 0; j < height; j++, dst += stride, jpeg_tile = FF_PTR_ADD(jpeg_tile, tile_stride)) {
1037  if (get_bits(&gb, 8))
1038  continue;
1039  for (i = 0; i < width; i++) {
1040  col = get_bits(&gb, nb);
1041  if (col != tidx)
1042  memcpy(dst + i * 3, pal + col * 3, 3);
1043  else
1044  memcpy(dst + i * 3, jpeg_tile + i * 3, 3);
1045  }
1046  skip_bits_long(&gb, nb * (align_width - width));
1047  }
1048 
1049  return 0;
1050 }
1051 
1052 static int kempf_decode_tile(G2MContext *c, int tile_x, int tile_y,
1053  const uint8_t *src, int src_size)
1054 {
1055  int width, height;
1056  int hdr, zsize, npal, tidx = -1, ret;
1057  const uint8_t *src_end = src + src_size;
1058  uint8_t pal[768], transp[3];
1059  uLongf dlen = (c->tile_width + 1) * c->tile_height;
1060  int sub_type;
1061  int nblocks, cblocks, bstride;
1062  int bits, bitbuf, coded;
1063  uint8_t *dst = c->framebuf + tile_x * c->tile_width * 3 +
1064  tile_y * c->tile_height * c->framebuf_stride;
1065 
1066  if (src_size < 2)
1067  return AVERROR_INVALIDDATA;
1068 
1069  width = FFMIN(c->width - tile_x * c->tile_width, c->tile_width);
1070  height = FFMIN(c->height - tile_y * c->tile_height, c->tile_height);
1071 
1072  hdr = *src++;
1073  sub_type = hdr >> 5;
1074  if (sub_type == 0) {
1075  memcpy(transp, src, 3);
1076  src += 3;
1077  for (int j = 0; j < height; j++, dst += c->framebuf_stride)
1078  for (int 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 (int 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 (int i = 0; i < (FFALIGN(height, 16) >> 4); i++) {
1129  for (int 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:47
COMPR_KEMPF_J_B
@ COMPR_KEMPF_J_B
Definition: g2meet.c:61
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:89
epic_add_pixel_to_cache
static int epic_add_pixel_to_cache(ePICPixHash *hash, uint32_t key, uint32_t pix)
Definition: g2meet.c:431
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:280
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
ePICContext::els_ctx
ElsDecCtx els_ctx
Definition: g2meet.c:106
jpegtables.h
ePICPixHashElem::list
struct ePICPixListElem * list
Definition: g2meet.c:95
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:43
chunk_start
static int chunk_start(AVFormatContext *s)
Definition: webm_chunk.c:161
blockdsp.h
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:688
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:143
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(const GetByteContext *g)
Definition: bytestream.h:158
mem_internal.h
out
static FILE * out
Definition: movenc.c:55
G2MContext::epic_buf_base
uint8_t * epic_buf_base
Definition: g2meet.c:153
GetByteContext
Definition: bytestream.h:33
bytestream2_tell
static av_always_inline int bytestream2_tell(const GetByteContext *g)
Definition: bytestream.h:192
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:118
G2MContext::old_tile_w
int old_tile_w
Definition: g2meet.c:154
EPIC_HASH_SIZE
#define EPIC_HASH_SIZE
Definition: g2meet.c:98
mask
int mask
Definition: mediacodecdec_common.c:154
jpg_decode_block
static int jpg_decode_block(JPGContext *c, GetBitContext *gb, int plane, int16_t *block)
Definition: g2meet.c:224
mjpegdec.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:459
JPGContext::permutated_scantable
uint8_t permutated_scantable[64]
Definition: g2meet.c:126
AVPacket::data
uint8_t * data
Definition: packet.h:595
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:743
R
#define R
Definition: huffyuv.h:44
G2MContext::tile_width
int tile_width
Definition: g2meet.c:144
ff_mjpeg_val_dc
const uint8_t ff_mjpeg_val_dc[]
Definition: jpegtabs.h:34
FFCodec
Definition: codec_internal.h:127
G2MContext::jpeg_tile
uint8_t * jpeg_tile
Definition: g2meet.c:153
ePICPixListElem::rung
uint8_t rung
Definition: g2meet.c:90
B_shift
#define B_shift
Definition: g2meet.c:376
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:703
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)
Definition: utils.c:91
hash
static uint8_t hash[HASH_SIZE]
Definition: movenc.c:58
pix
enum AVPixelFormat pix
Definition: ohcodec.c:55
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:374
rle
static int rle(uint8_t *dst, const uint8_t *src, int compressed_size, int uncompressed_size)
Definition: exr.c:225
ePICContext::N_ctx_rung
uint8_t N_ctx_rung[512]
Definition: g2meet.c:112
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:480
jpg_unescape
static void jpg_unescape(const uint8_t *src, int src_size, uint8_t *dst, int *dst_size)
Definition: g2meet.c:207
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
close
static av_cold void close(AVCodecParserContext *s)
Definition: apv_parser.c:197
ePICPixHash::bucket_size
int bucket_size[EPIC_HASH_SIZE]
Definition: g2meet.c:101
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:337
epic_hash_find
static ePICPixHashElem * epic_hash_find(const ePICPixHash *hash, uint32_t key)
Definition: g2meet.c:396
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
JPGContext
Definition: g2meet.c:123
epic_decode_tile
static int epic_decode_tile(ePICContext *dc, uint8_t *out, int tile_height, int tile_width, int stride)
Definition: g2meet.c:800
av_ceil_log2
#define av_ceil_log2
Definition: common.h:97
ePICContext::prev_row_rung
uint8_t prev_row_rung[14]
Definition: g2meet.c:115
GetBitContext
Definition: get_bits.h:109
TOSIGNED
#define TOSIGNED(val)
Definition: g2meet.c:494
val
static double val(void *priv, double ch)
Definition: aeval.c:77
G2MContext::swapuv
int swapuv
Definition: g2meet.c:155
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:566
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:129
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:119
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:544
ePICPixListElem
Definition: g2meet.c:87
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:674
G2MContext::version
int version
Definition: g2meet.c:139
G2MContext::tiles_y
int tiles_y
Definition: g2meet.c:145
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:347
W
#define W(a, i, v)
Definition: jpegls.h:119
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
ePICPixHashElem
Definition: g2meet.c:93
G2MContext::jc
JPGContext jc
Definition: g2meet.c:137
ePICContext::nw_pred_rung
uint8_t nw_pred_rung[256]
Definition: g2meet.c:113
bits
uint8_t bits
Definition: vp3data.h:128
ePICPixHash
Definition: g2meet.c:99
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:120
ePICContext::W_ctx_rung
uint8_t W_ctx_rung[256]
Definition: g2meet.c:111
ctx
static AVFormatContext * ctx
Definition: movenc.c:49
G2MContext::cursor
uint8_t * cursor
Definition: g2meet.c:159
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:1800
CHUNK_CC
@ CHUNK_CC
Definition: g2meet.c:55
epic_decode_from_cache
static int epic_decode_from_cache(ePICContext *dc, uint32_t W, uint32_t *pPix)
Definition: g2meet.c:771
key
const char * key
Definition: hwcontext_opencl.c:189
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
av_fallthrough
#define av_fallthrough
Definition: attributes.h:67
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
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:163
ePICContext::next_run_pos
int next_run_pos
Definition: g2meet.c:107
G2MContext::kempf_buf
uint8_t * kempf_buf
Definition: g2meet.c:157
TILE_DATA
@ TILE_DATA
Definition: g2meet.c:52
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:866
COMPR_EPIC_J_B
@ COMPR_EPIC_J_B
Definition: g2meet.c:60
NULL
#define NULL
Definition: coverity.c:32
CURSOR_SHAPE
@ CURSOR_SHAPE
Definition: g2meet.c:54
ePICPixHash::bucket
ePICPixHashElem * bucket[EPIC_HASH_SIZE]
Definition: g2meet.c:100
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:207
ePICContext::W_flag_rung
uint8_t W_flag_rung
Definition: g2meet.c:109
ePICContext::unsigned_rung
ElsUnsignedRung unsigned_rung
Definition: g2meet.c:108
epic_hash_add
static ePICPixHashElem * epic_hash_add(ePICPixHash *hash, uint32_t key)
Definition: g2meet.c:408
ff_g2m_decoder
const FFCodec ff_g2m_decoder
Definition: g2meet.c:1629
G2MContext::old_tile_h
int old_tile_h
Definition: g2meet.c:154
V
#define V
Definition: avdct.c:32
jpg_init
static av_cold int jpg_init(AVCodecContext *avctx, JPGContext *c)
Definition: g2meet.c:166
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
Compression
Compression
Definition: g2meet.c:59
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:160
EPIC_PIX_STACK_MAX
#define EPIC_PIX_STACK_MAX
Definition: g2meet.c:48
CURSOR_POS
@ CURSOR_POS
Definition: g2meet.c:53
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:645
epic_predict_pixel2
static int epic_predict_pixel2(ePICContext *dc, uint8_t *rung, uint32_t *pPix, uint32_t pix)
Definition: g2meet.c:732
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
g2m_decode_frame
static int g2m_decode_frame(AVCodecContext *avctx, AVFrame *pic, int *got_picture_ptr, AVPacket *avpkt)
Definition: g2meet.c:1375
G2MContext::epic_buf_stride
int epic_buf_stride
Definition: g2meet.c:154
G2MContext::epic_buf
uint8_t * epic_buf
Definition: g2meet.c:153
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:551
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1768
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:551
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:596
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
height
#define height
Definition: dsp.h:89
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
ePICContext::N_flag_rung
uint8_t N_flag_rung
Definition: g2meet.c:110
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:375
ePICPixListElem::next
struct ePICPixListElem * next
Definition: g2meet.c:88
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
G2MContext::cursor_y
int cursor_y
Definition: g2meet.c:162
G2MContext::compression
int compression
Definition: g2meet.c:141
ElsDecCtx
Definition: elsdec.h:36
attributes.h
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:294
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:125
Y
#define Y
Definition: boxblur.h:37
JPGContext::ac_vlc
VLC ac_vlc[2]
Definition: g2meet.c:128
ePICPixHashElem::pix_id
uint32_t pix_id
Definition: g2meet.c:94
G2MContext::framebuf_allocated
unsigned int framebuf_allocated
Definition: g2meet.c:151
ePICPixHash::bucket_fill
int bucket_fill[EPIC_HASH_SIZE]
Definition: g2meet.c:102
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:1052
JPGContext::buf
uint8_t * buf
Definition: g2meet.c:132
djb2_hash
static int djb2_hash(uint32_t key)
Definition: g2meet.c:379
G2MContext::height
int height
Definition: g2meet.c:142
G2MContext::cursor_w
int cursor_w
Definition: g2meet.c:162
delta
float delta
Definition: vorbis_enc_data.h:430
jpg_free_context
static av_cold void jpg_free_context(JPGContext *ctx)
Definition: g2meet.c:195
G2MContext::cursor_h
int cursor_h
Definition: g2meet.c:162
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
G2MContext::cursor_x
int cursor_x
Definition: g2meet.c:162
G2MContext::bpp
int bpp
Definition: g2meet.c:142
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
G2MContext::tile_stride
int tile_stride
Definition: g2meet.c:154
len
int len
Definition: vorbis_enc_data.h:426
luma_quant
static const uint8_t luma_quant[64]
Definition: g2meet.c:65
AVCodecContext::height
int height
Definition: avcodec.h:604
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:643
G2MContext::tile_x
int tile_x
Definition: g2meet.c:145
idctdsp.h
avcodec.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:137
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:1896
mid_pred
#define mid_pred
Definition: mathops.h:115
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:1017
pred
static const float pred[4]
Definition: siprdata.h:259
G2MContext::width
int width
Definition: g2meet.c:142
pos
unsigned int pos
Definition: spdifenc.c:414
IDCTDSPContext
Definition: idctdsp.h:43
flag
#define flag(name)
Definition: cbs_av1.c:496
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:114
U
#define U(x)
Definition: vpx_arith.h:37
G2MContext::ec
ePICContext ec
Definition: g2meet.c:136
AVCodecContext
main external API structure.
Definition: avcodec.h:443
G2MContext::framebuf
uint8_t * framebuf
Definition: g2meet.c:149
ePICContext::runlen_one
uint8_t runlen_one
Definition: g2meet.c:117
G2MContext::cursor_fmt
int cursor_fmt
Definition: g2meet.c:161
epic_hash_init
static void epic_hash_init(ePICPixHash *hash)
Definition: g2meet.c:391
g2m_init_buffers
static int g2m_init_buffers(G2MContext *c)
Definition: g2meet.c:1161
G2MContext
Definition: g2meet.c:135
ePICContext::runlen_zeroes
uint8_t runlen_zeroes[14]
Definition: g2meet.c:116
VLC
Definition: vlc.h:50
epic_predict_pixel
static int epic_predict_pixel(ePICContext *dc, uint8_t *rung, uint32_t *pPix, uint32_t pix)
Definition: g2meet.c:555
G2MContext::tiles_x
int tiles_x
Definition: g2meet.c:145
JPGContext::bdsp
BlockDSPContext bdsp
Definition: g2meet.c:124
JPGContext::dc_vlc
VLC dc_vlc[2]
Definition: g2meet.c:128
DISPLAY_INFO
@ DISPLAY_INFO
Definition: g2meet.c:51
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
ePICContext
Definition: g2meet.c:105
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:144
JPGContext::block
int16_t block[6][64]
Definition: g2meet.c:130
UPDATE_NEIGHBOURS
#define UPDATE_NEIGHBOURS(x)
Definition: g2meet.c:365
av_realloc
#define av_realloc(p, s)
Definition: ops_asmgen.c:46
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:271
CHUNK_CD
@ CHUNK_CD
Definition: g2meet.c:56
LOAD_NEIGHBOURS
#define LOAD_NEIGHBOURS(x)
Definition: g2meet.c:354
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
mem.h
chroma_quant
static const uint8_t chroma_quant[64]
Definition: g2meet.c:76
G2MContext::tile_y
int tile_y
Definition: g2meet.c:145
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
epic_cache_entries_for_pixel
static int epic_cache_entries_for_pixel(const ePICPixHash *hash, uint32_t pix)
Definition: g2meet.c:452
AV_CODEC_ID_G2M
@ AV_CODEC_ID_G2M
Definition: codec_id.h:225
w
uint8_t w
Definition: llvidencdsp.c:39
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
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:150
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:470
AVPacket
This structure stores compressed data.
Definition: packet.h:572
G2MContext::got_header
int got_header
Definition: g2meet.c:147
G2MContext::cursor_hot_y
int cursor_hot_y
Definition: g2meet.c:163
epic_decode_component_pred
static int epic_decode_component_pred(ePICContext *dc, int N, int W, int NW)
Definition: g2meet.c:496
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:597
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:604
ePICContext::stack
uint32_t stack[EPIC_PIX_STACK_SIZE]
Definition: g2meet.c:119
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:143
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:504
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:50
h
h
Definition: vp9dsp_template.c:2070
stride
#define stride
Definition: h264pred_template.c:536
width
#define width
Definition: dsp.h:89
epic_free_pixel_cache
static void epic_free_pixel_cache(ePICPixHash *hash)
Definition: g2meet.c:463
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:503
yuv2rgb
static void yuv2rgb(uint8_t *out, int ridx, int Y, int U, int V)
Definition: g2meet.c:264
G2MContext::synth_tile
uint8_t * synth_tile
Definition: g2meet.c:153
src
#define src
Definition: vp8dsp.c:248
G2MContext::kempf_flags
uint8_t * kempf_flags
Definition: g2meet.c:157
elsdec.h
is_pixel_on_stack
static int is_pixel_on_stack(const ePICContext *dc, uint32_t pix)
Definition: g2meet.c:482
Generated on Thu May 21 2026 19:22:25 for FFmpeg by   doxygen 1.8.17