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