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/intreadwrite.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 "elsdec.h"
40 #include "get_bits.h"
41 #include "idctdsp.h"
42 #include "internal.h"
43 #include "jpegtables.h"
44 #include "mjpeg.h"
45 #include "mjpegdec.h"
46 
47 #define EPIC_PIX_STACK_SIZE 1024
48 #define EPIC_PIX_STACK_MAX (EPIC_PIX_STACK_SIZE - 1)
49 
50 enum ChunkType {
51  DISPLAY_INFO = 0xC8,
52  TILE_DATA,
53  CURSOR_POS,
54  CURSOR_SHAPE,
55  CHUNK_CC,
56  CHUNK_CD
57 };
58 
59 enum Compression {
60  COMPR_EPIC_J_B = 2,
61  COMPR_KEMPF_J_B,
62 };
63 
64 static const uint8_t luma_quant[64] = {
65  8, 6, 5, 8, 12, 20, 26, 31,
66  6, 6, 7, 10, 13, 29, 30, 28,
67  7, 7, 8, 12, 20, 29, 35, 28,
68  7, 9, 11, 15, 26, 44, 40, 31,
69  9, 11, 19, 28, 34, 55, 52, 39,
70  12, 18, 28, 32, 41, 52, 57, 46,
71  25, 32, 39, 44, 52, 61, 60, 51,
72  36, 46, 48, 49, 56, 50, 52, 50
73 };
74 
75 static const uint8_t chroma_quant[64] = {
76  9, 9, 12, 24, 50, 50, 50, 50,
77  9, 11, 13, 33, 50, 50, 50, 50,
78  12, 13, 28, 50, 50, 50, 50, 50,
79  24, 33, 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  ScanTable scantable;
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, old_width, old_height;
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, avctx);
186  ff_idctdsp_init(&c->idsp, avctx);
187  ff_init_scantable(c->idsp.idct_permutation, &c->scantable,
188  ff_zigzag_direct);
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_free_vlc(&ctx->dc_vlc[i]);
199  ff_free_vlc(&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[ff_zigzag_direct[pos]];
256  block[c->scantable.permutated[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=%d, tile_x=%d, tile_y=%d\n",
936  avctx->frame_number, 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  if (!c->framebuf || c->old_width < c->width || c->old_height < c->height) {
1165  c->framebuf_stride = FFALIGN(c->width + 15, 16) * 3;
1166  aligned_height = c->height + 15;
1167  av_free(c->framebuf);
1168  c->framebuf = av_calloc(c->framebuf_stride, aligned_height);
1169  if (!c->framebuf)
1170  return AVERROR(ENOMEM);
1171  }
1172  if (!c->synth_tile || !c->jpeg_tile ||
1173  (c->compression == 2 && !c->epic_buf_base) ||
1174  c->old_tile_w < c->tile_width ||
1175  c->old_tile_h < c->tile_height) {
1176  c->tile_stride = FFALIGN(c->tile_width, 16) * 3;
1177  c->epic_buf_stride = FFALIGN(c->tile_width * 4, 16);
1178  aligned_height = FFALIGN(c->tile_height, 16);
1179  av_freep(&c->synth_tile);
1180  av_freep(&c->jpeg_tile);
1181  av_freep(&c->kempf_buf);
1182  av_freep(&c->kempf_flags);
1183  av_freep(&c->epic_buf_base);
1184  c->epic_buf = NULL;
1185  c->synth_tile = av_mallocz(c->tile_stride * aligned_height);
1186  c->jpeg_tile = av_mallocz(c->tile_stride * aligned_height);
1187  c->kempf_buf = av_mallocz((c->tile_width + 1) * aligned_height +
1188  AV_INPUT_BUFFER_PADDING_SIZE);
1189  c->kempf_flags = av_mallocz(c->tile_width * aligned_height);
1190  if (!c->synth_tile || !c->jpeg_tile ||
1191  !c->kempf_buf || !c->kempf_flags)
1192  return AVERROR(ENOMEM);
1193  if (c->compression == 2) {
1194  c->epic_buf_base = av_mallocz(c->epic_buf_stride * aligned_height + 4);
1195  if (!c->epic_buf_base)
1196  return AVERROR(ENOMEM);
1197  c->epic_buf = c->epic_buf_base + 4;
1198  }
1199  }
1200 
1201  return 0;
1202 }
1203 
1204 static int g2m_load_cursor(AVCodecContext *avctx, G2MContext *c,
1205  GetByteContext *gb)
1206 {
1207  int i, j, k;
1208  uint8_t *dst;
1209  uint32_t bits;
1210  uint32_t cur_size, cursor_w, cursor_h, cursor_stride;
1211  uint32_t cursor_hot_x, cursor_hot_y;
1212  int cursor_fmt, err;
1213 
1214  cur_size = bytestream2_get_be32(gb);
1215  cursor_w = bytestream2_get_byte(gb);
1216  cursor_h = bytestream2_get_byte(gb);
1217  cursor_hot_x = bytestream2_get_byte(gb);
1218  cursor_hot_y = bytestream2_get_byte(gb);
1219  cursor_fmt = bytestream2_get_byte(gb);
1220 
1221  cursor_stride = FFALIGN(cursor_w, cursor_fmt==1 ? 32 : 1) * 4;
1222 
1223  if (cursor_w < 1 || cursor_w > 256 ||
1224  cursor_h < 1 || cursor_h > 256) {
1225  av_log(avctx, AV_LOG_ERROR, "Invalid cursor dimensions %"PRIu32"x%"PRIu32"\n",
1226  cursor_w, cursor_h);
1227  return AVERROR_INVALIDDATA;
1228  }
1229  if (cursor_hot_x > cursor_w || cursor_hot_y > cursor_h) {
1230  av_log(avctx, AV_LOG_WARNING, "Invalid hotspot position %"PRIu32",%"PRIu32"\n",
1231  cursor_hot_x, cursor_hot_y);
1232  cursor_hot_x = FFMIN(cursor_hot_x, cursor_w - 1);
1233  cursor_hot_y = FFMIN(cursor_hot_y, cursor_h - 1);
1234  }
1235  if (cur_size - 9 > bytestream2_get_bytes_left(gb) ||
1236  c->cursor_w * c->cursor_h / 4 > cur_size) {
1237  av_log(avctx, AV_LOG_ERROR, "Invalid cursor data size %"PRIu32"/%u\n",
1238  cur_size, bytestream2_get_bytes_left(gb));
1239  return AVERROR_INVALIDDATA;
1240  }
1241  if (cursor_fmt != 1 && cursor_fmt != 32) {
1242  avpriv_report_missing_feature(avctx, "Cursor format %d",
1243  cursor_fmt);
1244  return AVERROR_PATCHWELCOME;
1245  }
1246 
1247  if ((err = av_reallocp(&c->cursor, cursor_stride * cursor_h)) < 0) {
1248  av_log(avctx, AV_LOG_ERROR, "Cannot allocate cursor buffer\n");
1249  return err;
1250  }
1251 
1252  c->cursor_w = cursor_w;
1253  c->cursor_h = cursor_h;
1254  c->cursor_hot_x = cursor_hot_x;
1255  c->cursor_hot_y = cursor_hot_y;
1256  c->cursor_fmt = cursor_fmt;
1257  c->cursor_stride = cursor_stride;
1258 
1259  dst = c->cursor;
1260  switch (c->cursor_fmt) {
1261  case 1: // old monochrome
1262  for (j = 0; j < c->cursor_h; j++) {
1263  for (i = 0; i < c->cursor_w; i += 32) {
1264  bits = bytestream2_get_be32(gb);
1265  for (k = 0; k < 32; k++) {
1266  dst[0] = !!(bits & 0x80000000);
1267  dst += 4;
1268  bits <<= 1;
1269  }
1270  }
1271  }
1272 
1273  dst = c->cursor;
1274  for (j = 0; j < c->cursor_h; j++) {
1275  for (i = 0; i < c->cursor_w; i += 32) {
1276  bits = bytestream2_get_be32(gb);
1277  for (k = 0; k < 32; k++) {
1278  int mask_bit = !!(bits & 0x80000000);
1279  switch (dst[0] * 2 + mask_bit) {
1280  case 0:
1281  dst[0] = 0xFF;
1282  dst[1] = 0x00;
1283  dst[2] = 0x00;
1284  dst[3] = 0x00;
1285  break;
1286  case 1:
1287  dst[0] = 0xFF;
1288  dst[1] = 0xFF;
1289  dst[2] = 0xFF;
1290  dst[3] = 0xFF;
1291  break;
1292  default:
1293  dst[0] = 0x00;
1294  dst[1] = 0x00;
1295  dst[2] = 0x00;
1296  dst[3] = 0x00;
1297  }
1298  dst += 4;
1299  bits <<= 1;
1300  }
1301  }
1302  }
1303  break;
1304  case 32: // full colour
1305  /* skip monochrome version of the cursor and decode RGBA instead */
1306  bytestream2_skip(gb, c->cursor_h * (FFALIGN(c->cursor_w, 32) >> 3));
1307  for (j = 0; j < c->cursor_h; j++) {
1308  for (i = 0; i < c->cursor_w; i++) {
1309  int val = bytestream2_get_be32(gb);
1310  *dst++ = val >> 0;
1311  *dst++ = val >> 8;
1312  *dst++ = val >> 16;
1313  *dst++ = val >> 24;
1314  }
1315  }
1316  break;
1317  default:
1318  return AVERROR_PATCHWELCOME;
1319  }
1320  return 0;
1321 }
1322 
1323 #define APPLY_ALPHA(src, new, alpha) \
1324  src = (src * (256 - alpha) + new * alpha) >> 8
1325 
1326 static void g2m_paint_cursor(G2MContext *c, uint8_t *dst, int stride)
1327 {
1328  int i, j;
1329  int x, y, w, h;
1330  const uint8_t *cursor;
1331 
1332  if (!c->cursor)
1333  return;
1334 
1335  x = c->cursor_x - c->cursor_hot_x;
1336  y = c->cursor_y - c->cursor_hot_y;
1337 
1338  cursor = c->cursor;
1339  w = c->cursor_w;
1340  h = c->cursor_h;
1341 
1342  if (x + w > c->width)
1343  w = c->width - x;
1344  if (y + h > c->height)
1345  h = c->height - y;
1346  if (x < 0) {
1347  w += x;
1348  cursor += -x * 4;
1349  } else {
1350  dst += x * 3;
1351  }
1352 
1353  if (y < 0)
1354  h += y;
1355  if (w < 0 || h < 0)
1356  return;
1357  if (y < 0) {
1358  cursor += -y * c->cursor_stride;
1359  } else {
1360  dst += y * stride;
1361  }
1362 
1363  for (j = 0; j < h; j++) {
1364  for (i = 0; i < w; i++) {
1365  uint8_t alpha = cursor[i * 4];
1366  APPLY_ALPHA(dst[i * 3 + 0], cursor[i * 4 + 1], alpha);
1367  APPLY_ALPHA(dst[i * 3 + 1], cursor[i * 4 + 2], alpha);
1368  APPLY_ALPHA(dst[i * 3 + 2], cursor[i * 4 + 3], alpha);
1369  }
1370  dst += stride;
1371  cursor += c->cursor_stride;
1372  }
1373 }
1374 
1375 static int g2m_decode_frame(AVCodecContext *avctx, AVFrame *pic,
1376  int *got_picture_ptr, AVPacket *avpkt)
1377 {
1378  const uint8_t *buf = avpkt->data;
1379  int buf_size = avpkt->size;
1380  G2MContext *c = avctx->priv_data;
1381  GetByteContext bc, tbc;
1382  int magic;
1383  int got_header = 0;
1384  uint32_t chunk_size, r_mask, g_mask, b_mask;
1385  int chunk_type, chunk_start;
1386  int i;
1387  int ret;
1388 
1389  if (buf_size < 12) {
1390  av_log(avctx, AV_LOG_ERROR,
1391  "Frame should have at least 12 bytes, got %d instead\n",
1392  buf_size);
1393  return AVERROR_INVALIDDATA;
1394  }
1395 
1396  bytestream2_init(&bc, buf, buf_size);
1397 
1398  magic = bytestream2_get_be32(&bc);
1399  if ((magic & ~0xF) != MKBETAG('G', '2', 'M', '0') ||
1400  (magic & 0xF) < 2 || (magic & 0xF) > 5) {
1401  av_log(avctx, AV_LOG_ERROR, "Wrong magic %08X\n", magic);
1402  return AVERROR_INVALIDDATA;
1403  }
1404 
1405  c->swapuv = magic == MKBETAG('G', '2', 'M', '2');
1406 
1407  while (bytestream2_get_bytes_left(&bc) > 5) {
1408  chunk_size = bytestream2_get_le32(&bc) - 1;
1409  chunk_type = bytestream2_get_byte(&bc);
1410  chunk_start = bytestream2_tell(&bc);
1411  if (chunk_size > bytestream2_get_bytes_left(&bc)) {
1412  av_log(avctx, AV_LOG_ERROR, "Invalid chunk size %"PRIu32" type %02X\n",
1413  chunk_size, chunk_type);
1414  break;
1415  }
1416  switch (chunk_type) {
1417  case DISPLAY_INFO:
1418  got_header =
1419  c->got_header = 0;
1420  if (chunk_size < 21) {
1421  av_log(avctx, AV_LOG_ERROR, "Invalid display info size %"PRIu32"\n",
1422  chunk_size);
1423  break;
1424  }
1425  c->width = bytestream2_get_be32(&bc);
1426  c->height = bytestream2_get_be32(&bc);
1427  if (c->width < 16 || c->height < 16) {
1428  av_log(avctx, AV_LOG_ERROR,
1429  "Invalid frame dimensions %dx%d\n",
1430  c->width, c->height);
1431  ret = AVERROR_INVALIDDATA;
1432  goto header_fail;
1433  }
1434  if (c->width != avctx->width || c->height != avctx->height) {
1435  ret = ff_set_dimensions(avctx, c->width, c->height);
1436  if (ret < 0)
1437  goto header_fail;
1438  }
1439  c->compression = bytestream2_get_be32(&bc);
1440  if (c->compression != 2 && c->compression != 3) {
1441  avpriv_report_missing_feature(avctx, "Compression method %d",
1442  c->compression);
1443  ret = AVERROR_PATCHWELCOME;
1444  goto header_fail;
1445  }
1446  c->tile_width = bytestream2_get_be32(&bc);
1447  c->tile_height = bytestream2_get_be32(&bc);
1448  if (c->tile_width <= 0 || c->tile_height <= 0 ||
1449  ((c->tile_width | c->tile_height) & 0xF) ||
1450  c->tile_width * (uint64_t)c->tile_height >= INT_MAX / 4 ||
1451  av_image_check_size2(c->tile_width, c->tile_height, avctx->max_pixels, avctx->pix_fmt, 0, avctx) < 0
1452  ) {
1453  av_log(avctx, AV_LOG_ERROR,
1454  "Invalid tile dimensions %dx%d\n",
1455  c->tile_width, c->tile_height);
1456  ret = AVERROR_INVALIDDATA;
1457  goto header_fail;
1458  }
1459  c->tiles_x = (c->width + c->tile_width - 1) / c->tile_width;
1460  c->tiles_y = (c->height + c->tile_height - 1) / c->tile_height;
1461  c->bpp = bytestream2_get_byte(&bc);
1462  if (c->bpp == 32) {
1463  if (bytestream2_get_bytes_left(&bc) < 16 ||
1464  (chunk_size - 21) < 16) {
1465  av_log(avctx, AV_LOG_ERROR,
1466  "Display info: missing bitmasks!\n");
1467  ret = AVERROR_INVALIDDATA;
1468  goto header_fail;
1469  }
1470  r_mask = bytestream2_get_be32(&bc);
1471  g_mask = bytestream2_get_be32(&bc);
1472  b_mask = bytestream2_get_be32(&bc);
1473  if (r_mask != 0xFF0000 || g_mask != 0xFF00 || b_mask != 0xFF) {
1474  avpriv_report_missing_feature(avctx,
1475  "Bitmasks: R=%"PRIX32", G=%"PRIX32", B=%"PRIX32,
1476  r_mask, g_mask, b_mask);
1477  ret = AVERROR_PATCHWELCOME;
1478  goto header_fail;
1479  }
1480  } else {
1481  avpriv_request_sample(avctx, "bpp=%d", c->bpp);
1482  ret = AVERROR_PATCHWELCOME;
1483  goto header_fail;
1484  }
1485  if (g2m_init_buffers(c)) {
1486  ret = AVERROR(ENOMEM);
1487  goto header_fail;
1488  }
1489  got_header = 1;
1490  break;
1491  case TILE_DATA:
1492  if (!c->tiles_x || !c->tiles_y) {
1493  av_log(avctx, AV_LOG_WARNING,
1494  "No display info - skipping tile\n");
1495  break;
1496  }
1497  if (chunk_size < 2) {
1498  av_log(avctx, AV_LOG_ERROR, "Invalid tile data size %"PRIu32"\n",
1499  chunk_size);
1500  break;
1501  }
1502  c->tile_x = bytestream2_get_byte(&bc);
1503  c->tile_y = bytestream2_get_byte(&bc);
1504  if (c->tile_x >= c->tiles_x || c->tile_y >= c->tiles_y) {
1505  av_log(avctx, AV_LOG_ERROR,
1506  "Invalid tile pos %d,%d (in %dx%d grid)\n",
1507  c->tile_x, c->tile_y, c->tiles_x, c->tiles_y);
1508  break;
1509  }
1510  ret = 0;
1511  switch (c->compression) {
1512  case COMPR_EPIC_J_B:
1513  ret = epic_jb_decode_tile(c, c->tile_x, c->tile_y,
1514  buf + bytestream2_tell(&bc),
1515  chunk_size - 2, avctx);
1516  break;
1517  case COMPR_KEMPF_J_B:
1518  ret = kempf_decode_tile(c, c->tile_x, c->tile_y,
1519  buf + bytestream2_tell(&bc),
1520  chunk_size - 2);
1521  break;
1522  }
1523  if (ret && c->framebuf)
1524  av_log(avctx, AV_LOG_ERROR, "Error decoding tile %d,%d\n",
1525  c->tile_x, c->tile_y);
1526  break;
1527  case CURSOR_POS:
1528  if (chunk_size < 5) {
1529  av_log(avctx, AV_LOG_ERROR, "Invalid cursor pos size %"PRIu32"\n",
1530  chunk_size);
1531  break;
1532  }
1533  c->cursor_x = bytestream2_get_be16(&bc);
1534  c->cursor_y = bytestream2_get_be16(&bc);
1535  break;
1536  case CURSOR_SHAPE:
1537  if (chunk_size < 8) {
1538  av_log(avctx, AV_LOG_ERROR, "Invalid cursor data size %"PRIu32"\n",
1539  chunk_size);
1540  break;
1541  }
1542  bytestream2_init(&tbc, buf + bytestream2_tell(&bc),
1543  chunk_size - 4);
1544  g2m_load_cursor(avctx, c, &tbc);
1545  break;
1546  case CHUNK_CC:
1547  case CHUNK_CD:
1548  break;
1549  default:
1550  av_log(avctx, AV_LOG_WARNING, "Skipping chunk type %02d\n",
1551  chunk_type);
1552  }
1553 
1554  /* navigate to next chunk */
1555  bytestream2_skip(&bc, chunk_start + chunk_size - bytestream2_tell(&bc));
1556  }
1557  if (got_header)
1558  c->got_header = 1;
1559 
1560  if (c->width && c->height && c->framebuf) {
1561  if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
1562  return ret;
1563 
1564  pic->key_frame = got_header;
1565  pic->pict_type = got_header ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1566 
1567  for (i = 0; i < avctx->height; i++)
1568  memcpy(pic->data[0] + i * pic->linesize[0],
1569  c->framebuf + i * c->framebuf_stride,
1570  c->width * 3);
1571  g2m_paint_cursor(c, pic->data[0], pic->linesize[0]);
1572 
1573  *got_picture_ptr = 1;
1574  }
1575 
1576  return buf_size;
1577 
1578 header_fail:
1579  c->width =
1580  c->height = 0;
1581  c->tiles_x =
1582  c->tiles_y = 0;
1583  c->tile_width =
1584  c->tile_height = 0;
1585  return ret;
1586 }
1587 
1588 static av_cold int g2m_decode_init(AVCodecContext *avctx)
1589 {
1590  G2MContext *const c = avctx->priv_data;
1591  int ret;
1592 
1593  if ((ret = jpg_init(avctx, &c->jc)) != 0) {
1594  av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
1595  return AVERROR(ENOMEM);
1596  }
1597 
1598  avctx->pix_fmt = AV_PIX_FMT_RGB24;
1599 
1600  // store original sizes and check against those if resize happens
1601  c->orig_width = avctx->width;
1602  c->orig_height = avctx->height;
1603 
1604  return 0;
1605 }
1606 
1607 static av_cold int g2m_decode_end(AVCodecContext *avctx)
1608 {
1609  G2MContext *const c = avctx->priv_data;
1610 
1611  jpg_free_context(&c->jc);
1612 
1613  av_freep(&c->epic_buf_base);
1614  c->epic_buf = NULL;
1615  av_freep(&c->kempf_buf);
1616  av_freep(&c->kempf_flags);
1617  av_freep(&c->synth_tile);
1618  av_freep(&c->jpeg_tile);
1619  av_freep(&c->cursor);
1620  av_freep(&c->framebuf);
1621 
1622  return 0;
1623 }
1624 
1625 const FFCodec ff_g2m_decoder = {
1626  .p.name = "g2m",
1627  .p.long_name = NULL_IF_CONFIG_SMALL("Go2Meeting"),
1628  .p.type = AVMEDIA_TYPE_VIDEO,
1629  .p.id = AV_CODEC_ID_G2M,
1630  .priv_data_size = sizeof(G2MContext),
1631  .init = g2m_decode_init,
1632  .close = g2m_decode_end,
1633  FF_CODEC_DECODE_CB(g2m_decode_frame),
1634  .p.capabilities = AV_CODEC_CAP_DR1,
1635  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1636 };
EPIC_PIX_STACK_SIZE
#define EPIC_PIX_STACK_SIZE
Definition: g2meet.c:47
COMPR_KEMPF_J_B
@ COMPR_KEMPF_J_B
Definition: g2meet.c:61
ff_els_decode_unsigned
unsigned ff_els_decode_unsigned(ElsDecCtx *ctx, ElsUnsignedRung *ur)
Definition: elsdec.c:352
ePICPixListElem::pixel
uint32_t pixel
Definition: g2meet.c:88
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:291
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ePICContext::els_ctx
ElsDecCtx els_ctx
Definition: g2meet.c:105
jpegtables.h
mjpeg.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:39
chunk_start
static int chunk_start(AVFormatContext *s)
Definition: webm_chunk.c:164
blockdsp.h
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
G2MContext::orig_height
int orig_height
Definition: g2meet.c:142
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:117
G2MContext::old_tile_w
int old_tile_w
Definition: g2meet.c:152
EPIC_HASH_SIZE
#define EPIC_HASH_SIZE
Definition: g2meet.c:97
jpg_decode_block
static int jpg_decode_block(JPGContext *c, GetBitContext *gb, int plane, int16_t *block)
Definition: g2meet.c:222
mjpegdec.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
w
uint8_t w
Definition: llviddspenc.c:38
R
#define R
Definition: huffyuvdsp.h:34
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
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
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:112
G2MContext::jpeg_tile
uint8_t * jpeg_tile
Definition: g2meet.c:151
ePICPixListElem::rung
uint8_t rung
Definition: g2meet.c:89
B_shift
#define B_shift
Definition: g2meet.c:374
ff_mjpeg_bits_ac_chrominance
const uint8_t ff_mjpeg_bits_ac_chrominance[]
Definition: jpegtabs.h:66
BlockDSPContext
Definition: blockdsp.h:34
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:240
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:111
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
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:1588
init
static int init
Definition: av_tx.c:47
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:379
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:116
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:797
U
#define U(x)
Definition: vp56_arith.h:37
av_ceil_log2
#define av_ceil_log2
Definition: common.h:92
ePICContext::prev_row_rung
uint8_t prev_row_rung[14]
Definition: g2meet.c:114
GetBitContext
Definition: get_bits.h:61
TOSIGNED
#define TOSIGNED(val)
Definition: g2meet.c:491
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:417
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:1326
av_image_check_size2
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:289
JPGContext::prev_dc
int prev_dc[3]
Definition: g2meet.c:128
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
ePICPixListElem
Definition: g2meet.c:86
G2MContext::version
int version
Definition: g2meet.c:138
mask
static const uint16_t mask[17]
Definition: lzw.c:38
G2MContext::tiles_y
int tiles_y
Definition: g2meet.c:144
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
intreadwrite.h
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:141
ePICPixHash
Definition: g2meet.c:98
bucket
static FFFrameBucket * bucket(FFFrameQueue *fq, size_t idx)
Definition: framequeue.c:25
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:48
G2MContext::cursor
uint8_t * cursor
Definition: g2meet.c:157
get_bits.h
APPLY_ALPHA
#define APPLY_ALPHA(src, new, alpha)
Definition: g2meet.c:1323
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1908
CHUNK_CC
@ CHUNK_CC
Definition: g2meet.c:55
epic_decode_from_cache
static int epic_decode_from_cache(ePICContext *dc, uint32_t W, uint32_t *pPix)
Definition: g2meet.c:768
key
const char * key
Definition: hwcontext_opencl.c:174
g2m_decode_end
static av_cold int g2m_decode_end(AVCodecContext *avctx)
Definition: g2meet.c:1607
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:106
G2MContext::kempf_buf
uint8_t * kempf_buf
Definition: g2meet.c:155
TILE_DATA
@ TILE_DATA
Definition: g2meet.c:52
epic_jb_decode_tile
static int epic_jb_decode_tile(G2MContext *c, int tile_x, int tile_y, const uint8_t *src, size_t src_size, AVCodecContext *avctx)
Definition: g2meet.c:863
COMPR_EPIC_J_B
@ COMPR_EPIC_J_B
Definition: g2meet.c:60
NULL
#define NULL
Definition: coverity.c:32
CURSOR_SHAPE
@ CURSOR_SHAPE
Definition: g2meet.c:54
ePICPixHash::bucket
ePICPixHashElem * bucket[EPIC_HASH_SIZE]
Definition: g2meet.c:99
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:205
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
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:406
ff_g2m_decoder
const FFCodec ff_g2m_decoder
Definition: g2meet.c:1625
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:274
Compression
Compression
Definition: g2meet.c:59
FF_PTR_ADD
#define FF_PTR_ADD(ptr, off)
Definition: internal.h:100
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:48
CURSOR_POS
@ CURSOR_POS
Definition: g2meet.c:53
g2m_load_cursor
static int g2m_load_cursor(AVCodecContext *avctx, G2MContext *c, GetByteContext *gb)
Definition: g2meet.c:1204
ff_mjpeg_val_ac_chrominance
const uint8_t ff_mjpeg_val_ac_chrominance[]
Definition: jpegtabs.h:69
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
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:1375
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
G2MContext::epic_buf_stride
int epic_buf_stride
Definition: g2meet.c: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:422
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1403
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:375
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
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
codec_internal.h
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:373
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: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
ff_mjpeg_bits_dc_luminance
const uint8_t ff_mjpeg_bits_dc_luminance[]
Definition: jpegtabs.h:32
height
#define height
G2MContext::cursor_y
int cursor_y
Definition: g2meet.c:160
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:321
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: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
flag
#define flag(name)
Definition: cbs_av1.c:553
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
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:1049
JPGContext::buf
uint8_t * buf
Definition: g2meet.c:131
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
djb2_hash
static int djb2_hash(uint32_t key)
Definition: g2meet.c:377
G2MContext::height
int height
Definition: g2meet.c:141
G2MContext::cursor_w
int cursor_w
Definition: g2meet.c:160
ff_init_scantable
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:30
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
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: codec_internal.h:31
G2MContext::old_width
int old_width
Definition: g2meet.c:149
G2MContext::cursor_x
int cursor_x
Definition: g2meet.c:160
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:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
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:64
AVCodecContext::height
int height
Definition: avcodec.h:562
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
G2MContext::tile_x
int tile_x
Definition: g2meet.c:144
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: vlc.c:375
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
W
@ W
Definition: vf_addroi.c:26
mid_pred
#define mid_pred
Definition: mathops.h:97
G
#define G
Definition: huffyuvdsp.h:33
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:141
pos
unsigned int pos
Definition: spdifenc.c:412
IDCTDSPContext
Definition: idctdsp.h:53
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
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:195
B
#define B
Definition: huffyuvdsp.h:32
G2MContext::ec
ePICContext ec
Definition: g2meet.c:135
AVCodecContext
main external API structure.
Definition: avcodec.h:389
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: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:134
ePICContext::runlen_zeroes
uint8_t runlen_zeroes[14]
Definition: g2meet.c:115
VLC
Definition: vlc.h:31
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: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:51
av_clip_uint8
#define av_clip_uint8
Definition: common.h:101
ePICContext
Definition: g2meet.c:104
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: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:56
LOAD_NEIGHBOURS
#define LOAD_NEIGHBOURS(x)
Definition: g2meet.c:352
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:90
chroma_quant
static const uint8_t chroma_quant[64]
Definition: g2meet.c:75
G2MContext::tile_y
int tile_y
Definition: g2meet.c:144
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1037
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
ScanTable
Scantable.
Definition: idctdsp.h:31
AV_CODEC_ID_G2M
@ AV_CODEC_ID_G2M
Definition: codec_id.h:221
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
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:416
AVPacket
This structure stores compressed data.
Definition: packet.h:351
G2MContext::got_header
int got_header
Definition: g2meet.c:146
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:562
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:370
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
JPGContext::scantable
ScanTable scantable
Definition: g2meet.c:125
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ChunkType
ChunkType
Definition: g2meet.c:50
h
h
Definition: vp9dsp_template.c:2038
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:59
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
G2MContext::old_height
int old_height
Definition: g2meet.c:149
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 Wed Aug 24 2022 21:41:26 for FFmpeg by   doxygen 1.8.17