2 * Go2Webinar / Go2Meeting decoder
3 * Copyright (c) 2012 Konstantin Shishkov
4 * Copyright (c) 2013 Maxim Poliakovski
6 * This file is part of Libav.
8 * Libav 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.
13 * Libav 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.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * Go2Webinar / Go2Meeting decoder
31 #include "libavutil/intreadwrite.h"
35 #include "bytestream.h"
40 #include "jpegtables.h"
43 #define EPIC_PIX_STACK_SIZE 1024
44 #define EPIC_PIX_STACK_MAX (EPIC_PIX_STACK_SIZE - 1)
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
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,
82 typedef struct ePICPixListElem
{
83 struct ePICPixListElem
*next
;
88 typedef struct ePICPixHashElem
{
90 struct ePICPixListElem
*list
;
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
];
100 typedef struct ePICContext
{
103 ElsUnsignedRung unsigned_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];
114 uint32_t stack
[EPIC_PIX_STACK_SIZE
];
118 typedef struct JPGContext
{
119 BlockDSPContext bdsp
;
123 VLC dc_vlc
[2], ac_vlc
[2];
125 DECLARE_ALIGNED(16, int16_t, block
)[6][64];
130 typedef struct G2MContext
{
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
;
145 int framebuf_stride
, old_width
, old_height
;
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
;
151 uint8_t *kempf_buf
, *kempf_flags
;
156 int cursor_w
, cursor_h
, cursor_x
, cursor_y
;
157 int cursor_hot_x
, cursor_hot_y
;
160 static av_cold
int build_vlc(VLC
*vlc
, const uint8_t *bits_table
,
161 const uint8_t *val_table
, int nb_codes
,
164 uint8_t huff_size
[256] = { 0 };
165 uint16_t huff_code
[256];
166 uint16_t huff_sym
[256];
169 ff_mjpeg_build_huffman_codes(huff_size
, huff_code
, bits_table
, val_table
);
171 for (i
= 0; i
< 256; i
++)
172 huff_sym
[i
] = i
+ 16 * is_ac
;
175 huff_sym
[0] = 16 * 256;
177 return ff_init_vlc_sparse(vlc
, 9, nb_codes
, huff_size
, 1, 1,
178 huff_code
, 2, 2, huff_sym
, 2, 2, 0);
181 static av_cold
int jpg_init(AVCodecContext
*avctx
, JPGContext
*c
)
185 ret
= build_vlc(&c
->dc_vlc
[0], avpriv_mjpeg_bits_dc_luminance
,
186 avpriv_mjpeg_val_dc
, 12, 0);
189 ret
= build_vlc(&c
->dc_vlc
[1], avpriv_mjpeg_bits_dc_chrominance
,
190 avpriv_mjpeg_val_dc
, 12, 0);
193 ret
= build_vlc(&c
->ac_vlc
[0], avpriv_mjpeg_bits_ac_luminance
,
194 avpriv_mjpeg_val_ac_luminance
, 251, 1);
197 ret
= build_vlc(&c
->ac_vlc
[1], avpriv_mjpeg_bits_ac_chrominance
,
198 avpriv_mjpeg_val_ac_chrominance
, 251, 1);
202 ff_blockdsp_init(&c
->bdsp
, avctx
);
203 ff_idctdsp_init(&c
->idsp
, avctx
);
204 ff_init_scantable(c
->idsp
.idct_permutation
, &c
->scantable
,
210 static av_cold
void jpg_free_context(JPGContext
*ctx
)
214 for (i
= 0; i
< 2; i
++) {
215 ff_free_vlc(&ctx
->dc_vlc
[i
]);
216 ff_free_vlc(&ctx
->ac_vlc
[i
]);
222 static void jpg_unescape(const uint8_t *src
, int src_size
,
223 uint8_t *dst
, int *dst_size
)
225 const uint8_t *src_end
= src
+ src_size
;
226 uint8_t *dst_start
= dst
;
228 while (src
< src_end
) {
233 if (x
== 0xFF && !*src
)
236 *dst_size
= dst
- dst_start
;
239 static int jpg_decode_block(JPGContext
*c
, GetBitContext
*gb
,
240 int plane
, int16_t *block
)
243 const int is_chroma
= !!plane
;
244 const uint8_t *qmat
= is_chroma ? chroma_quant
: luma_quant
;
246 c
->bdsp
.clear_block(block
);
247 dc
= get_vlc2(gb
, c
->dc_vlc
[is_chroma
].table
, 9, 3);
249 return AVERROR_INVALIDDATA
;
251 dc
= get_xbits(gb
, dc
);
252 dc
= dc
* qmat
[0] + c
->prev_dc
[plane
];
254 c
->prev_dc
[plane
] = dc
;
258 val
= get_vlc2(gb
, c
->ac_vlc
[is_chroma
].table
, 9, 3);
260 return AVERROR_INVALIDDATA
;
264 return val ? AVERROR_INVALIDDATA
: 0;
268 val
= get_xbits(gb
, nbits
);
269 val
*= qmat
[ff_zigzag_direct
[pos
]];
270 block
[c
->scantable
.permutated
[pos
]] = val
;
276 static inline void yuv2rgb(uint8_t *out
, int ridx
, int Y
, int U
, int V
)
278 out
[ridx
] = av_clip_uint8(Y
+ (91881 * V
+ 32768 >> 16));
279 out
[1] = av_clip_uint8(Y
+ (-22554 * U
- 46802 * V
+ 32768 >> 16));
280 out
[2 - ridx
] = av_clip_uint8(Y
+ (116130 * U
+ 32768 >> 16));
283 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
,
290 int mb_w
, mb_h
, mb_x
, mb_y
, i
, j
;
294 const int ridx
= swapuv ?
2 : 0;
296 if ((ret
= av_reallocp(&c
->buf
,
297 src_size
+ AV_INPUT_BUFFER_PADDING_SIZE
)) < 0)
299 jpg_unescape(src
, src_size
, c
->buf
, &unesc_size
);
300 memset(c
->buf
+ unesc_size
, 0, AV_INPUT_BUFFER_PADDING_SIZE
);
301 init_get_bits(&gb
, c
->buf
, unesc_size
* 8);
303 width
= FFALIGN(width
, 16);
305 mb_h
= (height
+ 15) >> 4;
308 num_mbs
= mb_w
* mb_h
* 4;
310 for (i
= 0; i
< 3; i
++)
311 c
->prev_dc
[i
] = 1024;
314 c
->bdsp
.clear_blocks(c
->block
[0]);
315 for (mb_y
= 0; mb_y
< mb_h
; mb_y
++) {
316 for (mb_x
= 0; mb_x
< mb_w
; mb_x
++) {
317 if (mask
&& !mask
[mb_x
* 2] && !mask
[mb_x
* 2 + 1] &&
318 !mask
[mb_x
* 2 + mask_stride
] &&
319 !mask
[mb_x
* 2 + 1 + mask_stride
]) {
323 for (j
= 0; j
< 2; j
++) {
324 for (i
= 0; i
< 2; i
++) {
325 if (mask
&& !mask
[mb_x
* 2 + i
+ j
* mask_stride
])
328 if ((ret
= jpg_decode_block(c
, &gb
, 0,
329 c
->block
[i
+ j
* 2])) != 0)
331 c
->idsp
.idct(c
->block
[i
+ j
* 2]);
334 for (i
= 1; i
< 3; i
++) {
335 if ((ret
= jpg_decode_block(c
, &gb
, i
, c
->block
[i
+ 3])) != 0)
337 c
->idsp
.idct(c
->block
[i
+ 3]);
340 for (j
= 0; j
< 16; j
++) {
341 uint8_t *out
= dst
+ bx
* 3 + (by
+ j
) * dst_stride
;
342 for (i
= 0; i
< 16; i
++) {
345 Y
= c
->block
[(j
>> 3) * 2 + (i
>> 3)][(i
& 7) + (j
& 7) * 8];
346 U
= c
->block
[4][(i
>> 1) + (j
>> 1) * 8] - 128;
347 V
= c
->block
[5][(i
>> 1) + (j
>> 1) * 8] - 128;
348 yuv2rgb(out
+ i
* 3, ridx
, Y
, U
, V
);
359 mask
+= mask_stride
* 2;
365 #define LOAD_NEIGHBOURS(x) \
366 W = curr_row[(x) - 1]; \
367 N = above_row[(x)]; \
368 WW = curr_row[(x) - 2]; \
369 NW = above_row[(x) - 1]; \
370 NE = above_row[(x) + 1]; \
371 NN = above2_row[(x)]; \
372 NNW = above2_row[(x) - 1]; \
373 NWW = above_row[(x) - 2]; \
374 NNE = above2_row[(x) + 1]
376 #define UPDATE_NEIGHBOURS(x) \
382 NE = above_row[(x) + 1]; \
383 NNE = above2_row[(x) + 1]
389 /* improved djb2 hash from http://www.cse.yorku.ca/~oz/hash.html */
390 static int djb2_hash(uint32_t key
)
394 h
= (h
* 33) ^ ((key
>> 24) & 0xFF); // xxx: probably not needed at all
395 h
= (h
* 33) ^ ((key
>> 16) & 0xFF);
396 h
= (h
* 33) ^ ((key
>> 8) & 0xFF);
397 h
= (h
* 33) ^ (key
& 0xFF);
399 return h
& (EPIC_HASH_SIZE
- 1);
402 static void epic_hash_init(ePICPixHash
*hash
)
404 memset(hash
, 0, sizeof(*hash
));
407 static ePICPixHashElem
*epic_hash_find(const ePICPixHash
*hash
, uint32_t key
)
409 int i
, idx
= djb2_hash(key
);
410 ePICPixHashElem
*bucket
= hash
->bucket
[idx
];
412 for (i
= 0; i
< hash
->bucket_fill
[idx
]; i
++)
413 if (bucket
[i
].pix_id
== key
)
419 static ePICPixHashElem
*epic_hash_add(ePICPixHash
*hash
, uint32_t key
)
421 ePICPixHashElem
*bucket
, *ret
;
422 int idx
= djb2_hash(key
);
424 if (hash
->bucket_size
[idx
] > INT_MAX
/ sizeof(**hash
->bucket
))
427 if (!(hash
->bucket_fill
[idx
] < hash
->bucket_size
[idx
])) {
428 int new_size
= hash
->bucket_size
[idx
] + 16;
429 bucket
= av_realloc(hash
->bucket
[idx
], new_size
* sizeof(*bucket
));
432 hash
->bucket
[idx
] = bucket
;
433 hash
->bucket_size
[idx
] = new_size
;
436 ret
= &hash
->bucket
[idx
][hash
->bucket_fill
[idx
]++];
437 memset(ret
, 0, sizeof(*ret
));
442 static int epic_add_pixel_to_cache(ePICPixHash
*hash
, uint32_t key
, uint32_t pix
)
444 ePICPixListElem
*new_elem
;
445 ePICPixHashElem
*hash_elem
= epic_hash_find(hash
, key
);
448 if (!(hash_elem
= epic_hash_add(hash
, key
)))
449 return AVERROR(ENOMEM
);
452 new_elem
= av_mallocz(sizeof(*new_elem
));
454 return AVERROR(ENOMEM
);
456 new_elem
->pixel
= pix
;
457 new_elem
->next
= hash_elem
->list
;
458 hash_elem
->list
= new_elem
;
463 static inline int epic_cache_entries_for_pixel(const ePICPixHash
*hash
,
466 ePICPixHashElem
*hash_elem
= epic_hash_find(hash
, pix
);
468 if (hash_elem
!= NULL
&& hash_elem
->list
!= NULL
)
474 static void epic_free_pixel_cache(ePICPixHash
*hash
)
478 for (i
= 0; i
< EPIC_HASH_SIZE
; i
++) {
479 for (j
= 0; j
< hash
->bucket_fill
[i
]; j
++) {
480 ePICPixListElem
*list_elem
= hash
->bucket
[i
][j
].list
;
482 ePICPixListElem
*tmp
= list_elem
->next
;
487 av_freep(&hash
->bucket
[i
]);
488 hash
->bucket_size
[i
] =
489 hash
->bucket_fill
[i
] = 0;
493 static inline int is_pixel_on_stack(const ePICContext
*dc
, uint32_t pix
)
497 for (i
= 0; i
< dc
->stack_pos
; i
++)
498 if (dc
->stack
[i
] == pix
)
501 return i
!= dc
->stack_pos
;
504 #define TOSIGNED(val) (((val) >> 1) ^ -((val) & 1))
506 static inline int epic_decode_component_pred(ePICContext
*dc
,
507 int N
, int W
, int NW
)
509 unsigned delta
= ff_els_decode_unsigned(&dc
->els_ctx
, &dc
->unsigned_rung
);
510 return mid_pred(N
, N
+ W
- NW
, W
) - TOSIGNED(delta
);
513 static uint32_t epic_decode_pixel_pred(ePICContext
*dc
, int x
, int y
,
514 const uint32_t *curr_row
,
515 const uint32_t *above_row
)
517 uint32_t N
, W
, NW
, pred
;
519 int GN
, GW
, GNW
, R
, G
, B
;
524 NW
= above_row
[x
- 1];
526 GN
= (N
>> G_shift
) & 0xFF;
527 GW
= (W
>> G_shift
) & 0xFF;
528 GNW
= (NW
>> G_shift
) & 0xFF;
530 G
= epic_decode_component_pred(dc
, GN
, GW
, GNW
);
532 R
= G
+ epic_decode_component_pred(dc
,
533 ((N
>> R_shift
) & 0xFF) - GN
,
534 ((W
>> R_shift
) & 0xFF) - GW
,
535 ((NW
>> R_shift
) & 0xFF) - GNW
);
537 B
= G
+ epic_decode_component_pred(dc
,
538 ((N
>> B_shift
) & 0xFF) - GN
,
539 ((W
>> B_shift
) & 0xFF) - GW
,
540 ((NW
>> B_shift
) & 0xFF) - GNW
);
543 pred
= curr_row
[x
- 1];
547 delta
= ff_els_decode_unsigned(&dc
->els_ctx
, &dc
->unsigned_rung
);
548 R
= ((pred
>> R_shift
) & 0xFF) - TOSIGNED(delta
);
550 delta
= ff_els_decode_unsigned(&dc
->els_ctx
, &dc
->unsigned_rung
);
551 G
= ((pred
>> G_shift
) & 0xFF) - TOSIGNED(delta
);
553 delta
= ff_els_decode_unsigned(&dc
->els_ctx
, &dc
->unsigned_rung
);
554 B
= ((pred
>> B_shift
) & 0xFF) - TOSIGNED(delta
);
557 return (R
<< R_shift
) | (G
<< G_shift
) | (B
<< B_shift
);
560 static int epic_predict_pixel(ePICContext
*dc
, uint8_t *rung
,
561 uint32_t *pPix
, uint32_t pix
)
563 if (!ff_els_decode_bit(&dc
->els_ctx
, rung
)) {
567 dc
->stack
[dc
->stack_pos
++ & EPIC_PIX_STACK_MAX
] = pix
;
571 static int epic_handle_edges(ePICContext
*dc
, int x
, int y
,
572 const uint32_t *curr_row
,
573 const uint32_t *above_row
, uint32_t *pPix
)
577 if (!x
&& !y
) { /* special case: top-left pixel */
578 /* the top-left pixel is coded independently with 3 unsigned numbers */
579 *pPix
= (ff_els_decode_unsigned(&dc
->els_ctx
, &dc
->unsigned_rung
) << R_shift
) |
580 (ff_els_decode_unsigned(&dc
->els_ctx
, &dc
->unsigned_rung
) << G_shift
) |
581 (ff_els_decode_unsigned(&dc
->els_ctx
, &dc
->unsigned_rung
) << B_shift
);
585 if (x
) { /* predict from W first */
586 pix
= curr_row
[x
- 1];
587 if (epic_predict_pixel(dc
, &dc
->W_flag_rung
, pPix
, pix
))
591 if (y
) { /* then try to predict from N */
593 if (!dc
->stack_pos
|| dc
->stack
[0] != pix
) {
594 if (epic_predict_pixel(dc
, &dc
->N_flag_rung
, pPix
, pix
))
602 static int epic_decode_run_length(ePICContext
*dc
, int x
, int y
, int tile_width
,
603 const uint32_t *curr_row
,
604 const uint32_t *above_row
,
605 const uint32_t *above2_row
,
606 uint32_t *pPix
, int *pRun
)
608 int idx
, got_pixel
= 0, WWneW
, old_WWneW
= 0;
609 uint32_t W
, WW
, N
, NN
, NW
, NE
, NWW
, NNW
, NNE
;
615 if (dc
->next_run_pos
== x
) {
616 /* can't reuse W for the new pixel in this case */
619 idx
= (WW
!= W
) << 7 |
627 WWneW
= ff_els_decode_bit(&dc
->els_ctx
, &dc
->W_ctx_rung
[idx
]);
631 dc
->stack
[dc
->stack_pos
++ & EPIC_PIX_STACK_MAX
] = W
;
639 if (got_pixel
) // pixel value already known (derived from either W or N)
641 else { // pixel value is unknown and will be decoded later
642 NWneW
= *pRun ? NWneW
: NW
!= W
;
644 /* TODO: RFC this mess! */
645 switch (((NW
!= N
) << 2) | (NWneW
<< 1) | WWneW
) {
647 break; // do nothing here
652 if (!is_pixel_on_stack(dc
, N
)) {
654 (*pRun ? old_WWneW
: WW
!= W
) << 7 |
662 if (!ff_els_decode_bit(&dc
->els_ctx
, &dc
->N_ctx_rung
[idx
])) {
673 if (!is_pixel_on_stack(dc
, N
))
674 dc
->stack
[dc
->stack_pos
++ & EPIC_PIX_STACK_MAX
] = N
;
679 if (x
+ *pRun
>= tile_width
- 1)
682 UPDATE_NEIGHBOURS(x
+ *pRun
);
684 if (!NWneW
&& NW
== N
&& N
== NE
) {
686 int start_pos
= x
+ *pRun
;
688 /* scan for a run of pix in the line above */
689 uint32_t pix
= above_row
[start_pos
+ 1];
690 for (pos
= start_pos
+ 2; pos
< tile_width
; pos
++)
691 if (!(above_row
[pos
] == pix
))
693 run
= pos
- start_pos
- 1;
694 idx
= av_ceil_log2(run
);
695 if (ff_els_decode_bit(&dc
->els_ctx
, &dc
->prev_row_rung
[idx
]))
699 /* run-length is coded as plain binary number of idx - 1 bits */
700 for (pos
= idx
- 1, rle
= 0, flag
= 0; pos
>= 0; pos
--) {
701 if ((1 << pos
) + rle
< run
&&
702 ff_els_decode_bit(&dc
->els_ctx
,
703 flag ?
&dc
->runlen_one
704 : &dc
->runlen_zeroes
[pos
])) {
710 break; // return immediately
712 if (x
+ *pRun
>= tile_width
- 1)
715 LOAD_NEIGHBOURS(x
+ *pRun
);
728 WWneW
= ff_els_decode_bit(&dc
->els_ctx
, &dc
->W_ctx_rung
[idx
]);
731 dc
->next_run_pos
= x
+ *pRun
;
735 static int epic_predict_pixel2(ePICContext
*dc
, uint8_t *rung
,
736 uint32_t *pPix
, uint32_t pix
)
738 if (ff_els_decode_bit(&dc
->els_ctx
, rung
)) {
742 dc
->stack
[dc
->stack_pos
++ & EPIC_PIX_STACK_MAX
] = pix
;
746 static int epic_predict_from_NW_NE(ePICContext
*dc
, int x
, int y
, int run
,
747 int tile_width
, const uint32_t *curr_row
,
748 const uint32_t *above_row
, uint32_t *pPix
)
752 /* try to reuse the NW pixel first */
754 uint32_t NW
= above_row
[x
- 1];
755 if (NW
!= curr_row
[x
- 1] && NW
!= above_row
[x
] && !is_pixel_on_stack(dc
, NW
)) {
756 if (epic_predict_pixel2(dc
, &dc
->nw_pred_rung
[NW
& 0xFF], pPix
, NW
))
761 /* try to reuse the NE[x + run, y] pixel */
763 if (pos
< tile_width
- 1 && y
) {
764 uint32_t NE
= above_row
[pos
+ 1];
765 if (NE
!= above_row
[pos
] && !is_pixel_on_stack(dc
, NE
)) {
766 if (epic_predict_pixel2(dc
, &dc
->ne_pred_rung
[NE
& 0xFF], pPix
, NE
))
774 static int epic_decode_from_cache(ePICContext
*dc
, uint32_t W
, uint32_t *pPix
)
776 ePICPixListElem
*list
, *prev
= NULL
;
777 ePICPixHashElem
*hash_elem
= epic_hash_find(&dc
->hash
, W
);
779 if (!hash_elem
|| !hash_elem
->list
)
782 list
= hash_elem
->list
;
784 if (!is_pixel_on_stack(dc
, list
->pixel
)) {
785 if (ff_els_decode_bit(&dc
->els_ctx
, &list
->rung
)) {
787 if (list
!= hash_elem
->list
) {
788 prev
->next
= list
->next
;
789 list
->next
= hash_elem
->list
;
790 hash_elem
->list
= list
;
794 dc
->stack
[dc
->stack_pos
++ & EPIC_PIX_STACK_MAX
] = list
->pixel
;
803 static int epic_decode_tile(ePICContext
*dc
, uint8_t *out
, int tile_height
,
804 int tile_width
, int stride
)
808 uint32_t *curr_row
= NULL
, *above_row
= NULL
, *above2_row
;
810 for (y
= 0; y
< tile_height
; y
++, out
+= stride
) {
811 above2_row
= above_row
;
812 above_row
= curr_row
;
813 curr_row
= (uint32_t *) out
;
815 for (x
= 0, dc
->next_run_pos
= 0; x
< tile_width
;) {
817 return AVERROR_INVALIDDATA
; // bail out in the case of ELS overflow
819 pix
= curr_row
[x
- 1]; // get W pixel
821 if (y
>= 1 && x
>= 2 &&
822 pix
!= curr_row
[x
- 2] && pix
!= above_row
[x
- 1] &&
823 pix
!= above_row
[x
- 2] && pix
!= above_row
[x
] &&
824 !epic_cache_entries_for_pixel(&dc
->hash
, pix
)) {
825 curr_row
[x
] = epic_decode_pixel_pred(dc
, x
, y
, curr_row
, above_row
);
829 dc
->stack_pos
= 0; // empty stack
831 if (y
< 2 || x
< 2 || x
== tile_width
- 1) {
833 got_pixel
= epic_handle_edges(dc
, x
, y
, curr_row
, above_row
, &pix
);
835 got_pixel
= epic_decode_run_length(dc
, x
, y
, tile_width
,
837 above2_row
, &pix
, &run
);
839 if (!got_pixel
&& !epic_predict_from_NW_NE(dc
, x
, y
, run
,
840 tile_width
, curr_row
,
842 uint32_t ref_pix
= curr_row
[x
- 1];
843 if (!x
|| !epic_decode_from_cache(dc
, ref_pix
, &pix
)) {
844 pix
= epic_decode_pixel_pred(dc
, x
, y
, curr_row
, above_row
);
846 int ret
= epic_add_pixel_to_cache(&dc
->hash
,
854 for (; run
> 0; x
++, run
--)
863 static int epic_jb_decode_tile(G2MContext
*c
, int tile_x
, int tile_y
,
864 const uint8_t *src
, size_t src_size
,
865 AVCodecContext
*avctx
)
867 uint8_t prefix
, mask
= 0x80;
868 int extrabytes
, tile_width
, tile_height
, awidth
, aheight
;
875 /* get data size of the ELS partition as unsigned variable-length integer */
878 for (extrabytes
= 0; (prefix
& mask
) && (extrabytes
< 7); extrabytes
++)
880 if (extrabytes
> 3 || src_size
< extrabytes
) {
881 av_log(avctx
, AV_LOG_ERROR
, "ePIC: invalid data size VLI\n");
882 return AVERROR_INVALIDDATA
;
885 els_dsize
= prefix
& ((0x80 >> extrabytes
) - 1); // mask out the length prefix
886 while (extrabytes
-- > 0) {
887 els_dsize
= (els_dsize
<< 8) | *src
++;
891 if (src_size
< els_dsize
) {
892 av_log(avctx
, AV_LOG_ERROR
, "ePIC: data too short, needed %zu, got %zu\n",
893 els_dsize
, src_size
);
894 return AVERROR_INVALIDDATA
;
897 tile_width
= FFMIN(c
->width
- tile_x
* c
->tile_width
, c
->tile_width
);
898 tile_height
= FFMIN(c
->height
- tile_y
* c
->tile_height
, c
->tile_height
);
899 awidth
= FFALIGN(tile_width
, 16);
900 aheight
= FFALIGN(tile_height
, 16);
904 uint8_t tr_r
, tr_g
, tr_b
, *buf
;
906 /* ELS decoder initializations */
907 memset(&c
->ec
, 0, sizeof(c
->ec
));
908 ff_els_decoder_init(&c
->ec
.els_ctx
, src
, els_dsize
);
909 epic_hash_init(&c
->ec
.hash
);
911 /* decode transparent pixel value */
912 tr_r
= ff_els_decode_unsigned(&c
->ec
.els_ctx
, &c
->ec
.unsigned_rung
);
913 tr_g
= ff_els_decode_unsigned(&c
->ec
.els_ctx
, &c
->ec
.unsigned_rung
);
914 tr_b
= ff_els_decode_unsigned(&c
->ec
.els_ctx
, &c
->ec
.unsigned_rung
);
915 if (c
->ec
.els_ctx
.err
!= 0) {
916 av_log(avctx
, AV_LOG_ERROR
,
917 "ePIC: couldn't decode transparency pixel!\n");
918 return AVERROR_INVALIDDATA
;
921 ret
= epic_decode_tile(&c
->ec
, c
->epic_buf
, tile_height
, tile_width
,
924 epic_free_pixel_cache(&c
->ec
.hash
);
925 ff_els_decoder_uninit(&c
->ec
.unsigned_rung
);
928 av_log(avctx
, AV_LOG_ERROR
,
929 "ePIC: tile decoding failed, frame=%d, tile_x=%d, tile_y=%d\n",
930 avctx
->frame_number
, tile_x
, tile_y
);
931 return AVERROR_INVALIDDATA
;
935 dst
= c
->framebuf
+ tile_x
* c
->tile_width
* 3 +
936 tile_y
* c
->tile_height
* c
->framebuf_stride
;
938 for (j
= 0; j
< tile_height
; j
++) {
940 in
= (uint32_t *) buf
;
941 for (i
= 0; i
< tile_width
; i
++) {
942 out
[0] = (in
[i
] >> R_shift
) & 0xFF;
943 out
[1] = (in
[i
] >> G_shift
) & 0xFF;
944 out
[2] = (in
[i
] >> B_shift
) & 0xFF;
947 buf
+= c
->epic_buf_stride
;
948 dst
+= c
->framebuf_stride
;
951 if (src_size
> els_dsize
) {
954 int bstride
= FFALIGN(tile_width
, 16) >> 3;
956 int estride
= c
->epic_buf_stride
>> 2;
959 src_size
-= els_dsize
;
961 in
= (uint32_t *) c
->epic_buf
;
962 tr
= (tr_r
<< R_shift
) | (tr_g
<< G_shift
) | (tr_b
<< B_shift
);
964 memset(c
->kempf_flags
, 0,
965 (aheight
>> 3) * bstride
* sizeof(*c
->kempf_flags
));
966 for (j
= 0; j
< tile_height
; j
+= 8) {
967 for (i
= 0; i
< tile_width
; i
+= 8) {
968 c
->kempf_flags
[(i
>> 3) + (j
>> 3) * bstride
] = 0;
969 for (k
= 0; k
< 8 * 8; k
++) {
970 if (in
[i
+ (k
& 7) + (k
>> 3) * estride
] == tr
) {
971 c
->kempf_flags
[(i
>> 3) + (j
>> 3) * bstride
] = 1;
980 memset(c
->jpeg_tile
, 0, c
->tile_stride
* aheight
);
981 jpg_decode_data(&c
->jc
, awidth
, aheight
, src
, src_size
,
982 c
->jpeg_tile
, c
->tile_stride
,
983 c
->kempf_flags
, bstride
, nblocks
, c
->swapuv
);
985 in
= (uint32_t *) c
->epic_buf
;
986 dst
= c
->framebuf
+ tile_x
* c
->tile_width
* 3 +
987 tile_y
* c
->tile_height
* c
->framebuf_stride
;
989 for (j
= 0; j
< tile_height
; j
++) {
990 for (i
= 0; i
< tile_width
; i
++)
992 memcpy(dst
+ i
* 3, jpg
+ i
* 3, 3);
993 in
+= c
->epic_buf_stride
>> 2;
994 dst
+= c
->framebuf_stride
;
995 jpg
+= c
->tile_stride
;
999 dst
= c
->framebuf
+ tile_x
* c
->tile_width
* 3 +
1000 tile_y
* c
->tile_height
* c
->framebuf_stride
;
1001 return jpg_decode_data(&c
->jc
, tile_width
, tile_height
, src
, src_size
,
1002 dst
, c
->framebuf_stride
, NULL
, 0, 0, c
->swapuv
);
1008 static void kempf_restore_buf(const uint8_t *src
, int len
,
1009 uint8_t *dst
, int stride
,
1010 const uint8_t *jpeg_tile
, int tile_stride
,
1011 int width
, int height
,
1012 const uint8_t *pal
, int npal
, int tidx
)
1016 int align_width
= FFALIGN(width
, 16);
1018 init_get_bits(&gb
, src
, len
* 8);
1020 if (npal
<= 2) nb
= 1;
1021 else if (npal
<= 4) nb
= 2;
1022 else if (npal
<= 16) nb
= 4;
1025 for (j
= 0; j
< height
; j
++, dst
+= stride
, jpeg_tile
+= tile_stride
) {
1026 if (get_bits(&gb
, 8))
1028 for (i
= 0; i
< width
; i
++) {
1029 col
= get_bits(&gb
, nb
);
1031 memcpy(dst
+ i
* 3, pal
+ col
* 3, 3);
1033 memcpy(dst
+ i
* 3, jpeg_tile
+ i
* 3, 3);
1035 skip_bits_long(&gb
, nb
* (align_width
- width
));
1039 static int kempf_decode_tile(G2MContext
*c
, int tile_x
, int tile_y
,
1040 const uint8_t *src
, int src_size
)
1043 int hdr
, zsize
, npal
, tidx
= -1, ret
;
1045 const uint8_t *src_end
= src
+ src_size
;
1046 uint8_t pal
[768], transp
[3];
1047 uLongf dlen
= (c
->tile_width
+ 1) * c
->tile_height
;
1049 int nblocks
, cblocks
, bstride
;
1050 int bits
, bitbuf
, coded
;
1051 uint8_t *dst
= c
->framebuf
+ tile_x
* c
->tile_width
* 3 +
1052 tile_y
* c
->tile_height
* c
->framebuf_stride
;
1055 return AVERROR_INVALIDDATA
;
1057 width
= FFMIN(c
->width
- tile_x
* c
->tile_width
, c
->tile_width
);
1058 height
= FFMIN(c
->height
- tile_y
* c
->tile_height
, c
->tile_height
);
1061 sub_type
= hdr
>> 5;
1062 if (sub_type
== 0) {
1064 memcpy(transp
, src
, 3);
1066 for (j
= 0; j
< height
; j
++, dst
+= c
->framebuf_stride
)
1067 for (i
= 0; i
< width
; i
++)
1068 memcpy(dst
+ i
* 3, transp
, 3);
1070 } else if (sub_type
== 1) {
1071 return jpg_decode_data(&c
->jc
, width
, height
, src
, src_end
- src
,
1072 dst
, c
->framebuf_stride
, NULL
, 0, 0, 0);
1075 if (sub_type
!= 2) {
1076 memcpy(transp
, src
, 3);
1080 memcpy(pal
, src
, npal
* 3);
1082 if (sub_type
!= 2) {
1083 for (i
= 0; i
< npal
; i
++) {
1084 if (!memcmp(pal
+ i
* 3, transp
, 3)) {
1091 if (src_end
- src
< 2)
1093 zsize
= (src
[0] << 8) | src
[1];
1096 if (src_end
- src
< zsize
)
1097 return AVERROR_INVALIDDATA
;
1099 ret
= uncompress(c
->kempf_buf
, &dlen
, src
, zsize
);
1101 return AVERROR_INVALIDDATA
;
1104 if (sub_type
== 2) {
1105 kempf_restore_buf(c
->kempf_buf
, dlen
, dst
, c
->framebuf_stride
,
1106 NULL
, 0, width
, height
, pal
, npal
, tidx
);
1110 nblocks
= *src
++ + 1;
1112 bstride
= FFALIGN(width
, 16) >> 3;
1113 // blocks are coded LSB and we need normal bitreader for JPEG data
1115 for (i
= 0; i
< (FFALIGN(height
, 16) >> 4); i
++) {
1116 for (j
= 0; j
< (FFALIGN(width
, 16) >> 4); j
++) {
1125 if (cblocks
> nblocks
)
1126 return AVERROR_INVALIDDATA
;
1127 c
->kempf_flags
[j
* 2 + i
* 2 * bstride
] =
1128 c
->kempf_flags
[j
* 2 + 1 + i
* 2 * bstride
] =
1129 c
->kempf_flags
[j
* 2 + (i
* 2 + 1) * bstride
] =
1130 c
->kempf_flags
[j
* 2 + 1 + (i
* 2 + 1) * bstride
] = coded
;
1134 memset(c
->jpeg_tile
, 0, c
->tile_stride
* height
);
1135 jpg_decode_data(&c
->jc
, width
, height
, src
, src_end
- src
,
1136 c
->jpeg_tile
, c
->tile_stride
,
1137 c
->kempf_flags
, bstride
, nblocks
* 4, 0);
1139 kempf_restore_buf(c
->kempf_buf
, dlen
, dst
, c
->framebuf_stride
,
1140 c
->jpeg_tile
, c
->tile_stride
,
1141 width
, height
, pal
, npal
, tidx
);
1146 static int g2m_init_buffers(G2MContext
*c
)
1150 if (!c
->framebuf
|| c
->old_width
< c
->width
|| c
->old_height
< c
->height
) {
1151 c
->framebuf_stride
= FFALIGN(c
->width
* 3, 16);
1152 aligned_height
= FFALIGN(c
->height
, 16);
1153 av_free(c
->framebuf
);
1154 c
->framebuf
= av_mallocz(c
->framebuf_stride
* aligned_height
);
1156 return AVERROR(ENOMEM
);
1158 if (!c
->synth_tile
|| !c
->jpeg_tile
||
1159 (c
->compression
== 2 && !c
->epic_buf_base
) ||
1160 c
->old_tile_w
< c
->tile_width
||
1161 c
->old_tile_h
< c
->tile_height
) {
1162 c
->tile_stride
= FFALIGN(c
->tile_width
* 3, 16);
1163 c
->epic_buf_stride
= FFALIGN(c
->tile_width
* 4, 16);
1164 aligned_height
= FFALIGN(c
->tile_height
, 16);
1165 av_free(c
->synth_tile
);
1166 av_free(c
->jpeg_tile
);
1167 av_free(c
->kempf_buf
);
1168 av_free(c
->kempf_flags
);
1169 av_free(c
->epic_buf_base
);
1170 c
->synth_tile
= av_mallocz(c
->tile_stride
* aligned_height
);
1171 c
->jpeg_tile
= av_mallocz(c
->tile_stride
* aligned_height
);
1172 c
->kempf_buf
= av_mallocz((c
->tile_width
+ 1) * aligned_height
+
1173 AV_INPUT_BUFFER_PADDING_SIZE
);
1174 c
->kempf_flags
= av_mallocz(c
->tile_width
* aligned_height
);
1175 if (!c
->synth_tile
|| !c
->jpeg_tile
||
1176 !c
->kempf_buf
|| !c
->kempf_flags
)
1177 return AVERROR(ENOMEM
);
1178 if (c
->compression
== 2) {
1179 c
->epic_buf_base
= av_mallocz(c
->epic_buf_stride
* aligned_height
+ 4);
1180 if (!c
->epic_buf_base
)
1181 return AVERROR(ENOMEM
);
1182 c
->epic_buf
= c
->epic_buf_base
+ 4;
1189 static int g2m_load_cursor(AVCodecContext
*avctx
, G2MContext
*c
,
1195 uint32_t cur_size
, cursor_w
, cursor_h
, cursor_stride
;
1196 uint32_t cursor_hot_x
, cursor_hot_y
;
1197 int cursor_fmt
, err
;
1199 cur_size
= bytestream2_get_be32(gb
);
1200 cursor_w
= bytestream2_get_byte(gb
);
1201 cursor_h
= bytestream2_get_byte(gb
);
1202 cursor_hot_x
= bytestream2_get_byte(gb
);
1203 cursor_hot_y
= bytestream2_get_byte(gb
);
1204 cursor_fmt
= bytestream2_get_byte(gb
);
1206 cursor_stride
= FFALIGN(cursor_w
, 32) * 4;
1208 if (cursor_w
< 1 || cursor_w
> 256 ||
1209 cursor_h
< 1 || cursor_h
> 256) {
1210 av_log(avctx
, AV_LOG_ERROR
, "Invalid cursor dimensions %"PRIu32
"x%"PRIu32
"\n",
1211 cursor_w
, cursor_h
);
1212 return AVERROR_INVALIDDATA
;
1214 if (cursor_hot_x
> cursor_w
|| cursor_hot_y
> cursor_h
) {
1215 av_log(avctx
, AV_LOG_WARNING
, "Invalid hotspot position %"PRIu32
",%"PRIu32
"\n",
1216 cursor_hot_x
, cursor_hot_y
);
1217 cursor_hot_x
= FFMIN(cursor_hot_x
, cursor_w
- 1);
1218 cursor_hot_y
= FFMIN(cursor_hot_y
, cursor_h
- 1);
1220 if (cur_size
- 9 > bytestream2_get_bytes_left(gb
) ||
1221 c
->cursor_w
* c
->cursor_h
/ 4 > cur_size
) {
1222 av_log(avctx
, AV_LOG_ERROR
, "Invalid cursor data size %"PRIu32
"/%u\n",
1223 cur_size
, bytestream2_get_bytes_left(gb
));
1224 return AVERROR_INVALIDDATA
;
1226 if (cursor_fmt
!= 1 && cursor_fmt
!= 32) {
1227 avpriv_report_missing_feature(avctx
, "Cursor format %d",
1229 return AVERROR_PATCHWELCOME
;
1232 if ((err
= av_reallocp(&c
->cursor
, cursor_stride
* cursor_h
)) < 0) {
1233 av_log(avctx
, AV_LOG_ERROR
, "Cannot allocate cursor buffer\n");
1237 c
->cursor_w
= cursor_w
;
1238 c
->cursor_h
= cursor_h
;
1239 c
->cursor_hot_x
= cursor_hot_x
;
1240 c
->cursor_hot_y
= cursor_hot_y
;
1241 c
->cursor_fmt
= cursor_fmt
;
1242 c
->cursor_stride
= cursor_stride
;
1245 switch (c
->cursor_fmt
) {
1246 case 1: // old monochrome
1247 for (j
= 0; j
< c
->cursor_h
; j
++) {
1248 for (i
= 0; i
< c
->cursor_w
; i
+= 32) {
1249 bits
= bytestream2_get_be32(gb
);
1250 for (k
= 0; k
< 32; k
++) {
1251 dst
[0] = !!(bits
& 0x80000000);
1256 dst
+= c
->cursor_stride
- c
->cursor_w
* 4;
1260 for (j
= 0; j
< c
->cursor_h
; j
++) {
1261 for (i
= 0; i
< c
->cursor_w
; i
+= 32) {
1262 bits
= bytestream2_get_be32(gb
);
1263 for (k
= 0; k
< 32; k
++) {
1264 int mask_bit
= !!(bits
& 0x80000000);
1265 switch (dst
[0] * 2 + mask_bit
) {
1288 dst
+= c
->cursor_stride
- c
->cursor_w
* 4;
1291 case 32: // full colour
1292 /* skip monochrome version of the cursor and decode RGBA instead */
1293 bytestream2_skip(gb
, c
->cursor_h
* (FFALIGN(c
->cursor_w
, 32) >> 3));
1294 for (j
= 0; j
< c
->cursor_h
; j
++) {
1295 for (i
= 0; i
< c
->cursor_w
; i
++) {
1296 int val
= bytestream2_get_be32(gb
);
1302 dst
+= c
->cursor_stride
- c
->cursor_w
* 4;
1306 return AVERROR_PATCHWELCOME
;
1311 #define APPLY_ALPHA(src, new, alpha) \
1312 src = (src * (256 - alpha) + new * alpha) >> 8
1314 static void g2m_paint_cursor(G2MContext
*c
, uint8_t *dst
, int stride
)
1318 const uint8_t *cursor
;
1323 x
= c
->cursor_x
- c
->cursor_hot_x
;
1324 y
= c
->cursor_y
- c
->cursor_hot_y
;
1330 if (x
+ w
> c
->width
)
1332 if (y
+ h
> c
->height
)
1342 cursor
+= -y
* c
->cursor_stride
;
1349 for (j
= 0; j
< h
; j
++) {
1350 for (i
= 0; i
< w
; i
++) {
1351 uint8_t alpha
= cursor
[i
* 4];
1352 APPLY_ALPHA(dst
[i
* 3 + 0], cursor
[i
* 4 + 1], alpha
);
1353 APPLY_ALPHA(dst
[i
* 3 + 1], cursor
[i
* 4 + 2], alpha
);
1354 APPLY_ALPHA(dst
[i
* 3 + 2], cursor
[i
* 4 + 3], alpha
);
1357 cursor
+= c
->cursor_stride
;
1361 static int g2m_decode_frame(AVCodecContext
*avctx
, void *data
,
1362 int *got_picture_ptr
, AVPacket
*avpkt
)
1364 const uint8_t *buf
= avpkt
->data
;
1365 int buf_size
= avpkt
->size
;
1366 G2MContext
*c
= avctx
->priv_data
;
1367 AVFrame
*pic
= data
;
1368 GetByteContext bc
, tbc
;
1371 uint32_t chunk_size
, r_mask
, g_mask
, b_mask
;
1372 int chunk_type
, chunk_start
;
1376 if (buf_size
< 12) {
1377 av_log(avctx
, AV_LOG_ERROR
,
1378 "Frame should have at least 12 bytes, got %d instead\n",
1380 return AVERROR_INVALIDDATA
;
1383 bytestream2_init(&bc
, buf
, buf_size
);
1385 magic
= bytestream2_get_be32(&bc
);
1386 if ((magic
& ~0xF) != MKBETAG('G', '2', 'M', '0') ||
1387 (magic
& 0xF) < 2 || (magic
& 0xF) > 5) {
1388 av_log(avctx
, AV_LOG_ERROR
, "Wrong magic %08X\n", magic
);
1389 return AVERROR_INVALIDDATA
;
1392 c
->swapuv
= magic
== MKBETAG('G', '2', 'M', '2');
1394 while (bytestream2_get_bytes_left(&bc
) > 5) {
1395 chunk_size
= bytestream2_get_le32(&bc
) - 1;
1396 chunk_type
= bytestream2_get_byte(&bc
);
1397 chunk_start
= bytestream2_tell(&bc
);
1398 if (chunk_size
> bytestream2_get_bytes_left(&bc
)) {
1399 av_log(avctx
, AV_LOG_ERROR
, "Invalid chunk size %"PRIu32
" type %02X\n",
1400 chunk_size
, chunk_type
);
1403 switch (chunk_type
) {
1406 if (chunk_size
< 21) {
1407 av_log(avctx
, AV_LOG_ERROR
, "Invalid display info size %"PRIu32
"\n",
1411 c
->width
= bytestream2_get_be32(&bc
);
1412 c
->height
= bytestream2_get_be32(&bc
);
1413 if (c
->width
< 16 || c
->height
< 16) {
1414 av_log(avctx
, AV_LOG_ERROR
,
1415 "Invalid frame dimensions %dx%d\n",
1416 c
->width
, c
->height
);
1417 ret
= AVERROR_INVALIDDATA
;
1420 if (c
->width
!= avctx
->width
|| c
->height
!= avctx
->height
) {
1421 ret
= ff_set_dimensions(avctx
, c
->width
, c
->height
);
1425 c
->compression
= bytestream2_get_be32(&bc
);
1426 if (c
->compression
!= 2 && c
->compression
!= 3) {
1427 avpriv_report_missing_feature(avctx
, "Compression method %d",
1429 return AVERROR_PATCHWELCOME
;
1431 c
->tile_width
= bytestream2_get_be32(&bc
);
1432 c
->tile_height
= bytestream2_get_be32(&bc
);
1433 if (!c
->tile_width
|| !c
->tile_height
||
1434 ((c
->tile_width
| c
->tile_height
) & 0xF)) {
1435 av_log(avctx
, AV_LOG_ERROR
,
1436 "Invalid tile dimensions %dx%d\n",
1437 c
->tile_width
, c
->tile_height
);
1438 ret
= AVERROR_INVALIDDATA
;
1441 c
->tiles_x
= (c
->width
+ c
->tile_width
- 1) / c
->tile_width
;
1442 c
->tiles_y
= (c
->height
+ c
->tile_height
- 1) / c
->tile_height
;
1443 c
->bpp
= bytestream2_get_byte(&bc
);
1445 if (bytestream2_get_bytes_left(&bc
) < 16 ||
1446 (chunk_size
- 21) < 16) {
1447 av_log(avctx
, AV_LOG_ERROR
,
1448 "Display info: missing bitmasks!\n");
1449 return AVERROR_INVALIDDATA
;
1451 r_mask
= bytestream2_get_be32(&bc
);
1452 g_mask
= bytestream2_get_be32(&bc
);
1453 b_mask
= bytestream2_get_be32(&bc
);
1454 if (r_mask
!= 0xFF0000 || g_mask
!= 0xFF00 || b_mask
!= 0xFF) {
1455 avpriv_report_missing_feature(avctx
,
1456 "Bitmasks: R=%"PRIX32
", G=%"PRIX32
", B=%"PRIX32
,
1457 r_mask
, g_mask
, b_mask
);
1458 return AVERROR_PATCHWELCOME
;
1461 avpriv_request_sample(avctx
, "bpp=%d", c
->bpp
);
1462 return AVERROR_PATCHWELCOME
;
1464 if (g2m_init_buffers(c
)) {
1465 ret
= AVERROR(ENOMEM
);
1471 if (!c
->tiles_x
|| !c
->tiles_y
) {
1472 av_log(avctx
, AV_LOG_WARNING
,
1473 "No display info - skipping tile\n");
1476 if (chunk_size
< 2) {
1477 av_log(avctx
, AV_LOG_ERROR
, "Invalid tile data size %"PRIu32
"\n",
1481 c
->tile_x
= bytestream2_get_byte(&bc
);
1482 c
->tile_y
= bytestream2_get_byte(&bc
);
1483 if (c
->tile_x
>= c
->tiles_x
|| c
->tile_y
>= c
->tiles_y
) {
1484 av_log(avctx
, AV_LOG_ERROR
,
1485 "Invalid tile pos %d,%d (in %dx%d grid)\n",
1486 c
->tile_x
, c
->tile_y
, c
->tiles_x
, c
->tiles_y
);
1490 switch (c
->compression
) {
1491 case COMPR_EPIC_J_B
:
1492 ret
= epic_jb_decode_tile(c
, c
->tile_x
, c
->tile_y
,
1493 buf
+ bytestream2_tell(&bc
),
1494 chunk_size
- 2, avctx
);
1496 case COMPR_KEMPF_J_B
:
1497 ret
= kempf_decode_tile(c
, c
->tile_x
, c
->tile_y
,
1498 buf
+ bytestream2_tell(&bc
),
1502 if (ret
&& c
->framebuf
)
1503 av_log(avctx
, AV_LOG_ERROR
, "Error decoding tile %d,%d\n",
1504 c
->tile_x
, c
->tile_y
);
1507 if (chunk_size
< 5) {
1508 av_log(avctx
, AV_LOG_ERROR
, "Invalid cursor pos size %"PRIu32
"\n",
1512 c
->cursor_x
= bytestream2_get_be16(&bc
);
1513 c
->cursor_y
= bytestream2_get_be16(&bc
);
1516 if (chunk_size
< 8) {
1517 av_log(avctx
, AV_LOG_ERROR
, "Invalid cursor data size %"PRIu32
"\n",
1521 bytestream2_init(&tbc
, buf
+ bytestream2_tell(&bc
),
1523 g2m_load_cursor(avctx
, c
, &tbc
);
1529 av_log(avctx
, AV_LOG_WARNING
, "Skipping chunk type %02d\n",
1533 /* navigate to next chunk */
1534 bytestream2_skip(&bc
, chunk_start
+ chunk_size
- bytestream2_tell(&bc
));
1539 if (c
->width
&& c
->height
) {
1540 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0) {
1541 av_log(avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
1545 pic
->key_frame
= got_header
;
1546 pic
->pict_type
= got_header ? AV_PICTURE_TYPE_I
: AV_PICTURE_TYPE_P
;
1548 for (i
= 0; i
< avctx
->height
; i
++)
1549 memcpy(pic
->data
[0] + i
* pic
->linesize
[0],
1550 c
->framebuf
+ i
* c
->framebuf_stride
,
1552 g2m_paint_cursor(c
, pic
->data
[0], pic
->linesize
[0]);
1554 *got_picture_ptr
= 1;
1567 static av_cold
int g2m_decode_init(AVCodecContext
*avctx
)
1569 G2MContext
*const c
= avctx
->priv_data
;
1572 if ((ret
= jpg_init(avctx
, &c
->jc
)) != 0) {
1573 av_log(avctx
, AV_LOG_ERROR
, "Cannot initialise VLCs\n");
1574 jpg_free_context(&c
->jc
);
1575 return AVERROR(ENOMEM
);
1578 avctx
->pix_fmt
= AV_PIX_FMT_RGB24
;
1580 // store original sizes and check against those if resize happens
1581 c
->orig_width
= avctx
->width
;
1582 c
->orig_height
= avctx
->height
;
1587 static av_cold
int g2m_decode_end(AVCodecContext
*avctx
)
1589 G2MContext
*const c
= avctx
->priv_data
;
1591 jpg_free_context(&c
->jc
);
1593 av_freep(&c
->epic_buf_base
);
1594 av_freep(&c
->kempf_buf
);
1595 av_freep(&c
->kempf_flags
);
1596 av_freep(&c
->synth_tile
);
1597 av_freep(&c
->jpeg_tile
);
1598 av_freep(&c
->cursor
);
1599 av_freep(&c
->framebuf
);
1604 AVCodec ff_g2m_decoder
= {
1606 .long_name
= NULL_IF_CONFIG_SMALL("Go2Meeting"),
1607 .type
= AVMEDIA_TYPE_VIDEO
,
1608 .id
= AV_CODEC_ID_G2M
,
1609 .priv_data_size
= sizeof(G2MContext
),
1610 .init
= g2m_decode_init
,
1611 .close
= g2m_decode_end
,
1612 .decode
= g2m_decode_frame
,
1613 .capabilities
= AV_CODEC_CAP_DR1
,
1614 .caps_internal
= FF_CODEC_CAP_INIT_THREADSAFE
,