1 |
|
|
/* |
2 |
|
|
* TechSmith Screen Codec 2 (aka Dora) decoder |
3 |
|
|
* Copyright (c) 2012 Konstantin Shishkov |
4 |
|
|
* |
5 |
|
|
* This file is part of FFmpeg. |
6 |
|
|
* |
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. |
11 |
|
|
* |
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. |
16 |
|
|
* |
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 |
20 |
|
|
*/ |
21 |
|
|
|
22 |
|
|
/** |
23 |
|
|
* @file |
24 |
|
|
* TechSmith Screen Codec 2 decoder |
25 |
|
|
*/ |
26 |
|
|
|
27 |
|
|
#include <inttypes.h> |
28 |
|
|
|
29 |
|
|
#include "libavutil/thread.h" |
30 |
|
|
|
31 |
|
|
#define BITSTREAM_READER_LE |
32 |
|
|
#include "avcodec.h" |
33 |
|
|
#include "bytestream.h" |
34 |
|
|
#include "get_bits.h" |
35 |
|
|
#include "internal.h" |
36 |
|
|
#include "mathops.h" |
37 |
|
|
#include "tscc2data.h" |
38 |
|
|
|
39 |
|
|
#define TSCC2_VLC_BITS 9 |
40 |
|
|
|
41 |
|
|
typedef struct TSCC2Context { |
42 |
|
|
AVCodecContext *avctx; |
43 |
|
|
AVFrame *pic; |
44 |
|
|
int mb_width, mb_height; |
45 |
|
|
uint8_t *slice_quants; |
46 |
|
|
int quant[2]; |
47 |
|
|
int q[2][3]; |
48 |
|
|
GetBitContext gb; |
49 |
|
|
|
50 |
|
|
int block[16]; |
51 |
|
|
} TSCC2Context; |
52 |
|
|
|
53 |
|
|
static VLC dc_vlc, nc_vlc[NUM_VLC_SETS], ac_vlc[NUM_VLC_SETS]; |
54 |
|
|
|
55 |
|
54 |
static av_cold void tscc2_init_vlc(VLC *vlc, int *offset, int nb_codes, |
56 |
|
|
const uint8_t *lens, const void *syms, |
57 |
|
|
int sym_length) |
58 |
|
|
{ |
59 |
|
|
static VLC_TYPE vlc_buf[15442][2]; |
60 |
|
|
|
61 |
|
54 |
vlc->table = &vlc_buf[*offset]; |
62 |
|
54 |
vlc->table_allocated = FF_ARRAY_ELEMS(vlc_buf) - *offset; |
63 |
|
54 |
ff_init_vlc_from_lengths(vlc, TSCC2_VLC_BITS, nb_codes, |
64 |
|
|
lens, 1, syms, sym_length, sym_length, 0, |
65 |
|
|
INIT_VLC_STATIC_OVERLONG | INIT_VLC_OUTPUT_LE, NULL); |
66 |
|
54 |
*offset += vlc->table_size; |
67 |
|
54 |
} |
68 |
|
|
|
69 |
|
2 |
static av_cold void tscc2_init_vlcs(void) |
70 |
|
|
{ |
71 |
|
2 |
const uint16_t *ac_vlc_syms = tscc2_ac_vlc_syms; |
72 |
|
2 |
const uint8_t *ac_vlc_lens = tscc2_ac_vlc_lens; |
73 |
|
2 |
int i, offset = 0; |
74 |
|
|
|
75 |
|
2 |
tscc2_init_vlc(&dc_vlc, &offset, DC_VLC_COUNT, |
76 |
|
|
tscc2_dc_vlc_lens, tscc2_dc_vlc_syms, 2); |
77 |
|
|
|
78 |
✓✓ |
28 |
for (i = 0; i < NUM_VLC_SETS; i++) { |
79 |
|
26 |
tscc2_init_vlc(&nc_vlc[i], &offset, 16, |
80 |
|
26 |
tscc2_nc_vlc_lens[i], tscc2_nc_vlc_syms[i], 1); |
81 |
|
|
|
82 |
|
26 |
tscc2_init_vlc(&ac_vlc[i], &offset, tscc2_ac_vlc_sizes[i], |
83 |
|
|
ac_vlc_lens, ac_vlc_syms, 2); |
84 |
|
26 |
ac_vlc_lens += tscc2_ac_vlc_sizes[i]; |
85 |
|
26 |
ac_vlc_syms += tscc2_ac_vlc_sizes[i]; |
86 |
|
|
} |
87 |
|
2 |
} |
88 |
|
|
|
89 |
|
|
#define DEQUANT(val, q) (((q) * (val) + 0x80) >> 8) |
90 |
|
|
#define DCT1D(d0, d1, d2, d3, s0, s1, s2, s3, OP) \ |
91 |
|
|
OP(d0, 5 * ((s0) + (s1) + (s2)) + 2 * (s3)); \ |
92 |
|
|
OP(d1, 5 * ((s0) - (s2) - (s3)) + 2 * (s1)); \ |
93 |
|
|
OP(d2, 5 * ((s0) - (s2) + (s3)) - 2 * (s1)); \ |
94 |
|
|
OP(d3, 5 * ((s0) - (s1) + (s2)) - 2 * (s3)); \ |
95 |
|
|
|
96 |
|
|
#define COL_OP(a, b) a = (b) |
97 |
|
|
#define ROW_OP(a, b) a = ((b) + 0x20) >> 6 |
98 |
|
|
|
99 |
|
441488 |
static void tscc2_idct4_put(int *in, int q[3], uint8_t *dst, int stride) |
100 |
|
|
{ |
101 |
|
|
int i; |
102 |
|
|
int tblk[4 * 4]; |
103 |
|
|
int t0, t1, t2, t3; |
104 |
|
|
|
105 |
✓✓ |
2207440 |
for (i = 0; i < 4; i++) { |
106 |
|
1765952 |
t0 = DEQUANT(q[0 + (i & 1)], in[0 * 4 + i]); |
107 |
|
1765952 |
t1 = DEQUANT(q[1 + (i & 1)], in[1 * 4 + i]); |
108 |
|
1765952 |
t2 = DEQUANT(q[0 + (i & 1)], in[2 * 4 + i]); |
109 |
|
1765952 |
t3 = DEQUANT(q[1 + (i & 1)], in[3 * 4 + i]); |
110 |
|
1765952 |
DCT1D(tblk[0 * 4 + i], tblk[1 * 4 + i], |
111 |
|
|
tblk[2 * 4 + i], tblk[3 * 4 + i], |
112 |
|
|
t0, t1, t2, t3, COL_OP); |
113 |
|
|
} |
114 |
✓✓ |
2207440 |
for (i = 0; i < 4; i++) { |
115 |
|
1765952 |
DCT1D(dst[0], dst[1], dst[2], dst[3], |
116 |
|
|
tblk[i * 4 + 0], tblk[i * 4 + 1], |
117 |
|
|
tblk[i * 4 + 2], tblk[i * 4 + 3], ROW_OP); |
118 |
|
1765952 |
dst += stride; |
119 |
|
|
} |
120 |
|
441488 |
} |
121 |
|
|
|
122 |
|
66141 |
static int tscc2_decode_mb(TSCC2Context *c, int *q, int vlc_set, |
123 |
|
|
uint8_t *dst, int stride, int plane) |
124 |
|
|
{ |
125 |
|
66141 |
GetBitContext *gb = &c->gb; |
126 |
|
|
int prev_dc, dc, nc, ac, bpos, val; |
127 |
|
|
int i, j, k, l; |
128 |
|
|
|
129 |
✓✓ |
66141 |
if (get_bits1(gb)) { |
130 |
✓✓ |
10955 |
if (get_bits1(gb)) { |
131 |
|
10954 |
val = get_bits(gb, 8); |
132 |
✓✓ |
98586 |
for (i = 0; i < 8; i++, dst += stride) |
133 |
|
87632 |
memset(dst, val, 16); |
134 |
|
|
} else { |
135 |
✗✓ |
1 |
if (get_bits_left(gb) < 16 * 8 * 8) |
136 |
|
|
return AVERROR_INVALIDDATA; |
137 |
✓✓ |
9 |
for (i = 0; i < 8; i++) { |
138 |
✓✓ |
136 |
for (j = 0; j < 16; j++) |
139 |
|
128 |
dst[j] = get_bits(gb, 8); |
140 |
|
8 |
dst += stride; |
141 |
|
|
} |
142 |
|
|
} |
143 |
|
10955 |
return 0; |
144 |
|
|
} |
145 |
|
|
|
146 |
|
55186 |
prev_dc = 0; |
147 |
✓✓ |
165558 |
for (j = 0; j < 2; j++) { |
148 |
✓✓ |
551860 |
for (k = 0; k < 4; k++) { |
149 |
✓✓ |
441488 |
if (!(j | k)) { |
150 |
|
55186 |
dc = get_bits(gb, 8); |
151 |
|
|
} else { |
152 |
|
386302 |
dc = get_vlc2(gb, dc_vlc.table, TSCC2_VLC_BITS, 2); |
153 |
✓✓ |
386302 |
if (dc == 0x100) |
154 |
|
22622 |
dc = get_bits(gb, 8); |
155 |
|
|
} |
156 |
|
441488 |
dc = (dc + prev_dc) & 0xFF; |
157 |
|
441488 |
prev_dc = dc; |
158 |
|
441488 |
c->block[0] = dc; |
159 |
|
|
|
160 |
|
441488 |
nc = get_vlc2(gb, nc_vlc[vlc_set].table, TSCC2_VLC_BITS, 1); |
161 |
|
|
|
162 |
|
441488 |
bpos = 1; |
163 |
|
441488 |
memset(c->block + 1, 0, 15 * sizeof(*c->block)); |
164 |
✓✓ |
2082935 |
for (l = 0; l < nc; l++) { |
165 |
|
1641447 |
ac = get_vlc2(gb, ac_vlc[vlc_set].table, TSCC2_VLC_BITS, 2); |
166 |
✓✓ |
1641447 |
if (ac == 0x1000) |
167 |
|
48321 |
ac = get_bits(gb, 12); |
168 |
|
1641447 |
bpos += ac & 0xF; |
169 |
✗✓ |
1641447 |
if (bpos >= 16) |
170 |
|
|
return AVERROR_INVALIDDATA; |
171 |
|
1641447 |
val = sign_extend(ac >> 4, 8); |
172 |
|
1641447 |
c->block[ff_zigzag_scan[bpos++]] = val; |
173 |
|
|
} |
174 |
|
441488 |
tscc2_idct4_put(c->block, q, dst + k * 4, stride); |
175 |
|
|
} |
176 |
|
110372 |
dst += 4 * stride; |
177 |
|
|
} |
178 |
|
55186 |
return 0; |
179 |
|
|
} |
180 |
|
|
|
181 |
|
1084 |
static int tscc2_decode_slice(TSCC2Context *c, int mb_y, |
182 |
|
|
const uint8_t *buf, int buf_size) |
183 |
|
|
{ |
184 |
|
|
int i, mb_x, q, ret; |
185 |
|
|
int off; |
186 |
|
|
|
187 |
✗✓ |
1084 |
if ((ret = init_get_bits8(&c->gb, buf, buf_size)) < 0) |
188 |
|
|
return ret; |
189 |
|
|
|
190 |
✓✓ |
34860 |
for (mb_x = 0; mb_x < c->mb_width; mb_x++) { |
191 |
|
33776 |
q = c->slice_quants[mb_x + c->mb_width * mb_y]; |
192 |
|
|
|
193 |
✓✓✗✓
|
33776 |
if (q == 0 || q == 3) // skip block |
194 |
|
11729 |
continue; |
195 |
✓✓ |
88188 |
for (i = 0; i < 3; i++) { |
196 |
|
66141 |
off = mb_x * 16 + mb_y * 8 * c->pic->linesize[i]; |
197 |
|
66141 |
ret = tscc2_decode_mb(c, c->q[q - 1], c->quant[q - 1] - 2, |
198 |
|
66141 |
c->pic->data[i] + off, c->pic->linesize[i], i); |
199 |
✗✓ |
66141 |
if (ret) |
200 |
|
|
return ret; |
201 |
|
|
} |
202 |
|
|
} |
203 |
|
|
|
204 |
|
1084 |
return 0; |
205 |
|
|
} |
206 |
|
|
|
207 |
|
48 |
static int tscc2_decode_frame(AVCodecContext *avctx, void *data, |
208 |
|
|
int *got_frame, AVPacket *avpkt) |
209 |
|
|
{ |
210 |
|
48 |
const uint8_t *buf = avpkt->data; |
211 |
|
48 |
int buf_size = avpkt->size; |
212 |
|
48 |
TSCC2Context *c = avctx->priv_data; |
213 |
|
|
GetByteContext gb; |
214 |
|
|
uint32_t frame_type, size; |
215 |
|
48 |
int i, val, len, pos = 0; |
216 |
|
48 |
int num_mb = c->mb_width * c->mb_height; |
217 |
|
|
int ret; |
218 |
|
|
|
219 |
|
48 |
bytestream2_init(&gb, buf, buf_size); |
220 |
|
48 |
frame_type = bytestream2_get_byte(&gb); |
221 |
✗✓ |
48 |
if (frame_type > 1) { |
222 |
|
|
av_log(avctx, AV_LOG_ERROR, "Incorrect frame type %"PRIu32"\n", |
223 |
|
|
frame_type); |
224 |
|
|
return AVERROR_INVALIDDATA; |
225 |
|
|
} |
226 |
|
|
|
227 |
✓✓ |
48 |
if (frame_type == 0) { |
228 |
|
|
// Skip duplicate frames |
229 |
|
17 |
return buf_size; |
230 |
|
|
} |
231 |
|
|
|
232 |
✗✓ |
31 |
if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0) { |
233 |
|
|
return ret; |
234 |
|
|
} |
235 |
|
|
|
236 |
✗✓ |
31 |
if (bytestream2_get_bytes_left(&gb) < 4) { |
237 |
|
|
av_log(avctx, AV_LOG_ERROR, "Frame is too short\n"); |
238 |
|
|
return AVERROR_INVALIDDATA; |
239 |
|
|
} |
240 |
|
|
|
241 |
|
31 |
c->quant[0] = bytestream2_get_byte(&gb); |
242 |
|
31 |
c->quant[1] = bytestream2_get_byte(&gb); |
243 |
✓✗✓✗
|
31 |
if (c->quant[0] < 2 || c->quant[0] > NUM_VLC_SETS + 1 || |
244 |
✓✗✗✓
|
31 |
c->quant[1] < 2 || c->quant[1] > NUM_VLC_SETS + 1) { |
245 |
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid quantisers %d / %d\n", |
246 |
|
|
c->quant[0], c->quant[1]); |
247 |
|
|
return AVERROR_INVALIDDATA; |
248 |
|
|
} |
249 |
|
|
|
250 |
✓✓ |
124 |
for (i = 0; i < 3; i++) { |
251 |
|
93 |
c->q[0][i] = tscc2_quants[c->quant[0] - 2][i]; |
252 |
|
93 |
c->q[1][i] = tscc2_quants[c->quant[1] - 2][i]; |
253 |
|
|
} |
254 |
|
|
|
255 |
|
31 |
bytestream2_skip(&gb, 1); |
256 |
|
|
|
257 |
|
31 |
size = bytestream2_get_le32(&gb); |
258 |
✗✓ |
31 |
if (size > bytestream2_get_bytes_left(&gb)) { |
259 |
|
|
av_log(avctx, AV_LOG_ERROR, "Slice properties chunk is too large\n"); |
260 |
|
|
return AVERROR_INVALIDDATA; |
261 |
|
|
} |
262 |
|
|
|
263 |
✓✓ |
3319 |
for (i = 0; i < size; i++) { |
264 |
|
3288 |
val = bytestream2_get_byte(&gb); |
265 |
|
3288 |
len = val & 0x3F; |
266 |
|
3288 |
val >>= 6; |
267 |
✗✓ |
3288 |
if (pos + len > num_mb) { |
268 |
|
|
av_log(avctx, AV_LOG_ERROR, "Too many slice properties\n"); |
269 |
|
|
return AVERROR_INVALIDDATA; |
270 |
|
|
} |
271 |
|
3288 |
memset(c->slice_quants + pos, val, len); |
272 |
|
3288 |
pos += len; |
273 |
|
|
} |
274 |
✗✓ |
31 |
if (pos < num_mb) { |
275 |
|
|
av_log(avctx, AV_LOG_ERROR, "Too few slice properties (%d / %d)\n", |
276 |
|
|
pos, num_mb); |
277 |
|
|
return AVERROR_INVALIDDATA; |
278 |
|
|
} |
279 |
|
|
|
280 |
✓✓ |
1115 |
for (i = 0; i < c->mb_height; i++) { |
281 |
|
1085 |
size = bytestream2_peek_byte(&gb); |
282 |
✓✓ |
1085 |
if (size & 1) { |
283 |
|
103 |
size = bytestream2_get_byte(&gb) - 1; |
284 |
|
|
} else { |
285 |
|
982 |
size = bytestream2_get_le32(&gb) >> 1; |
286 |
|
|
} |
287 |
✓✓ |
1085 |
if (!size) { |
288 |
|
103 |
int skip_row = 1, j, off = i * c->mb_width; |
289 |
✓✓ |
5871 |
for (j = 0; j < c->mb_width; j++) { |
290 |
✓✗ |
5768 |
if (c->slice_quants[off + j] == 1 || |
291 |
✗✓ |
5768 |
c->slice_quants[off + j] == 2) { |
292 |
|
|
skip_row = 0; |
293 |
|
|
break; |
294 |
|
|
} |
295 |
|
|
} |
296 |
✗✓ |
103 |
if (!skip_row) { |
297 |
|
|
av_log(avctx, AV_LOG_ERROR, "Non-skip row with zero size\n"); |
298 |
|
|
return AVERROR_INVALIDDATA; |
299 |
|
|
} |
300 |
|
|
} |
301 |
✓✓ |
1085 |
if (bytestream2_get_bytes_left(&gb) < size) { |
302 |
|
1 |
av_log(avctx, AV_LOG_ERROR, "Invalid slice size (%"PRIu32"/%u)\n", |
303 |
|
|
size, bytestream2_get_bytes_left(&gb)); |
304 |
|
1 |
return AVERROR_INVALIDDATA; |
305 |
|
|
} |
306 |
|
1084 |
ret = tscc2_decode_slice(c, i, buf + bytestream2_tell(&gb), size); |
307 |
✗✓ |
1084 |
if (ret) { |
308 |
|
|
av_log(avctx, AV_LOG_ERROR, "Error decoding slice %d\n", i); |
309 |
|
|
return ret; |
310 |
|
|
} |
311 |
|
1084 |
bytestream2_skip(&gb, size); |
312 |
|
|
} |
313 |
|
|
|
314 |
|
30 |
*got_frame = 1; |
315 |
✗✓ |
30 |
if ((ret = av_frame_ref(data, c->pic)) < 0) |
316 |
|
|
return ret; |
317 |
|
|
|
318 |
|
|
/* always report that the buffer was completely consumed */ |
319 |
|
30 |
return buf_size; |
320 |
|
|
} |
321 |
|
|
|
322 |
|
4 |
static av_cold int tscc2_decode_end(AVCodecContext *avctx) |
323 |
|
|
{ |
324 |
|
4 |
TSCC2Context * const c = avctx->priv_data; |
325 |
|
|
|
326 |
|
4 |
av_frame_free(&c->pic); |
327 |
|
4 |
av_freep(&c->slice_quants); |
328 |
|
|
|
329 |
|
4 |
return 0; |
330 |
|
|
} |
331 |
|
|
|
332 |
|
4 |
static av_cold int tscc2_decode_init(AVCodecContext *avctx) |
333 |
|
|
{ |
334 |
|
4 |
TSCC2Context * const c = avctx->priv_data; |
335 |
|
|
static AVOnce init_static_once = AV_ONCE_INIT; |
336 |
|
|
|
337 |
|
4 |
c->avctx = avctx; |
338 |
|
|
|
339 |
|
4 |
avctx->pix_fmt = AV_PIX_FMT_YUV444P; |
340 |
|
|
|
341 |
|
4 |
c->mb_width = FFALIGN(avctx->width, 16) >> 4; |
342 |
|
4 |
c->mb_height = FFALIGN(avctx->height, 8) >> 3; |
343 |
|
4 |
c->slice_quants = av_malloc(c->mb_width * c->mb_height); |
344 |
✗✓ |
4 |
if (!c->slice_quants) { |
345 |
|
|
av_log(avctx, AV_LOG_ERROR, "Cannot allocate slice information\n"); |
346 |
|
|
return AVERROR(ENOMEM); |
347 |
|
|
} |
348 |
|
|
|
349 |
|
4 |
c->pic = av_frame_alloc(); |
350 |
✗✓ |
4 |
if (!c->pic) |
351 |
|
|
return AVERROR(ENOMEM); |
352 |
|
|
|
353 |
|
4 |
ff_thread_once(&init_static_once, tscc2_init_vlcs); |
354 |
|
|
|
355 |
|
4 |
return 0; |
356 |
|
|
} |
357 |
|
|
|
358 |
|
|
AVCodec ff_tscc2_decoder = { |
359 |
|
|
.name = "tscc2", |
360 |
|
|
.long_name = NULL_IF_CONFIG_SMALL("TechSmith Screen Codec 2"), |
361 |
|
|
.type = AVMEDIA_TYPE_VIDEO, |
362 |
|
|
.id = AV_CODEC_ID_TSCC2, |
363 |
|
|
.priv_data_size = sizeof(TSCC2Context), |
364 |
|
|
.init = tscc2_decode_init, |
365 |
|
|
.close = tscc2_decode_end, |
366 |
|
|
.decode = tscc2_decode_frame, |
367 |
|
|
.capabilities = AV_CODEC_CAP_DR1, |
368 |
|
|
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE, |
369 |
|
|
}; |