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