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