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

Generated by: LCOV version 1.13