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