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