avcodec/scpr: add version 3 support
[ffmpeg.git] / libavcodec / scpr.h
1 /*
2  * ScreenPressor decoder
3  *
4  * Copyright (c) 2017 Paul B Mahol
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 #ifndef AVCODEC_SCPR_H
24 #define AVCODEC_SCPR_H
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "internal.h"
33 #include "scpr3.h"
34
35 typedef struct RangeCoder {
36     uint32_t   code;
37     uint32_t   range;
38     uint32_t   code1;
39 } RangeCoder;
40
41 typedef struct PixelModel {
42     uint32_t    freq[256];
43     uint32_t    lookup[16];
44     uint32_t    total_freq;
45 } PixelModel;
46
47 typedef struct SCPRContext {
48     int             version;
49     AVFrame        *last_frame;
50     AVFrame        *current_frame;
51     GetByteContext  gb;
52     RangeCoder      rc;
53     PixelModel      pixel_model[3][4096];
54     uint32_t        op_model[6][7];
55     uint32_t        run_model[6][257];
56     uint32_t        range_model[257];
57     uint32_t        count_model[257];
58     uint32_t        fill_model[6];
59     uint32_t        sxy_model[4][17];
60     uint32_t        mv_model[2][513];
61     uint32_t        nbx, nby;
62     uint32_t        nbcount;
63     uint32_t       *blocks;
64     uint32_t        cbits;
65     int             cxshift;
66
67     PixelModel3     pixel_model3[3][4096];
68     RunModel3       run_model3[6];
69     RunModel3       range_model3;
70     RunModel3       count_model3;
71     FillModel3      fill_model3;
72     SxyModel3       sxy_model3[4];
73     MVModel3        mv_model3[2];
74     OpModel3        op_model3[6];
75
76     int           (*get_freq)(RangeCoder *rc, uint32_t total_freq, uint32_t *freq);
77     int           (*decode)(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq);
78 } SCPRContext;
79
80 static int decode_run_i(AVCodecContext *avctx, uint32_t ptype, int run,
81                         int *x, int *y, uint32_t clr, uint32_t *dst,
82                         int linesize, uint32_t *lx, uint32_t *ly,
83                         uint32_t backstep, int off, int *cx, int *cx1)
84 {
85     uint32_t r, g, b;
86     int z;
87
88     switch (ptype) {
89     case 0:
90         while (run-- > 0) {
91             if (*y >= avctx->height)
92                 return AVERROR_INVALIDDATA;
93
94             dst[*y * linesize + *x] = clr;
95             *lx = *x;
96             *ly = *y;
97             (*x)++;
98             if (*x >= avctx->width) {
99                 *x = 0;
100                 (*y)++;
101             }
102         }
103         break;
104     case 1:
105         while (run-- > 0) {
106             if (*y >= avctx->height)
107                 return AVERROR_INVALIDDATA;
108
109             dst[*y * linesize + *x] = dst[*ly * linesize + *lx];
110             *lx = *x;
111             *ly = *y;
112             (*x)++;
113             if (*x >= avctx->width) {
114                 *x = 0;
115                 (*y)++;
116             }
117         }
118         clr = dst[*ly * linesize + *lx];
119         break;
120     case 2:
121         while (run-- > 0) {
122             if (*y < 1 || *y >= avctx->height)
123                 return AVERROR_INVALIDDATA;
124
125             clr = dst[*y * linesize + *x + off + 1];
126             dst[*y * linesize + *x] = clr;
127             *lx = *x;
128             *ly = *y;
129             (*x)++;
130             if (*x >= avctx->width) {
131                 *x = 0;
132                 (*y)++;
133             }
134         }
135         break;
136     case 4:
137         while (run-- > 0) {
138             uint8_t *odst = (uint8_t *)dst;
139
140             if (*y < 1 || *y >= avctx->height ||
141                 (*y == 1 && *x == 0))
142                 return AVERROR_INVALIDDATA;
143
144             if (*x == 0) {
145                 z = backstep;
146             } else {
147                 z = 0;
148             }
149
150             r = odst[(*ly * linesize + *lx) * 4] +
151                 odst[((*y * linesize + *x) + off) * 4 + 4] -
152                 odst[((*y * linesize + *x) + off - z) * 4];
153             g = odst[(*ly * linesize + *lx) * 4 + 1] +
154                 odst[((*y * linesize + *x) + off) * 4 + 5] -
155                 odst[((*y * linesize + *x) + off - z) * 4 + 1];
156             b = odst[(*ly * linesize + *lx) * 4 + 2] +
157                 odst[((*y * linesize + *x) + off) * 4 + 6] -
158                 odst[((*y * linesize + *x) + off - z) * 4 + 2];
159             clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);
160             dst[*y * linesize + *x] = clr;
161             *lx = *x;
162             *ly = *y;
163             (*x)++;
164             if (*x >= avctx->width) {
165                 *x = 0;
166                 (*y)++;
167             }
168         }
169         break;
170     case 5:
171         while (run-- > 0) {
172             if (*y < 1 || *y >= avctx->height ||
173                 (*y == 1 && *x == 0))
174                 return AVERROR_INVALIDDATA;
175
176             if (*x == 0) {
177                 z = backstep;
178             } else {
179                 z = 0;
180             }
181
182             clr = dst[*y * linesize + *x + off - z];
183             dst[*y * linesize + *x] = clr;
184             *lx = *x;
185             *ly = *y;
186             (*x)++;
187             if (*x >= avctx->width) {
188                 *x = 0;
189                 (*y)++;
190             }
191         }
192         break;
193     }
194
195     if (avctx->bits_per_coded_sample == 16) {
196         *cx1 = (clr & 0x3F00) >> 2;
197         *cx = (clr & 0x3FFFFF) >> 16;
198     } else {
199         *cx1 = (clr & 0xFC00) >> 4;
200         *cx = (clr & 0xFFFFFF) >> 18;
201     }
202
203     return 0;
204 }
205
206 static int decode_run_p(AVCodecContext *avctx, uint32_t ptype, int run,
207                         int x, int y, uint32_t clr,
208                         uint32_t *dst, uint32_t *prev,
209                         int linesize, int plinesize,
210                         uint32_t *bx, uint32_t *by,
211                         uint32_t backstep, int sx1, int sx2,
212                         int *cx, int *cx1)
213 {
214     uint32_t r, g, b;
215     int z;
216
217     switch (ptype) {
218     case 0:
219         while (run-- > 0) {
220             if (*by >= avctx->height)
221                 return AVERROR_INVALIDDATA;
222
223             dst[*by * linesize + *bx] = clr;
224             (*bx)++;
225             if (*bx >= x * 16 + sx2 || *bx >= avctx->width) {
226                 *bx = x * 16 + sx1;
227                 (*by)++;
228             }
229         }
230         break;
231     case 1:
232         while (run-- > 0) {
233             if (*bx == 0) {
234                 if (*by < 1)
235                     return AVERROR_INVALIDDATA;
236                 z = backstep;
237             } else {
238                 z = 0;
239             }
240
241             if (*by >= avctx->height)
242                 return AVERROR_INVALIDDATA;
243
244             clr = dst[*by * linesize + *bx - 1 - z];
245             dst[*by * linesize + *bx] = clr;
246             (*bx)++;
247             if (*bx >= x * 16 + sx2 || *bx >= avctx->width) {
248                 *bx = x * 16 + sx1;
249                 (*by)++;
250             }
251         }
252         break;
253     case 2:
254         while (run-- > 0) {
255             if (*by < 1 || *by >= avctx->height)
256                 return AVERROR_INVALIDDATA;
257
258             clr = dst[(*by - 1) * linesize + *bx];
259             dst[*by * linesize + *bx] = clr;
260             (*bx)++;
261             if (*bx >= x * 16 + sx2 || *bx >= avctx->width) {
262                 *bx = x * 16 + sx1;
263                 (*by)++;
264             }
265         }
266         break;
267     case 3:
268         while (run-- > 0) {
269             if (*by >= avctx->height)
270                 return AVERROR_INVALIDDATA;
271
272             clr = prev[*by * plinesize + *bx];
273             dst[*by * linesize + *bx] = clr;
274             (*bx)++;
275             if (*bx >= x * 16 + sx2 || *bx >= avctx->width) {
276                 *bx = x * 16 + sx1;
277                 (*by)++;
278             }
279         }
280         break;
281     case 4:
282         while (run-- > 0) {
283             uint8_t *odst = (uint8_t *)dst;
284
285             if (*by < 1 || *by >= avctx->height)
286                 return AVERROR_INVALIDDATA;
287
288             if (*bx == 0) {
289                 if (*by < 2)
290                     return AVERROR_INVALIDDATA;
291                 z = backstep;
292             } else {
293                 z = 0;
294             }
295
296             r = odst[((*by - 1) * linesize + *bx) * 4] +
297                 odst[(*by * linesize + *bx - 1 - z) * 4] -
298                 odst[((*by - 1) * linesize + *bx - 1 - z) * 4];
299             g = odst[((*by - 1) * linesize + *bx) * 4 + 1] +
300                 odst[(*by * linesize + *bx - 1 - z) * 4 + 1] -
301                 odst[((*by - 1) * linesize + *bx - 1 - z) * 4 + 1];
302             b = odst[((*by - 1) * linesize + *bx) * 4 + 2] +
303                 odst[(*by * linesize + *bx - 1 - z) * 4 + 2] -
304                 odst[((*by - 1) * linesize + *bx - 1 - z) * 4 + 2];
305             clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);
306             dst[*by * linesize + *bx] = clr;
307             (*bx)++;
308             if (*bx >= x * 16 + sx2 || *bx >= avctx->width) {
309                 *bx = x * 16 + sx1;
310                 (*by)++;
311             }
312         }
313         break;
314     case 5:
315         while (run-- > 0) {
316             if (*by < 1 || *by >= avctx->height)
317                 return AVERROR_INVALIDDATA;
318
319             if (*bx == 0) {
320                 if (*by < 2)
321                     return AVERROR_INVALIDDATA;
322                 z = backstep;
323             } else {
324                 z = 0;
325             }
326
327             clr = dst[(*by - 1) * linesize + *bx - 1 - z];
328             dst[*by * linesize + *bx] = clr;
329             (*bx)++;
330             if (*bx >= x * 16 + sx2 || *bx >= avctx->width) {
331                 *bx = x * 16 + sx1;
332                 (*by)++;
333             }
334         }
335         break;
336     }
337
338     if (avctx->bits_per_coded_sample == 16) {
339         *cx1 = (clr & 0x3F00) >> 2;
340         *cx = (clr & 0x3FFFFF) >> 16;
341     } else {
342         *cx1 = (clr & 0xFC00) >> 4;
343         *cx = (clr & 0xFFFFFF) >> 18;
344     }
345
346     return 0;
347 }
348
349 #endif /* AVCODEC_SCPR_H */