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