LCOV - code coverage report
Current view: top level - libavcodec - g2meet.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 776 900 86.2 %
Date: 2017-12-12 11:08:38 Functions: 33 33 100.0 %

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

Generated by: LCOV version 1.13