2 * TechSmith Camtasia decoder
3 * Copyright (c) 2004 Konstantin Shishkov
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * TechSmith Camtasia decoder
28 * Codec is very simple:
29 * it codes picture (picture difference, really)
30 * with algorithm almost identical to Windows RLE8,
31 * only without padding and with greater pixel sizes,
32 * then this coded picture is packed with ZLib
34 * Supports: BGR8,BGR555,BGR24 - only BGR8 and BGR555 tested
51 typedef struct TsccContext
{
53 AVCodecContext
*avctx
;
58 // Decompressed data size
59 unsigned int decomp_size
;
60 // Decompression buffer
61 unsigned char* decomp_buf
;
70 * Decode RLE - almost identical to Windows BMP RLE8
71 * and enhanced to bigger color depths
75 static int decode_rle(CamtasiaContext
*c
, unsigned int srcsize
)
77 unsigned char *src
= c
->decomp_buf
;
78 unsigned char *output
, *output_end
;
79 int p1
, p2
, line
=c
->height
, pos
=0, i
;
83 output
= c
->pic
.data
[0] + (c
->height
- 1) * c
->pic
.linesize
[0];
84 output_end
= c
->pic
.data
[0] + (c
->height
) * c
->pic
.linesize
[0];
85 while(src
< c
->decomp_buf
+ srcsize
) {
87 if(p1
== 0) { //Escape code
89 if(p2
== 0) { //End-of-line
90 output
= c
->pic
.data
[0] + (--line
) * c
->pic
.linesize
[0];
95 } else if(p2
== 1) { //End-of-picture
97 } else if(p2
== 2) { //Skip
104 output
= c
->pic
.data
[0] + line
* c
->pic
.linesize
[0] + pos
* (c
->bpp
/ 8);
108 if (output
+ p2
* (c
->bpp
/ 8) > output_end
) {
109 src
+= p2
* (c
->bpp
/ 8);
112 if ((c
->bpp
== 8) || (c
->bpp
== 24)) {
113 for(i
= 0; i
< p2
* (c
->bpp
/ 8); i
++) {
116 // RLE8 copy is actually padded - and runs are not!
117 if(c
->bpp
== 8 && (p2
& 1)) {
120 } else if (c
->bpp
== 16) {
121 for(i
= 0; i
< p2
; i
++) {
122 pix16
= AV_RL16(src
);
124 *(uint16_t*)output
= pix16
;
127 } else if (c
->bpp
== 32) {
128 for(i
= 0; i
< p2
; i
++) {
129 pix32
= AV_RL32(src
);
131 *(uint32_t*)output
= pix32
;
136 } else { //Run of pixels
137 int pix
[4]; //original pixel
139 case 8: pix
[0] = *src
++;
141 case 16: pix16
= AV_RL16(src
);
143 *(uint16_t*)pix
= pix16
;
145 case 24: pix
[0] = *src
++;
149 case 32: pix32
= AV_RL32(src
);
151 *(uint32_t*)pix
= pix32
;
154 if (output
+ p1
* (c
->bpp
/ 8) > output_end
)
156 for(i
= 0; i
< p1
; i
++) {
158 case 8: *output
++ = pix
[0];
160 case 16: *(uint16_t*)output
= pix16
;
163 case 24: *output
++ = pix
[0];
167 case 32: *(uint32_t*)output
= pix32
;
176 av_log(c
->avctx
, AV_LOG_ERROR
, "Camtasia warning: no End-of-picture code\n");
185 static int decode_frame(AVCodecContext
*avctx
, void *data
, int *data_size
, const uint8_t *buf
, int buf_size
)
187 CamtasiaContext
* const c
= avctx
->priv_data
;
188 const unsigned char *encoded
= buf
;
189 unsigned char *outptr
;
191 int zret
; // Zlib return code
196 avctx
->release_buffer(avctx
, &c
->pic
);
198 c
->pic
.reference
= 1;
199 c
->pic
.buffer_hints
= FF_BUFFER_HINTS_VALID
;
200 if(avctx
->get_buffer(avctx
, &c
->pic
) < 0){
201 av_log(avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
205 outptr
= c
->pic
.data
[0]; // Output image pointer
208 zret
= inflateReset(&(c
->zstream
));
210 av_log(avctx
, AV_LOG_ERROR
, "Inflate reset error: %d\n", zret
);
213 c
->zstream
.next_in
= encoded
;
214 c
->zstream
.avail_in
= len
;
215 c
->zstream
.next_out
= c
->decomp_buf
;
216 c
->zstream
.avail_out
= c
->decomp_size
;
217 zret
= inflate(&(c
->zstream
), Z_FINISH
);
218 // Z_DATA_ERROR means empty picture
219 if ((zret
!= Z_OK
) && (zret
!= Z_STREAM_END
) && (zret
!= Z_DATA_ERROR
)) {
220 av_log(avctx
, AV_LOG_ERROR
, "Inflate error: %d\n", zret
);
225 if(zret
!= Z_DATA_ERROR
)
226 decode_rle(c
, c
->zstream
.avail_out
);
228 /* make the palette available on the way out */
229 if (c
->avctx
->pix_fmt
== PIX_FMT_PAL8
) {
230 memcpy(c
->pic
.data
[1], c
->avctx
->palctrl
->palette
, AVPALETTE_SIZE
);
231 if (c
->avctx
->palctrl
->palette_changed
) {
232 c
->pic
.palette_has_changed
= 1;
233 c
->avctx
->palctrl
->palette_changed
= 0;
238 av_log(avctx
, AV_LOG_ERROR
, "BUG! Zlib support not compiled in frame decoder.\n");
242 *data_size
= sizeof(AVFrame
);
243 *(AVFrame
*)data
= c
->pic
;
245 /* always report that the buffer was completely consumed */
256 static av_cold
int decode_init(AVCodecContext
*avctx
)
258 CamtasiaContext
* const c
= avctx
->priv_data
;
259 int zret
; // Zlib return code
263 c
->pic
.data
[0] = NULL
;
264 c
->height
= avctx
->height
;
266 if (avcodec_check_dimensions(avctx
, avctx
->width
, avctx
->height
) < 0) {
271 // Needed if zlib unused or init aborted before inflateInit
272 memset(&(c
->zstream
), 0, sizeof(z_stream
));
274 av_log(avctx
, AV_LOG_ERROR
, "Zlib support not compiled.\n");
277 switch(avctx
->bits_per_sample
){
278 case 8: avctx
->pix_fmt
= PIX_FMT_PAL8
; break;
279 case 16: avctx
->pix_fmt
= PIX_FMT_RGB555
; break;
281 avctx
->pix_fmt
= PIX_FMT_BGR24
;
283 case 32: avctx
->pix_fmt
= PIX_FMT_RGB32
; break;
284 default: av_log(avctx
, AV_LOG_ERROR
, "Camtasia error: unknown depth %i bpp\n", avctx
->bits_per_sample
);
287 c
->bpp
= avctx
->bits_per_sample
;
288 c
->decomp_size
= (avctx
->width
* c
->bpp
+ (avctx
->width
+ 254) / 255 + 2) * avctx
->height
+ 2;//RLE in the 'best' case
290 /* Allocate decompression buffer */
291 if (c
->decomp_size
) {
292 if ((c
->decomp_buf
= av_malloc(c
->decomp_size
)) == NULL
) {
293 av_log(avctx
, AV_LOG_ERROR
, "Can't allocate decompression buffer.\n");
299 c
->zstream
.zalloc
= Z_NULL
;
300 c
->zstream
.zfree
= Z_NULL
;
301 c
->zstream
.opaque
= Z_NULL
;
302 zret
= inflateInit(&(c
->zstream
));
304 av_log(avctx
, AV_LOG_ERROR
, "Inflate init error: %d\n", zret
);
316 * Uninit tscc decoder
319 static av_cold
int decode_end(AVCodecContext
*avctx
)
321 CamtasiaContext
* const c
= avctx
->priv_data
;
323 av_freep(&c
->decomp_buf
);
326 avctx
->release_buffer(avctx
, &c
->pic
);
328 inflateEnd(&(c
->zstream
));
334 AVCodec tscc_decoder
= {
338 sizeof(CamtasiaContext
),
344 .long_name
= NULL_IF_CONFIG_SMALL("TechSmith Screen Capture Codec"),