FFmpeg
sanm.c
Go to the documentation of this file.
1 /*
2  * LucasArts Smush video decoder
3  * Copyright (c) 2006 Cyril Zorin
4  * Copyright (c) 2011 Konstantin Shishkov
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 #include "libavutil/avassert.h"
24 #include "libavutil/mem.h"
25 
26 #include "avcodec.h"
27 #include "bytestream.h"
28 #include "copy_block.h"
29 #include "codec_internal.h"
30 #include "decode.h"
31 
32 #define NGLYPHS 256
33 #define GLYPH_COORD_VECT_SIZE 16
34 #define PALETTE_SIZE 256
35 #define PALETTE_DELTA 768
36 
37 static const int8_t glyph4_x[GLYPH_COORD_VECT_SIZE] = {
38  0, 1, 2, 3, 3, 3, 3, 2, 1, 0, 0, 0, 1, 2, 2, 1
39 };
40 
41 static const int8_t glyph4_y[GLYPH_COORD_VECT_SIZE] = {
42  0, 0, 0, 0, 1, 2, 3, 3, 3, 3, 2, 1, 1, 1, 2, 2
43 };
44 
45 static const int8_t glyph8_x[GLYPH_COORD_VECT_SIZE] = {
46  0, 2, 5, 7, 7, 7, 7, 7, 7, 5, 2, 0, 0, 0, 0, 0
47 };
48 
49 static const int8_t glyph8_y[GLYPH_COORD_VECT_SIZE] = {
50  0, 0, 0, 0, 1, 3, 4, 6, 7, 7, 7, 7, 6, 4, 3, 1
51 };
52 
53 /* codec47/bl16 motion vectors */
54 static const int8_t c47_mv[256][2] = {
55  { 0, 0 }, { -1, -43 }, { 6, -43 }, { -9, -42 }, { 13, -41 },
56  { -16, -40 }, { 19, -39 }, { -23, -36 }, { 26, -34 }, { -2, -33 },
57  { 4, -33 }, { -29, -32 }, { -9, -32 }, { 11, -31 }, { -16, -29 },
58  { 32, -29 }, { 18, -28 }, { -34, -26 }, { -22, -25 }, { -1, -25 },
59  { 3, -25 }, { -7, -24 }, { 8, -24 }, { 24, -23 }, { 36, -23 },
60  { -12, -22 }, { 13, -21 }, { -38, -20 }, { 0, -20 }, { -27, -19 },
61  { -4, -19 }, { 4, -19 }, { -17, -18 }, { -8, -17 }, { 8, -17 },
62  { 18, -17 }, { 28, -17 }, { 39, -17 }, { -12, -15 }, { 12, -15 },
63  { -21, -14 }, { -1, -14 }, { 1, -14 }, { -41, -13 }, { -5, -13 },
64  { 5, -13 }, { 21, -13 }, { -31, -12 }, { -15, -11 }, { -8, -11 },
65  { 8, -11 }, { 15, -11 }, { -2, -10 }, { 1, -10 }, { 31, -10 },
66  { -23, -9 }, { -11, -9 }, { -5, -9 }, { 4, -9 }, { 11, -9 },
67  { 42, -9 }, { 6, -8 }, { 24, -8 }, { -18, -7 }, { -7, -7 },
68  { -3, -7 }, { -1, -7 }, { 2, -7 }, { 18, -7 }, { -43, -6 },
69  { -13, -6 }, { -4, -6 }, { 4, -6 }, { 8, -6 }, { -33, -5 },
70  { -9, -5 }, { -2, -5 }, { 0, -5 }, { 2, -5 }, { 5, -5 },
71  { 13, -5 }, { -25, -4 }, { -6, -4 }, { -3, -4 }, { 3, -4 },
72  { 9, -4 }, { -19, -3 }, { -7, -3 }, { -4, -3 }, { -2, -3 },
73  { -1, -3 }, { 0, -3 }, { 1, -3 }, { 2, -3 }, { 4, -3 },
74  { 6, -3 }, { 33, -3 }, { -14, -2 }, { -10, -2 }, { -5, -2 },
75  { -3, -2 }, { -2, -2 }, { -1, -2 }, { 0, -2 }, { 1, -2 },
76  { 2, -2 }, { 3, -2 }, { 5, -2 }, { 7, -2 }, { 14, -2 },
77  { 19, -2 }, { 25, -2 }, { 43, -2 }, { -7, -1 }, { -3, -1 },
78  { -2, -1 }, { -1, -1 }, { 0, -1 }, { 1, -1 }, { 2, -1 },
79  { 3, -1 }, { 10, -1 }, { -5, 0 }, { -3, 0 }, { -2, 0 },
80  { -1, 0 }, { 1, 0 }, { 2, 0 }, { 3, 0 }, { 5, 0 },
81  { 7, 0 }, { -10, 1 }, { -7, 1 }, { -3, 1 }, { -2, 1 },
82  { -1, 1 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 3, 1 },
83  { -43, 2 }, { -25, 2 }, { -19, 2 }, { -14, 2 }, { -5, 2 },
84  { -3, 2 }, { -2, 2 }, { -1, 2 }, { 0, 2 }, { 1, 2 },
85  { 2, 2 }, { 3, 2 }, { 5, 2 }, { 7, 2 }, { 10, 2 },
86  { 14, 2 }, { -33, 3 }, { -6, 3 }, { -4, 3 }, { -2, 3 },
87  { -1, 3 }, { 0, 3 }, { 1, 3 }, { 2, 3 }, { 4, 3 },
88  { 19, 3 }, { -9, 4 }, { -3, 4 }, { 3, 4 }, { 7, 4 },
89  { 25, 4 }, { -13, 5 }, { -5, 5 }, { -2, 5 }, { 0, 5 },
90  { 2, 5 }, { 5, 5 }, { 9, 5 }, { 33, 5 }, { -8, 6 },
91  { -4, 6 }, { 4, 6 }, { 13, 6 }, { 43, 6 }, { -18, 7 },
92  { -2, 7 }, { 0, 7 }, { 2, 7 }, { 7, 7 }, { 18, 7 },
93  { -24, 8 }, { -6, 8 }, { -42, 9 }, { -11, 9 }, { -4, 9 },
94  { 5, 9 }, { 11, 9 }, { 23, 9 }, { -31, 10 }, { -1, 10 },
95  { 2, 10 }, { -15, 11 }, { -8, 11 }, { 8, 11 }, { 15, 11 },
96  { 31, 12 }, { -21, 13 }, { -5, 13 }, { 5, 13 }, { 41, 13 },
97  { -1, 14 }, { 1, 14 }, { 21, 14 }, { -12, 15 }, { 12, 15 },
98  { -39, 17 }, { -28, 17 }, { -18, 17 }, { -8, 17 }, { 8, 17 },
99  { 17, 18 }, { -4, 19 }, { 0, 19 }, { 4, 19 }, { 27, 19 },
100  { 38, 20 }, { -13, 21 }, { 12, 22 }, { -36, 23 }, { -24, 23 },
101  { -8, 24 }, { 7, 24 }, { -3, 25 }, { 1, 25 }, { 22, 25 },
102  { 34, 26 }, { -18, 28 }, { -32, 29 }, { 16, 29 }, { -11, 31 },
103  { 9, 32 }, { 29, 32 }, { -4, 33 }, { 2, 33 }, { -26, 34 },
104  { 23, 36 }, { -19, 39 }, { 16, 40 }, { -13, 41 }, { 9, 42 },
105  { -6, 43 }, { 1, 43 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
106 };
107 
108 /* codec37/48 motion vector tables: 3x 510 bytes/255 x-y pairs */
109 static const int8_t c37_mv[] = {
110  0, 0, 1, 0, 2, 0, 3, 0, 5, 0,
111  8, 0, 13, 0, 21, 0, -1, 0, -2, 0,
112  -3, 0, -5, 0, -8, 0, -13, 0, -17, 0,
113  -21, 0, 0, 1, 1, 1, 2, 1, 3, 1,
114  5, 1, 8, 1, 13, 1, 21, 1, -1, 1,
115  -2, 1, -3, 1, -5, 1, -8, 1, -13, 1,
116  -17, 1, -21, 1, 0, 2, 1, 2, 2, 2,
117  3, 2, 5, 2, 8, 2, 13, 2, 21, 2,
118  -1, 2, -2, 2, -3, 2, -5, 2, -8, 2,
119  -13, 2, -17, 2, -21, 2, 0, 3, 1, 3,
120  2, 3, 3, 3, 5, 3, 8, 3, 13, 3,
121  21, 3, -1, 3, -2, 3, -3, 3, -5, 3,
122  -8, 3, -13, 3, -17, 3, -21, 3, 0, 5,
123  1, 5, 2, 5, 3, 5, 5, 5, 8, 5,
124  13, 5, 21, 5, -1, 5, -2, 5, -3, 5,
125  -5, 5, -8, 5, -13, 5, -17, 5, -21, 5,
126  0, 8, 1, 8, 2, 8, 3, 8, 5, 8,
127  8, 8, 13, 8, 21, 8, -1, 8, -2, 8,
128  -3, 8, -5, 8, -8, 8, -13, 8, -17, 8,
129  -21, 8, 0, 13, 1, 13, 2, 13, 3, 13,
130  5, 13, 8, 13, 13, 13, 21, 13, -1, 13,
131  -2, 13, -3, 13, -5, 13, -8, 13, -13, 13,
132  -17, 13, -21, 13, 0, 21, 1, 21, 2, 21,
133  3, 21, 5, 21, 8, 21, 13, 21, 21, 21,
134  -1, 21, -2, 21, -3, 21, -5, 21, -8, 21,
135  -13, 21, -17, 21, -21, 21, 0, -1, 1, -1,
136  2, -1, 3, -1, 5, -1, 8, -1, 13, -1,
137  21, -1, -1, -1, -2, -1, -3, -1, -5, -1,
138  -8, -1, -13, -1, -17, -1, -21, -1, 0, -2,
139  1, -2, 2, -2, 3, -2, 5, -2, 8, -2,
140  13, -2, 21, -2, -1, -2, -2, -2, -3, -2,
141  -5, -2, -8, -2, -13, -2, -17, -2, -21, -2,
142  0, -3, 1, -3, 2, -3, 3, -3, 5, -3,
143  8, -3, 13, -3, 21, -3, -1, -3, -2, -3,
144  -3, -3, -5, -3, -8, -3, -13, -3, -17, -3,
145  -21, -3, 0, -5, 1, -5, 2, -5, 3, -5,
146  5, -5, 8, -5, 13, -5, 21, -5, -1, -5,
147  -2, -5, -3, -5, -5, -5, -8, -5, -13, -5,
148  -17, -5, -21, -5, 0, -8, 1, -8, 2, -8,
149  3, -8, 5, -8, 8, -8, 13, -8, 21, -8,
150  -1, -8, -2, -8, -3, -8, -5, -8, -8, -8,
151  -13, -8, -17, -8, -21, -8, 0, -13, 1, -13,
152  2, -13, 3, -13, 5, -13, 8, -13, 13, -13,
153  21, -13, -1, -13, -2, -13, -3, -13, -5, -13,
154  -8, -13, -13, -13, -17, -13, -21, -13, 0, -17,
155  1, -17, 2, -17, 3, -17, 5, -17, 8, -17,
156  13, -17, 21, -17, -1, -17, -2, -17, -3, -17,
157  -5, -17, -8, -17, -13, -17, -17, -17, -21, -17,
158  0, -21, 1, -21, 2, -21, 3, -21, 5, -21,
159  8, -21, 13, -21, 21, -21, -1, -21, -2, -21,
160  -3, -21, -5, -21, -8, -21, -13, -21, -17, -21,
161  0, 0, -8, -29, 8, -29, -18, -25, 17, -25,
162  0, -23, -6, -22, 6, -22, -13, -19, 12, -19,
163  0, -18, 25, -18, -25, -17, -5, -17, 5, -17,
164  -10, -15, 10, -15, 0, -14, -4, -13, 4, -13,
165  19, -13, -19, -12, -8, -11, -2, -11, 0, -11,
166  2, -11, 8, -11, -15, -10, -4, -10, 4, -10,
167  15, -10, -6, -9, -1, -9, 1, -9, 6, -9,
168  -29, -8, -11, -8, -8, -8, -3, -8, 3, -8,
169  8, -8, 11, -8, 29, -8, -5, -7, -2, -7,
170  0, -7, 2, -7, 5, -7, -22, -6, -9, -6,
171  -6, -6, -3, -6, -1, -6, 1, -6, 3, -6,
172  6, -6, 9, -6, 22, -6, -17, -5, -7, -5,
173  -4, -5, -2, -5, 0, -5, 2, -5, 4, -5,
174  7, -5, 17, -5, -13, -4, -10, -4, -5, -4,
175  -3, -4, -1, -4, 0, -4, 1, -4, 3, -4,
176  5, -4, 10, -4, 13, -4, -8, -3, -6, -3,
177  -4, -3, -3, -3, -2, -3, -1, -3, 0, -3,
178  1, -3, 2, -3, 4, -3, 6, -3, 8, -3,
179  -11, -2, -7, -2, -5, -2, -3, -2, -2, -2,
180  -1, -2, 0, -2, 1, -2, 2, -2, 3, -2,
181  5, -2, 7, -2, 11, -2, -9, -1, -6, -1,
182  -4, -1, -3, -1, -2, -1, -1, -1, 0, -1,
183  1, -1, 2, -1, 3, -1, 4, -1, 6, -1,
184  9, -1, -31, 0, -23, 0, -18, 0, -14, 0,
185  -11, 0, -7, 0, -5, 0, -4, 0, -3, 0,
186  -2, 0, -1, 0, 0, -31, 1, 0, 2, 0,
187  3, 0, 4, 0, 5, 0, 7, 0, 11, 0,
188  14, 0, 18, 0, 23, 0, 31, 0, -9, 1,
189  -6, 1, -4, 1, -3, 1, -2, 1, -1, 1,
190  0, 1, 1, 1, 2, 1, 3, 1, 4, 1,
191  6, 1, 9, 1, -11, 2, -7, 2, -5, 2,
192  -3, 2, -2, 2, -1, 2, 0, 2, 1, 2,
193  2, 2, 3, 2, 5, 2, 7, 2, 11, 2,
194  -8, 3, -6, 3, -4, 3, -2, 3, -1, 3,
195  0, 3, 1, 3, 2, 3, 3, 3, 4, 3,
196  6, 3, 8, 3, -13, 4, -10, 4, -5, 4,
197  -3, 4, -1, 4, 0, 4, 1, 4, 3, 4,
198  5, 4, 10, 4, 13, 4, -17, 5, -7, 5,
199  -4, 5, -2, 5, 0, 5, 2, 5, 4, 5,
200  7, 5, 17, 5, -22, 6, -9, 6, -6, 6,
201  -3, 6, -1, 6, 1, 6, 3, 6, 6, 6,
202  9, 6, 22, 6, -5, 7, -2, 7, 0, 7,
203  2, 7, 5, 7, -29, 8, -11, 8, -8, 8,
204  -3, 8, 3, 8, 8, 8, 11, 8, 29, 8,
205  -6, 9, -1, 9, 1, 9, 6, 9, -15, 10,
206  -4, 10, 4, 10, 15, 10, -8, 11, -2, 11,
207  0, 11, 2, 11, 8, 11, 19, 12, -19, 13,
208  -4, 13, 4, 13, 0, 14, -10, 15, 10, 15,
209  -5, 17, 5, 17, 25, 17, -25, 18, 0, 18,
210  -12, 19, 13, 19, -6, 22, 6, 22, 0, 23,
211  -17, 25, 18, 25, -8, 29, 8, 29, 0, 31,
212  0, 0, -6, -22, 6, -22, -13, -19, 12, -19,
213  0, -18, -5, -17, 5, -17, -10, -15, 10, -15,
214  0, -14, -4, -13, 4, -13, 19, -13, -19, -12,
215  -8, -11, -2, -11, 0, -11, 2, -11, 8, -11,
216  -15, -10, -4, -10, 4, -10, 15, -10, -6, -9,
217  -1, -9, 1, -9, 6, -9, -11, -8, -8, -8,
218  -3, -8, 0, -8, 3, -8, 8, -8, 11, -8,
219  -5, -7, -2, -7, 0, -7, 2, -7, 5, -7,
220  -22, -6, -9, -6, -6, -6, -3, -6, -1, -6,
221  1, -6, 3, -6, 6, -6, 9, -6, 22, -6,
222  -17, -5, -7, -5, -4, -5, -2, -5, -1, -5,
223  0, -5, 1, -5, 2, -5, 4, -5, 7, -5,
224  17, -5, -13, -4, -10, -4, -5, -4, -3, -4,
225  -2, -4, -1, -4, 0, -4, 1, -4, 2, -4,
226  3, -4, 5, -4, 10, -4, 13, -4, -8, -3,
227  -6, -3, -4, -3, -3, -3, -2, -3, -1, -3,
228  0, -3, 1, -3, 2, -3, 3, -3, 4, -3,
229  6, -3, 8, -3, -11, -2, -7, -2, -5, -2,
230  -4, -2, -3, -2, -2, -2, -1, -2, 0, -2,
231  1, -2, 2, -2, 3, -2, 4, -2, 5, -2,
232  7, -2, 11, -2, -9, -1, -6, -1, -5, -1,
233  -4, -1, -3, -1, -2, -1, -1, -1, 0, -1,
234  1, -1, 2, -1, 3, -1, 4, -1, 5, -1,
235  6, -1, 9, -1, -23, 0, -18, 0, -14, 0,
236  -11, 0, -7, 0, -5, 0, -4, 0, -3, 0,
237  -2, 0, -1, 0, 0, -23, 1, 0, 2, 0,
238  3, 0, 4, 0, 5, 0, 7, 0, 11, 0,
239  14, 0, 18, 0, 23, 0, -9, 1, -6, 1,
240  -5, 1, -4, 1, -3, 1, -2, 1, -1, 1,
241  0, 1, 1, 1, 2, 1, 3, 1, 4, 1,
242  5, 1, 6, 1, 9, 1, -11, 2, -7, 2,
243  -5, 2, -4, 2, -3, 2, -2, 2, -1, 2,
244  0, 2, 1, 2, 2, 2, 3, 2, 4, 2,
245  5, 2, 7, 2, 11, 2, -8, 3, -6, 3,
246  -4, 3, -3, 3, -2, 3, -1, 3, 0, 3,
247  1, 3, 2, 3, 3, 3, 4, 3, 6, 3,
248  8, 3, -13, 4, -10, 4, -5, 4, -3, 4,
249  -2, 4, -1, 4, 0, 4, 1, 4, 2, 4,
250  3, 4, 5, 4, 10, 4, 13, 4, -17, 5,
251  -7, 5, -4, 5, -2, 5, -1, 5, 0, 5,
252  1, 5, 2, 5, 4, 5, 7, 5, 17, 5,
253  -22, 6, -9, 6, -6, 6, -3, 6, -1, 6,
254  1, 6, 3, 6, 6, 6, 9, 6, 22, 6,
255  -5, 7, -2, 7, 0, 7, 2, 7, 5, 7,
256  -11, 8, -8, 8, -3, 8, 0, 8, 3, 8,
257  8, 8, 11, 8, -6, 9, -1, 9, 1, 9,
258  6, 9, -15, 10, -4, 10, 4, 10, 15, 10,
259  -8, 11, -2, 11, 0, 11, 2, 11, 8, 11,
260  19, 12, -19, 13, -4, 13, 4, 13, 0, 14,
261  -10, 15, 10, 15, -5, 17, 5, 17, 0, 18,
262  -12, 19, 13, 19, -6, 22, 6, 22, 0, 23,
263 };
264 
265 typedef struct SANMVideoContext {
266  AVCodecContext *avctx;
267  GetByteContext gb;
268 
269  int version, subversion, have_dimensions, first_fob;
270  uint32_t pal[PALETTE_SIZE];
271  int16_t delta_pal[PALETTE_DELTA], shift_pal[PALETTE_DELTA];
272 
273  ptrdiff_t pitch;
274  int width, height;
275  int aligned_width, aligned_height;
276  int prev_seq;
277 
278  AVFrame *frame;
279  uint16_t *fbuf, *frm0, *frm1, *frm2;
280  uint8_t *stored_frame;
281  uint32_t fbuf_size, frm0_size, frm1_size, frm2_size;
282  uint32_t stor_size;
283  uint32_t stored_frame_size;
284 
285  uint8_t *rle_buf;
286  unsigned int rle_buf_size;
287 
288  long npixels, buf_size;
289 
290  uint16_t codebook[256];
291  uint16_t small_codebook[4];
292 
293  int8_t p4x4glyphs[NGLYPHS][16];
294  int8_t p8x8glyphs[NGLYPHS][64];
295  uint8_t c47itbl[0x10000];
296  uint8_t c23lut[256];
297  uint8_t c4tbl[2][256][16];
298  uint16_t c4param;
299  uint8_t c47cb[4];
300  uint8_t c45tbl1[0x300];
301  uint8_t c45tbl2[0x8000];
302 } SANMVideoContext;
303 
304 enum GlyphEdge {
305  LEFT_EDGE,
306  TOP_EDGE,
307  RIGHT_EDGE,
308  BOTTOM_EDGE,
309  NO_EDGE
310 };
311 
312 enum GlyphDir {
313  DIR_LEFT,
314  DIR_UP,
315  DIR_RIGHT,
316  DIR_DOWN,
317  NO_DIR
318 };
319 
320 /**
321  * Return enum GlyphEdge of box where point (x, y) lies.
322  *
323  * @param x x point coordinate
324  * @param y y point coordinate
325  * @param edge_size box width/height.
326  */
327 static enum GlyphEdge which_edge(int x, int y, int edge_size)
328 {
329  const int edge_max = edge_size - 1;
330 
331  if (!y)
332  return BOTTOM_EDGE;
333  else if (y == edge_max)
334  return TOP_EDGE;
335  else if (!x)
336  return LEFT_EDGE;
337  else if (x == edge_max)
338  return RIGHT_EDGE;
339  else
340  return NO_EDGE;
341 }
342 
343 static enum GlyphDir which_direction(enum GlyphEdge edge0, enum GlyphEdge edge1)
344 {
345  if ((edge0 == LEFT_EDGE && edge1 == RIGHT_EDGE) ||
346  (edge1 == LEFT_EDGE && edge0 == RIGHT_EDGE) ||
347  (edge0 == BOTTOM_EDGE && edge1 != TOP_EDGE) ||
348  (edge1 == BOTTOM_EDGE && edge0 != TOP_EDGE))
349  return DIR_UP;
350  else if ((edge0 == TOP_EDGE && edge1 != BOTTOM_EDGE) ||
351  (edge1 == TOP_EDGE && edge0 != BOTTOM_EDGE))
352  return DIR_DOWN;
353  else if ((edge0 == LEFT_EDGE && edge1 != RIGHT_EDGE) ||
354  (edge1 == LEFT_EDGE && edge0 != RIGHT_EDGE))
355  return DIR_LEFT;
356  else if ((edge0 == TOP_EDGE && edge1 == BOTTOM_EDGE) ||
357  (edge1 == TOP_EDGE && edge0 == BOTTOM_EDGE) ||
358  (edge0 == RIGHT_EDGE && edge1 != LEFT_EDGE) ||
359  (edge1 == RIGHT_EDGE && edge0 != LEFT_EDGE))
360  return DIR_RIGHT;
361 
362  return NO_DIR;
363 }
364 
365 /* Interpolate two points. */
366 static void interp_point(int8_t *points, int x0, int y0, int x1, int y1,
367  int pos, int npoints)
368 {
369  if (npoints) {
370  points[0] = (x0 * pos + x1 * (npoints - pos) + (npoints >> 1)) / npoints;
371  points[1] = (y0 * pos + y1 * (npoints - pos) + (npoints >> 1)) / npoints;
372  } else {
373  points[0] = x0;
374  points[1] = y0;
375  }
376 }
377 
378 /**
379  * Construct glyphs by iterating through vector coordinates.
380  *
381  * @param pglyphs pointer to table where glyphs are stored
382  * @param xvec pointer to x component of vector coordinates
383  * @param yvec pointer to y component of vector coordinates
384  * @param side_length glyph width/height.
385  */
386 static void make_glyphs(int8_t *pglyphs, const int8_t *xvec, const int8_t *yvec,
387  const int side_length)
388 {
389  const int glyph_size = side_length * side_length;
390  int8_t *pglyph = pglyphs;
391 
392  int i, j;
393  for (i = 0; i < GLYPH_COORD_VECT_SIZE; i++) {
394  int x0 = xvec[i];
395  int y0 = yvec[i];
396  enum GlyphEdge edge0 = which_edge(x0, y0, side_length);
397 
398  for (j = 0; j < GLYPH_COORD_VECT_SIZE; j++, pglyph += glyph_size) {
399  int x1 = xvec[j];
400  int y1 = yvec[j];
401  enum GlyphEdge edge1 = which_edge(x1, y1, side_length);
402  enum GlyphDir dir = which_direction(edge0, edge1);
403  int npoints = FFMAX(FFABS(x1 - x0), FFABS(y1 - y0));
404  int ipoint;
405 
406  for (ipoint = 0; ipoint <= npoints; ipoint++) {
407  int8_t point[2];
408  int irow, icol;
409 
410  interp_point(point, x0, y0, x1, y1, ipoint, npoints);
411 
412  switch (dir) {
413  case DIR_UP:
414  for (irow = point[1]; irow >= 0; irow--)
415  pglyph[point[0] + irow * side_length] = 1;
416  break;
417 
418  case DIR_DOWN:
419  for (irow = point[1]; irow < side_length; irow++)
420  pglyph[point[0] + irow * side_length] = 1;
421  break;
422 
423  case DIR_LEFT:
424  for (icol = point[0]; icol >= 0; icol--)
425  pglyph[icol + point[1] * side_length] = 1;
426  break;
427 
428  case DIR_RIGHT:
429  for (icol = point[0]; icol < side_length; icol++)
430  pglyph[icol + point[1] * side_length] = 1;
431  break;
432  }
433  }
434  }
435  }
436 }
437 
438 static void init_sizes(SANMVideoContext *ctx, int width, int height)
439 {
440  ctx->width = width;
441  ctx->height = height;
442  ctx->npixels = width * height;
443 
444  ctx->aligned_width = FFALIGN(width, 8);
445  ctx->aligned_height = FFALIGN(height, 8);
446 
447  ctx->buf_size = ctx->aligned_width * ctx->aligned_height * sizeof(ctx->frm0[0]);
448  ctx->pitch = width;
449 }
450 
451 static void destroy_buffers(SANMVideoContext *ctx)
452 {
453  av_freep(&ctx->fbuf);
454  av_freep(&ctx->frm0);
455  av_freep(&ctx->frm1);
456  av_freep(&ctx->frm2);
457  av_freep(&ctx->stored_frame);
458  av_freep(&ctx->rle_buf);
459  ctx->frm0_size =
460  ctx->frm1_size =
461  ctx->frm2_size = 0;
462  init_sizes(ctx, 0, 0);
463 }
464 
465 static av_cold int init_buffers(SANMVideoContext *ctx)
466 {
467  av_fast_padded_mallocz(&ctx->fbuf, &ctx->fbuf_size, ctx->buf_size);
468  av_fast_padded_mallocz(&ctx->frm0, &ctx->frm0_size, ctx->buf_size);
469  av_fast_padded_mallocz(&ctx->frm1, &ctx->frm1_size, ctx->buf_size);
470  av_fast_padded_mallocz(&ctx->frm2, &ctx->frm2_size, ctx->buf_size);
471  if (!ctx->version) {
472  av_fast_padded_mallocz(&ctx->stored_frame,
473  &ctx->stored_frame_size, ctx->buf_size);
474  ctx->stor_size = 0;
475  }
476 
477  if (!ctx->frm0 || !ctx->frm1 || !ctx->frm2 ||
478  (!ctx->stored_frame && !ctx->version)) {
479  destroy_buffers(ctx);
480  return AVERROR(ENOMEM);
481  }
482 
483  return 0;
484 }
485 
486 static void codec33_gen_tiles(SANMVideoContext *ctx, int8_t param1)
487 {
488  uint8_t *dst = &(ctx->c4tbl[0][0][0]);
489  int i, j, k, l, m, n, o, p;
490 
491  for (i = 0; i < 8; i++) {
492  for (k = 0; k < 8; k++) {
493  j = i + param1;
494  l = k + param1;
495  p = (j + l) >> 1;
496  n = (j + p) >> 1;
497  m = (p + l) >> 1;
498 
499  *dst++ = p; *dst++ = p; *dst++ = n; *dst++ = j;
500  *dst++ = p; *dst++ = p; *dst++ = n; *dst++ = j;
501  *dst++ = m; *dst++ = m; *dst++ = p; *dst++ = j;
502  *dst++ = l; *dst++ = l; *dst++ = m; *dst++ = p;
503  }
504  }
505 
506  for (i = 0; i < 8; i++) {
507  for (k = 0; k < 8; k++) {
508  j = i + param1;
509  l = k + param1;
510  n = (j + l) >> 1;
511  m = (l + n) >> 1;
512 
513  *dst++ = j; *dst++ = j; *dst++ = j; *dst++ = j;
514  *dst++ = n; *dst++ = n; *dst++ = n; *dst++ = n;
515  *dst++ = m; *dst++ = m; *dst++ = m; *dst++ = m;
516  *dst++ = l; *dst++ = l; *dst++ = l; *dst++ = l;
517  }
518  }
519 
520  for (i = 0; i < 8; i++) {
521  for (k = 0; k < 8; k++) {
522  j = i + param1;
523  l = k + param1;
524  m = (j + l) >> 1;
525  n = (j + m) >> 1;
526  o = (l + m) >> 1;
527 
528  *dst++ = j; *dst++ = j; *dst++ = n; *dst++ = m;
529  *dst++ = j; *dst++ = j; *dst++ = n; *dst++ = m;
530  *dst++ = n; *dst++ = n; *dst++ = m; *dst++ = o;
531  *dst++ = m; *dst++ = m; *dst++ = o; *dst++ = l;
532  }
533  }
534 
535  for (i = 0; i < 8; i++) {
536  for (k = 0; k < 8; k++) {
537  j = i + param1;
538  l = k + param1;
539  m = (j + l) >> 1;
540  n = (l + m) >> 1;
541 
542  *dst++ = j; *dst++ = m; *dst++ = n; *dst++ = l;
543  *dst++ = j; *dst++ = m; *dst++ = n; *dst++ = l;
544  *dst++ = j; *dst++ = m; *dst++ = n; *dst++ = l;
545  *dst++ = j; *dst++ = m; *dst++ = n; *dst++ = l;
546  }
547  }
548 }
549 
550 static void codec4_gen_tiles(SANMVideoContext *ctx, uint16_t param1)
551 {
552  uint8_t *dst = &(ctx->c4tbl[0][0][0]);
553  int i, j, k, l, m, n, o;
554 
555  for (i = 1; i < 16; i += 2) {
556  for (k = 0; k < 16; k++) {
557  j = i + param1;
558  l = k + param1;
559  m = (j + l) / 2;
560  n = (j + m) / 2;
561  o = (l + m) / 2;
562  if (j == m || l == m) {
563  *dst++ = l; *dst++ = j; *dst++ = l; *dst++ = j;
564  *dst++ = j; *dst++ = l; *dst++ = j; *dst++ = j;
565  *dst++ = l; *dst++ = j; *dst++ = l; *dst++ = j;
566  *dst++ = l; *dst++ = l; *dst++ = j; *dst++ = l;
567  } else {
568  *dst++ = m; *dst++ = m; *dst++ = n; *dst++ = j;
569  *dst++ = m; *dst++ = m; *dst++ = n; *dst++ = j;
570  *dst++ = o; *dst++ = o; *dst++ = m; *dst++ = n;
571  *dst++ = l; *dst++ = l; *dst++ = o; *dst++ = m;
572  }
573  }
574  }
575 
576  for (i = 0; i < 16; i += 2) {
577  for (k = 0; k < 16; k++) {
578  j = i + param1;
579  l = k + param1;
580  m = (j + l) / 2;
581  n = (j + m) / 2;
582  o = (l + m) / 2;
583  if (m == j || m == l) {
584  *dst++ = j; *dst++ = j; *dst++ = l; *dst++ = j;
585  *dst++ = j; *dst++ = j; *dst++ = j; *dst++ = l;
586  *dst++ = l; *dst++ = j; *dst++ = l; *dst++ = l;
587  *dst++ = j; *dst++ = l; *dst++ = j; *dst++ = l;
588  } else {
589  *dst++ = j; *dst++ = j; *dst++ = n; *dst++ = m;
590  *dst++ = j; *dst++ = j; *dst++ = n; *dst++ = m;
591  *dst++ = n; *dst++ = n; *dst++ = m; *dst++ = o;
592  *dst++ = m; *dst++ = m; *dst++ = o; *dst++ = l;
593  }
594  }
595  }
596 }
597 
598 
599 static int codec4_load_tiles(SANMVideoContext *ctx, GetByteContext *gb,
600  uint16_t param2, uint8_t clr)
601 {
602  uint8_t c, *dst = (uint8_t *)&(ctx->c4tbl[1][0][0]);
603  uint32_t loop = param2 * 8;
604 
605  if ((param2 > 256) || (bytestream2_get_bytes_left(gb) < loop))
606  return AVERROR_INVALIDDATA;
607 
608  while (loop--) {
609  c = bytestream2_get_byteu(gb);
610  *dst++ = (c >> 4) + clr;
611  *dst++ = (c & 0xf) + clr;
612  }
613 
614  return 0;
615 }
616 
617 static void rotate_bufs(SANMVideoContext *ctx, int rotate_code)
618 {
619  if (rotate_code == 2)
620  FFSWAP(uint16_t*, ctx->frm1, ctx->frm2);
621  FFSWAP(uint16_t*, ctx->frm2, ctx->frm0);
622 }
623 
624 static av_cold int decode_init(AVCodecContext *avctx)
625 {
626  SANMVideoContext *ctx = avctx->priv_data;
627 
628  ctx->avctx = avctx;
629  ctx->version = !avctx->extradata_size;
630  // early sanity check before allocations to avoid need for deallocation code.
631  if (!ctx->version && avctx->extradata_size < 1026) {
632  av_log(avctx, AV_LOG_ERROR, "Not enough extradata.\n");
633  return AVERROR_INVALIDDATA;
634  }
635 
636  avctx->pix_fmt = ctx->version ? AV_PIX_FMT_RGB565 : AV_PIX_FMT_PAL8;
637 
638  if (!ctx->version) {
639  // ANIM has no dimensions in the header, distrust the incoming data.
640  avctx->width = avctx->height = 0;
641  ctx->have_dimensions = 0;
642  } else if (avctx->width > 800 || avctx->height > 600 ||
643  avctx->width < 8 || avctx->height < 8) {
644  // BL16 valid range is 8x8 - 800x600
645  return AVERROR_INVALIDDATA;
646  }
647  init_sizes(ctx, avctx->width, avctx->height);
648  if (init_buffers(ctx)) {
649  av_log(avctx, AV_LOG_ERROR, "Error allocating buffers.\n");
650  return AVERROR(ENOMEM);
651  }
652 
653  make_glyphs(ctx->p4x4glyphs[0], glyph4_x, glyph4_y, 4);
654  make_glyphs(ctx->p8x8glyphs[0], glyph8_x, glyph8_y, 8);
655 
656  if (!ctx->version) {
657  int i;
658 
659  ctx->subversion = AV_RL16(avctx->extradata);
660  for (i = 0; i < PALETTE_SIZE; i++)
661  ctx->pal[i] = 0xFFU << 24 | AV_RL32(avctx->extradata + 2 + i * 4);
662  if (ctx->subversion < 2)
663  ctx->pal[0] = 0xFFU << 24;
664  }
665  ctx->c4param = 0xffff;
666 
667  return 0;
668 }
669 
670 static av_cold int decode_end(AVCodecContext *avctx)
671 {
672  SANMVideoContext *ctx = avctx->priv_data;
673 
674  destroy_buffers(ctx);
675 
676  return 0;
677 }
678 
679 static int old_codec4(SANMVideoContext *ctx, GetByteContext *gb, int top, int left,
680  int w, int h, uint8_t param, uint16_t param2, int codec)
681 {
682  const uint16_t mx = ctx->width, my = ctx->height, p = ctx->pitch;
683  uint8_t mask, bits, idx, *gs, *dst = (uint8_t *)ctx->fbuf;
684  int i, j, k, l, bit, ret, x, y;
685 
686  if (ctx->c4param != param) {
687  if (codec > 32)
688  codec33_gen_tiles(ctx, param);
689  else
690  codec4_gen_tiles(ctx, param);
691  ctx->c4param = param;
692  }
693  if (param2 > 0) {
694  ret = codec4_load_tiles(ctx, gb, param2, param);
695  if (ret)
696  return ret;
697  }
698 
699  if (codec > 32)
700  codec -= 29;
701 
702  for (j = 0; j < w; j += 4) {
703  mask = bits = 0;
704  x = left + j;
705  for (i = 0; i < h; i += 4) {
706  y = top + i;
707  if (param2 > 0) {
708  if (bits == 0) {
709  if (bytestream2_get_bytes_left(gb) < 1)
710  return AVERROR_INVALIDDATA;
711  mask = bytestream2_get_byteu(gb);
712  bits = 8;
713  }
714  bit = !!(mask & 0x80);
715  mask <<= 1;
716  bits--;
717  } else {
718  bit = 0;
719  }
720 
721  if (bytestream2_get_bytes_left(gb) < 1)
722  return AVERROR_INVALIDDATA;
723  idx = bytestream2_get_byteu(gb);
724  if ((bit == 0) && (idx == 0x80) && (codec != 5))
725  continue;
726  if ((y >= my) || ((y + 4) < 0) || ((x + 4) < 0) || (x >= mx))
727  continue;
728  gs = &(ctx->c4tbl[bit][idx][0]);
729  if ((y >= 0) && (x >= 0) && ((y + 4) < my) && ((x + 4) < mx)) {
730  for (k = 0; k < 4; k++, gs += 4)
731  memcpy(dst + x + (y + k) * p, gs, 4);
732  } else {
733  for (k = 0; k < 4; k++) {
734  for (l = 0; l < 4; l++, gs++) {
735  const int yo = y + k, xo = x + l;
736  if ((yo >= 0) && (yo < my) && (xo >= 0) && (xo < mx))
737  *(dst + yo * p + xo) = *gs;
738  }
739  }
740  }
741  }
742  }
743  return 0;
744 }
745 
746 static int rle_decode(SANMVideoContext *ctx, GetByteContext *gb, uint8_t *dst, const int out_size)
747 {
748  int opcode, color, run_len, left = out_size;
749 
750  while (left > 0) {
751  opcode = bytestream2_get_byte(gb);
752  run_len = (opcode >> 1) + 1;
753  if (run_len > left || bytestream2_get_bytes_left(gb) <= 0)
754  return AVERROR_INVALIDDATA;
755 
756  if (opcode & 1) {
757  color = bytestream2_get_byte(gb);
758  memset(dst, color, run_len);
759  } else {
760  if (bytestream2_get_bytes_left(gb) < run_len)
761  return AVERROR_INVALIDDATA;
762  bytestream2_get_bufferu(gb, dst, run_len);
763  }
764 
765  dst += run_len;
766  left -= run_len;
767  }
768 
769  return 0;
770 }
771 
772 static int old_codec23(SANMVideoContext *ctx, GetByteContext *gb, int top, int left,
773  int width, int height, uint8_t param, uint16_t param2)
774 {
775  const uint16_t mx = ctx->width, my = ctx->height, p = ctx->pitch;
776  uint8_t c, lut[256], *dst = (uint8_t *)ctx->fbuf;
777  int sk, i, j, ls, pc, y;
778 
779  if (ctx->subversion < 2) {
780  /* Rebel Assault 1: constant offset + 0xd0 */
781  for (i = 0; i < 256; i++)
782  lut[i] = (i + param + 0xd0) & 0xff;
783  } else if (param2 == 256) {
784  if (bytestream2_get_bytes_left(gb) < 256)
785  return AVERROR_INVALIDDATA;
786  bytestream2_get_bufferu(gb, ctx->c23lut, 256);
787  } else if (param2 < 256) {
788  for (i = 0; i < 256; i++)
789  lut[i] = (i + param2) & 0xff;
790  } else {
791  memcpy(lut, ctx->c23lut, 256);
792  }
793  if (bytestream2_get_bytes_left(gb) < 1)
794  return 0; /* some c23 frames just set up the LUT */
795 
796  if (((top + height) < 0) || (top >= my) || (left + width < 0) || (left >= mx))
797  return 0;
798 
799  if (top < 0) {
800  y = -top;
801  while (y-- && bytestream2_get_bytes_left(gb) > 1) {
802  ls = bytestream2_get_le16u(gb);
803  if (bytestream2_get_bytes_left(gb) < ls)
804  return AVERROR_INVALIDDATA;
805  bytestream2_skip(gb, ls);
806  }
807  height += top;
808  top = 0;
809  }
810 
811  y = top;
812  for (; (bytestream2_get_bytes_left(gb) > 1) && (height > 0) && (y < my); height--, y++) {
813  ls = bytestream2_get_le16u(gb);
814  sk = 1;
815  pc = left;
816  while ((bytestream2_get_bytes_left(gb) > 0) && (ls > 0) && (pc <= (width + left))) {
817  j = bytestream2_get_byteu(gb);
818  ls--;
819  if (!sk) {
820  while (j--) {
821  if ((pc >= 0) && (pc < mx)) {
822  c = *(dst + (y * p) + pc);
823  *(dst + (y * p) + pc) = lut[c];
824  }
825  if (pc < mx)
826  pc++;
827  }
828  } else {
829  if (pc < mx)
830  pc += j;
831  }
832  sk ^= 1;
833  }
834  }
835  return 0;
836 }
837 
838 static int old_codec21(SANMVideoContext *ctx, GetByteContext *gb, int top, int left,
839  int width, int height)
840 {
841  const uint16_t mx = ctx->width, my = ctx->height, p = ctx->pitch;
842  uint8_t *dst = (uint8_t *)ctx->fbuf, c;
843  int j, y, pc, sk, ls;
844 
845  if (((top + height) < 0) || (top >= my) || (left + width < 0) || (left >= mx))
846  return 0;
847 
848  y = top;
849  for (; (bytestream2_get_bytes_left(gb) > 2) && (height > 0) && (y < my); height--, y++) {
850  ls = bytestream2_get_le16u(gb);
851  if (y < 0) {
852  if (ls >= bytestream2_get_bytes_left(gb))
853  return 0;
854  bytestream2_skip(gb, ls);
855  continue;
856  }
857  sk = 1;
858  pc = left;
859  while ((bytestream2_get_bytes_left(gb) > 1) && (ls > 1) && (pc <= (width + left))) {
860  j = bytestream2_get_le16u(gb);
861  ls -= 2;
862  if (sk) {
863  if (pc < mx)
864  pc += j;
865  } else {
866  while ((bytestream2_get_bytes_left(gb) > 0) && (ls > 0) && (j >= 0)) {
867  c = bytestream2_get_byteu(gb);
868  if ((pc >= 0) && (pc < mx)) {
869  *(dst + (y * p) + pc) = c;
870  }
871  ls--;
872  j--;
873  if (pc < mx)
874  pc++;
875  }
876  }
877  sk ^= 1;
878  }
879  }
880  return 0;
881 }
882 
883 static int old_codec1(SANMVideoContext *ctx, GetByteContext *gb, int top,
884  int left, int width, int height, int opaque)
885 {
886  const uint16_t mx = ctx->width, my = ctx->height, p = ctx->pitch;
887  uint8_t *dst = (uint8_t *)ctx->fbuf, code, c;
888  int j, x, y, flag, dlen;
889 
890  if (((top + height) < 0) || (top >= my) || (left + width < 0) || (left >= mx))
891  return 0;
892 
893  if (top < 0) {
894  y = -top;
895  while (y-- && bytestream2_get_bytes_left(gb) > 1) {
896  dlen = bytestream2_get_le16u(gb);
897  if (bytestream2_get_bytes_left(gb) <= dlen)
898  return AVERROR_INVALIDDATA;
899  bytestream2_skip(gb, dlen);
900  }
901  height += top;
902  top = 0;
903  }
904 
905  y = top;
906  for (; (bytestream2_get_bytes_left(gb) > 1) && (height > 0) && (y < my); height--, y++) {
907  dlen = bytestream2_get_le16u(gb);
908  x = left;
909  while (bytestream2_get_bytes_left(gb) > 1 && dlen) {
910  code = bytestream2_get_byteu(gb);
911  dlen--;
912  flag = code & 1;
913  code = (code >> 1) + 1;
914  if (flag) {
915  c = bytestream2_get_byteu(gb);
916  dlen--;
917  if (x >= mx)
918  continue;
919  if (x < 0) {
920  int dff = FFMIN(-x, code);
921  code -= dff;
922  x += dff;
923  }
924  if (x + code >= mx)
925  code = mx - x;
926  if (code < 1)
927  continue;
928  for (j = 0; (j < code) && (c || opaque); j++) {
929  *(dst + (y * p) + x + j) = c;
930  }
931  x += code;
932  } else {
933  if (bytestream2_get_bytes_left(gb) < code)
934  return AVERROR_INVALIDDATA;
935  for (j = 0; j < code; j++) {
936  c = bytestream2_get_byteu(gb);
937  if ((x >= 0) && (x < mx) && (c || opaque))
938  *(dst + (y * p) + x) = c;
939  if (x < mx)
940  x++;
941  }
942  dlen -= code;
943  }
944  }
945  }
946 
947  return 0;
948 }
949 
950 static int old_codec31(SANMVideoContext *ctx, GetByteContext *gb, int top,
951  int left, int width, int height, int p1, int opaque)
952 {
953  const uint16_t mx = ctx->width, my = ctx->height, p = ctx->pitch;
954  uint8_t *dst = (uint8_t *)ctx->fbuf, c;
955  int j, x, y, flag, dlen, code;
956 
957  if (((top + height) < 0) || (top >= my) || (left + width < 0) || (left >= mx))
958  return 0;
959 
960  if (top < 0) {
961  y = -top;
962  while (y-- && bytestream2_get_bytes_left(gb) > 1) {
963  dlen = bytestream2_get_le16u(gb);
964  if (bytestream2_get_bytes_left(gb) <= dlen)
965  return AVERROR_INVALIDDATA;
966  bytestream2_skip(gb, dlen);
967  }
968  height += top;
969  top = 0;
970  }
971 
972  y = top;
973  for (; (bytestream2_get_bytes_left(gb) > 1) && (height > 0) && (y < my); height--, y++) {
974  dlen = bytestream2_get_le16u(gb);
975  x = left;
976  while (bytestream2_get_bytes_left(gb) > 1 && dlen) {
977  code = bytestream2_get_byteu(gb);
978  dlen--;
979  flag = code & 1;
980  code = (code >> 1) + 1;
981  if (flag) {
982  c = bytestream2_get_byteu(gb);
983  dlen--;
984  for (j = 0; (j < code); j++) {
985  if ((opaque || (c & 0xf)) && (x >= 0) && (x < mx))
986  *(dst + (y * p) + x) = p1 + (c & 0xf);
987  if (x < mx)
988  x++;
989  if ((opaque || (c >> 4)) && (x >= 0) && (x < mx))
990  *(dst + (y * p) + x) = p1 + (c >> 4);
991  if (x < mx)
992  x++;
993  }
994  } else {
995  if (bytestream2_get_bytes_left(gb) < code)
996  return AVERROR_INVALIDDATA;
997  for (j = 0; j < code; j++) {
998  c = bytestream2_get_byteu(gb);
999  if ((opaque || (c & 0xf)) && (x >= 0) && (x < mx))
1000  *(dst + (y * p) + x) = p1 + (c & 0xf);
1001  if (x < mx)
1002  x++;
1003  if ((opaque || (c >> 4)) && (x >= 0) && (x < mx))
1004  *(dst + (y * p) + x) = p1 + (c >> 4);
1005  if (x < mx)
1006  x++;
1007  }
1008  dlen -= code;
1009  }
1010  }
1011  }
1012 
1013  return 0;
1014 }
1015 
1016 static int old_codec2(SANMVideoContext *ctx, GetByteContext *gb, int top,
1017  int left, int width, int height)
1018 {
1019  uint8_t *dst = (uint8_t *)ctx->fbuf, col;
1020  int16_t xpos = left, ypos = top;
1021 
1022  while (bytestream2_get_bytes_left(gb) > 3) {
1023  xpos += bytestream2_get_le16u(gb);
1024  ypos += bytestream2_get_byteu(gb);
1025  col = bytestream2_get_byteu(gb);
1026  if (xpos >= 0 && ypos >= 0 &&
1027  xpos < ctx->width && ypos < ctx->height) {
1028  *(dst + xpos + ypos * ctx->pitch) = col;
1029  }
1030  }
1031  return 0;
1032 }
1033 
1034 static void blt_solid(uint8_t *dst, const uint8_t *src, int16_t left, int16_t top,
1035  uint16_t srcxoff, uint16_t srcyoff, uint16_t srcwidth,
1036  uint16_t srcheight, const uint16_t srcpitch, const uint16_t dstpitch,
1037  const uint16_t dstheight, int32_t size)
1038 {
1039  if ((srcwidth < 1) || (srcheight < 1) || (size < 1))
1040  return;
1041 
1042  if (top < 0) {
1043  if (-top >= srcheight)
1044  return;
1045  srcyoff -= top;
1046  srcheight += top;
1047  size += (srcpitch * top);
1048  top = 0;
1049  }
1050 
1051  if ((top + srcheight) > dstheight) {
1052  int clip = (top + srcheight) - dstheight;
1053  if (clip >= srcheight)
1054  return;
1055  srcheight -= clip;
1056  }
1057 
1058  if (left < 0) {
1059  if (-left >= srcwidth)
1060  return;
1061  srcxoff -= left;
1062  srcwidth += left;
1063  size += left;
1064  left = 0;
1065  }
1066 
1067  if (left + srcwidth > dstpitch) {
1068  int clip = (left + srcwidth) - dstpitch;
1069  if (clip >= srcwidth)
1070  return;
1071  srcwidth -= clip;
1072  }
1073 
1074  src += ((uintptr_t)srcyoff * srcpitch) + srcxoff;
1075  dst += ((uintptr_t)top * dstpitch) + left;
1076  while ((srcheight--) && (size >= srcwidth)) {
1077  memcpy(dst, src, srcwidth);
1078  src += srcpitch;
1079  dst += dstpitch;
1080  size -= srcpitch;
1081  }
1082  if ((size > 0) && (size < srcwidth) && (srcheight > 0))
1083  memcpy(dst, src, size);
1084 }
1085 
1086 static void blt_mask(uint8_t *dst, const uint8_t *src, int16_t left, int16_t top,
1087  uint16_t srcxoff, uint16_t srcyoff, uint16_t srcwidth,
1088  uint16_t srcheight, const uint16_t srcpitch, const uint16_t dstpitch,
1089  const uint16_t dstheight, int32_t size, const uint8_t skipcolor)
1090 {
1091  if ((srcwidth < 1) || (srcheight < 1) || (size < 1))
1092  return;
1093 
1094  if (top < 0) {
1095  if (-top >= srcheight)
1096  return;
1097  srcyoff -= top;
1098  srcheight += top;
1099  size += (srcpitch * top);
1100  top = 0;
1101  }
1102 
1103  if ((top + srcheight) > dstheight) {
1104  int clip = (top + srcheight) - dstheight;
1105  if (clip >= srcheight)
1106  return;
1107  srcheight -= clip;
1108  }
1109 
1110  if (left < 0) {
1111  if (-left >= srcwidth)
1112  return;
1113  srcxoff -= left;
1114  srcwidth += left;
1115  size += left;
1116  left = 0;
1117  }
1118 
1119  if (left + srcwidth > dstpitch) {
1120  int clip = (left + srcwidth) - dstpitch;
1121  if (clip >= srcwidth)
1122  return;
1123  srcwidth -= clip;
1124  }
1125 
1126  src += ((uintptr_t)srcyoff * srcpitch) + srcxoff;
1127  dst += ((uintptr_t)top * dstpitch) + left;
1128  for (int i = 0; (size > 0) && (i < srcheight); i++) {
1129  for (int j = 0; (size > 0) && (j < srcwidth); j++, size--) {
1130  if (src[j] != skipcolor)
1131  dst[j] = src[j];
1132  }
1133  src += srcpitch;
1134  dst += dstpitch;
1135  }
1136 }
1137 
1138 static void blt_ipol(uint8_t *dst, const uint8_t *src1, const uint8_t *src2,
1139  int16_t left, int16_t top, uint16_t srcxoff, uint16_t srcyoff,
1140  uint16_t srcwidth, uint16_t srcheight, const uint16_t srcpitch,
1141  const uint16_t dstpitch, const uint16_t dstheight, int32_t size,
1142  const uint8_t *itbl)
1143 {
1144  if ((srcwidth < 1) || (srcheight < 1) || (size < 1))
1145  return;
1146 
1147  if (top < 0) {
1148  if (-top >= srcheight)
1149  return;
1150  srcyoff -= top;
1151  srcheight += top;
1152  size += (srcpitch * top);
1153  top = 0;
1154  }
1155 
1156  if ((top + srcheight) > dstheight) {
1157  int clip = (top + srcheight) - dstheight;
1158  if (clip >= srcheight)
1159  return;
1160  srcheight -= clip;
1161  }
1162 
1163  if (left < 0) {
1164  if (-left >= srcwidth)
1165  return;
1166  srcxoff -= left;
1167  srcwidth += left;
1168  size += left;
1169  left = 0;
1170  }
1171 
1172  if (left + srcwidth > dstpitch) {
1173  int clip = (left + srcwidth) - dstpitch;
1174  if (clip >= srcwidth)
1175  return;
1176  srcwidth -= clip;
1177  }
1178 
1179  src1 += ((uintptr_t)srcyoff * srcpitch) + srcxoff;
1180  src2 += ((uintptr_t)srcyoff * srcpitch) + srcxoff;
1181  dst += ((uintptr_t)top * dstpitch) + left;
1182  for (int i = 0; (size > 0) && (i < srcheight); i++) {
1183  for (int j = 0; (size > 0) && (j < srcwidth); j++, size--) {
1184  dst[j] = itbl[(src1[j] << 8) | src2[j]];
1185  }
1186  src1 += srcpitch;
1187  src2 += srcpitch;
1188  dst += dstpitch;
1189  }
1190 }
1191 
1192 static int old_codec20(SANMVideoContext *ctx, GetByteContext *gb, int top, int left,
1193  const int w, const int h)
1194 {
1195  blt_solid((uint8_t*)ctx->fbuf, gb->buffer, left, top, 0, 0, w, h, w, ctx->pitch,
1196  ctx->height, FFMIN(bytestream2_get_bytes_left(gb), w * h));
1197 
1198  return 0;
1199 }
1200 
1201 static inline void codec37_mv(uint8_t *dst, const uint8_t *src,
1202  int height, int stride, int x, int y)
1203 {
1204  int pos, i, j;
1205 
1206  pos = x + y * stride;
1207  for (j = 0; j < 4; j++) {
1208  for (i = 0; i < 4; i++) {
1209  if ((pos + i) < 0 || (pos + i) >= height * stride)
1210  dst[i] = 0;
1211  else
1212  dst[i] = src[i];
1213  }
1214  dst += stride;
1215  src += stride;
1216  pos += stride;
1217  }
1218 }
1219 
1220 static int old_codec37(SANMVideoContext *ctx, GetByteContext *gb, int top, int left,
1221  int width, int height)
1222 {
1223  int i, j, k, l, t, run, len, code, skip, mx, my;
1224  uint8_t *dst, *prev;
1225  int skip_run = 0;
1226 
1227  width = FFALIGN(width, 4);
1228  if (width > ctx->aligned_width)
1229  return AVERROR_INVALIDDATA;
1230 
1231  if (FFALIGN(height, 4) > ctx->aligned_height)
1232  return AVERROR_INVALIDDATA;
1233 
1234  if (bytestream2_get_bytes_left(gb) < 16)
1235  return AVERROR_INVALIDDATA;
1236 
1237  int compr = bytestream2_get_byteu(gb);
1238  int mvoff = bytestream2_get_byteu(gb);
1239  int seq = bytestream2_get_le16u(gb);
1240  uint32_t decoded_size = bytestream2_get_le32u(gb);
1241  int flags;
1242 
1243  bytestream2_skip(gb, 4);
1244  flags = bytestream2_get_byteu(gb);
1245  bytestream2_skip(gb, 3);
1246 
1247  if (decoded_size > height * width) {
1248  decoded_size = height * width;
1249  av_log(ctx->avctx, AV_LOG_WARNING, "Decoded size is too large.\n");
1250  }
1251 
1252  if (((seq & 1) || !(flags & 1)) && (compr && compr != 2)) {
1253  FFSWAP(uint16_t*, ctx->frm0, ctx->frm2);
1254  }
1255 
1256  dst = ((uint8_t*)ctx->frm0);
1257  prev = ((uint8_t*)ctx->frm2);
1258 
1259  if (mvoff > 2) {
1260  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid motion base value %d.\n", mvoff);
1261  return AVERROR_INVALIDDATA;
1262  }
1263 
1264  switch (compr) {
1265  case 0:
1266  if (bytestream2_get_bytes_left(gb) < width * height)
1267  return AVERROR_INVALIDDATA;
1268  bytestream2_get_bufferu(gb, dst, width * height);
1269  memset(ctx->frm2, 0, ctx->frm2_size);
1270  break;
1271  case 1:
1272  run = 0;
1273  len = -1;
1274  code = 0;
1275 
1276  for (j = 0; j < height; j += 4) {
1277  for (i = 0; i < width; i += 4) {
1278  if (len < 0) {
1279  if (bytestream2_get_bytes_left(gb) < 1)
1280  return AVERROR_INVALIDDATA;
1281  code = bytestream2_get_byte(gb);
1282  len = code >> 1;
1283  run = code & 1;
1284  skip = 0;
1285  } else {
1286  skip = run;
1287  }
1288 
1289  if (!skip) {
1290  if (bytestream2_get_bytes_left(gb) < 1)
1291  return AVERROR_INVALIDDATA;
1292  code = bytestream2_get_byte(gb);
1293  if (code == 0xff) {
1294  len--;
1295  for (k = 0; k < 4; k++) {
1296  for (l = 0; l < 4; l++) {
1297  if (len < 0) {
1298  if (bytestream2_get_bytes_left(gb) < 1)
1299  return AVERROR_INVALIDDATA;
1300  code = bytestream2_get_byte(gb);
1301  len = code >> 1;
1302  run = code & 1;
1303  if (run) {
1304  if (bytestream2_get_bytes_left(gb) < 1)
1305  return AVERROR_INVALIDDATA;
1306  code = bytestream2_get_byte(gb);
1307  }
1308  }
1309  if (!run) {
1310  if (bytestream2_get_bytes_left(gb) < 1)
1311  return AVERROR_INVALIDDATA;
1312  code = bytestream2_get_byte(gb);
1313  }
1314  *(dst + i + (k * width) + l) = code;
1315  len--;
1316  }
1317  }
1318  continue;
1319  }
1320  }
1321  /* 4x4 block copy from prev with MV */
1322  code = (code == 0xff) ? 0 : code;
1323  mx = c37_mv[(mvoff * 255 + code) * 2];
1324  my = c37_mv[(mvoff * 255 + code) * 2 + 1];
1325  codec37_mv(dst + i, prev + i + mx + my * width,
1326  height, width, i + mx, j + my);
1327  len--;
1328  }
1329  dst += width * 4;
1330  prev += width * 4;
1331  }
1332  break;
1333  case 2:
1334  if (rle_decode(ctx, gb, dst, decoded_size))
1335  return AVERROR_INVALIDDATA;
1336  memset(ctx->frm2, 0, ctx->frm2_size);
1337  break;
1338  case 3:
1339  case 4:
1340  for (j = 0; j < height; j += 4) {
1341  for (i = 0; i < width; i += 4) {
1342  int code;
1343  if (skip_run) {
1344  skip_run--;
1345  copy_block4(dst + i, prev + i, width, width, 4);
1346  continue;
1347  }
1348  if (bytestream2_get_bytes_left(gb) < 1)
1349  return AVERROR_INVALIDDATA;
1350  code = bytestream2_get_byteu(gb);
1351  if (code == 0xFF) {
1352  if (bytestream2_get_bytes_left(gb) < 16)
1353  return AVERROR_INVALIDDATA;
1354  for (k = 0; k < 4; k++)
1355  bytestream2_get_bufferu(gb, dst + i + k * width, 4);
1356  } else if ((flags & 4) && (code == 0xFE)) {
1357  if (bytestream2_get_bytes_left(gb) < 4)
1358  return AVERROR_INVALIDDATA;
1359  for (k = 0; k < 4; k += 2) {
1360  uint8_t c1 = bytestream2_get_byteu(gb);
1361  uint8_t c2 = bytestream2_get_byteu(gb);
1362  for (l = 0; l < 2; l++) {
1363  *(dst + i + ((k + l) * width) + 0) = c1;
1364  *(dst + i + ((k + l) * width) + 1) = c1;
1365  *(dst + i + ((k + l) * width) + 2) = c2;
1366  *(dst + i + ((k + l) * width) + 3) = c2;
1367  }
1368  }
1369  } else if ((flags & 4) && (code == 0xFD)) {
1370  if (bytestream2_get_bytes_left(gb) < 1)
1371  return AVERROR_INVALIDDATA;
1372  t = bytestream2_get_byteu(gb);
1373  for (k = 0; k < 4; k++)
1374  memset(dst + i + k * width, t, 4);
1375  } else {
1376  mx = c37_mv[(mvoff * 255 + code) * 2];
1377  my = c37_mv[(mvoff * 255 + code) * 2 + 1];
1378  codec37_mv(dst + i, prev + i + mx + my * width,
1379  height, width, i + mx, j + my);
1380 
1381  if ((compr == 4) && (code == 0)) {
1382  if (bytestream2_get_bytes_left(gb) < 1)
1383  return AVERROR_INVALIDDATA;
1384  skip_run = bytestream2_get_byteu(gb);
1385  }
1386  }
1387  }
1388  dst += width * 4;
1389  prev += width * 4;
1390  }
1391  break;
1392  default:
1393  avpriv_report_missing_feature(ctx->avctx,
1394  "Subcodec 37 compression %d", compr);
1395  return AVERROR_PATCHWELCOME;
1396  }
1397 
1398  if ((flags & 2) == 0) {
1399  blt_solid((uint8_t*)ctx->fbuf, (uint8_t*)ctx->frm0, left, top, 0, 0, width,
1400  height, width, ctx->pitch, ctx->height, width * height);
1401  } else {
1402  blt_mask((uint8_t*)ctx->fbuf, (uint8_t*)ctx->frm0, left, top, 0, 0, width,
1403  height, width, ctx->pitch, ctx->height, width * height, 0);
1404  }
1405  return 0;
1406 }
1407 
1408 static int codec47_block(SANMVideoContext *ctx, GetByteContext *gb,uint8_t *dst,
1409  uint8_t *prev1, uint8_t *prev2, int stride, int size)
1410 {
1411  int code, k, t;
1412  uint8_t colors[2];
1413  int8_t *pglyph;
1414 
1415  if (bytestream2_get_bytes_left(gb) < 1)
1416  return AVERROR_INVALIDDATA;
1417 
1418  code = bytestream2_get_byteu(gb);
1419  if (code >= 0xF8) {
1420  switch (code) {
1421  case 0xFF:
1422  if (size == 2) {
1423  if (bytestream2_get_bytes_left(gb) < 4)
1424  return AVERROR_INVALIDDATA;
1425  dst[0] = bytestream2_get_byteu(gb);
1426  dst[1] = bytestream2_get_byteu(gb);
1427  dst[0 + stride] = bytestream2_get_byteu(gb);
1428  dst[1 + stride] = bytestream2_get_byteu(gb);
1429  } else {
1430  size >>= 1;
1431  if (codec47_block(ctx, gb, dst, prev1, prev2, stride, size))
1432  return AVERROR_INVALIDDATA;
1433  if (codec47_block(ctx, gb, dst + size, prev1 + size, prev2 + size,
1434  stride, size))
1435  return AVERROR_INVALIDDATA;
1436  dst += size * stride;
1437  prev1 += size * stride;
1438  prev2 += size * stride;
1439  if (codec47_block(ctx, gb, dst, prev1, prev2, stride, size))
1440  return AVERROR_INVALIDDATA;
1441  if (codec47_block(ctx, gb, dst + size, prev1 + size, prev2 + size,
1442  stride, size))
1443  return AVERROR_INVALIDDATA;
1444  }
1445  break;
1446  case 0xFE:
1447  if (bytestream2_get_bytes_left(gb) < 1)
1448  return AVERROR_INVALIDDATA;
1449 
1450  t = bytestream2_get_byteu(gb);
1451  for (k = 0; k < size; k++)
1452  memset(dst + k * stride, t, size);
1453  break;
1454  case 0xFD:
1455  if (bytestream2_get_bytes_left(gb) < 3)
1456  return AVERROR_INVALIDDATA;
1457 
1458  code = bytestream2_get_byteu(gb);
1459  pglyph = (size == 8) ? ctx->p8x8glyphs[code] : ctx->p4x4glyphs[code];
1460  bytestream2_get_bufferu(gb, colors, 2);
1461 
1462  for (k = 0; k < size; k++)
1463  for (t = 0; t < size; t++)
1464  dst[t + k * stride] = colors[!*pglyph++];
1465  break;
1466  case 0xFC:
1467  for (k = 0; k < size; k++)
1468  memcpy(dst + k * stride, prev1 + k * stride, size);
1469  break;
1470  default:
1471  for (k = 0; k < size; k++)
1472  memset(dst + k * stride, ctx->c47cb[code & 3], size);
1473  }
1474  } else {
1475  int mx = c47_mv[code][0];
1476  int my = c47_mv[code][1];
1477  int index = prev2 - (const uint8_t *)ctx->frm2;
1478 
1479  av_assert2(index >= 0 && index < (ctx->buf_size >> 1));
1480 
1481  if (index < -mx - my * stride ||
1482  (ctx->buf_size >> 1) - index < mx + size + (my + size - 1) * stride) {
1483  av_log(ctx->avctx, AV_LOG_ERROR, "MV is invalid.\n");
1484  return AVERROR_INVALIDDATA;
1485  }
1486 
1487  for (k = 0; k < size; k++)
1488  memcpy(dst + k * stride, prev2 + mx + (my + k) * stride, size);
1489  }
1490 
1491  return 0;
1492 }
1493 
1494 static void codec47_read_interptable(GetByteContext *gb, uint8_t *itbl)
1495 {
1496  uint8_t *p1, *p2;
1497  int i, j;
1498 
1499  for (i = 0; i < 256; i++) {
1500  p1 = p2 = itbl + i;
1501  for (j = 256 - i; j; j--) {
1502  *p1 = *p2 = bytestream2_get_byte(gb);
1503  p1 += 1;
1504  p2 += 256;
1505  }
1506  itbl += 256;
1507  }
1508 }
1509 
1510 static void codec47_comp1(GetByteContext *gb, uint8_t *dst_in, int width,
1511  const int height, const ptrdiff_t stride, const uint8_t *itbl)
1512 {
1513  uint8_t p1, *dst;
1514  uint16_t px;
1515  int i, j;
1516 
1517  dst = dst_in + stride;
1518  for (i = 0; i < height; i += 2) {
1519  p1 = bytestream2_get_byte(gb);
1520  *dst++ = p1;
1521  *dst++ = p1;
1522  px = p1;
1523  for (j = 2; j < width; j += 2) {
1524  p1 = bytestream2_get_byte(gb);
1525  px = (px << 8) | p1;
1526  *dst++ = itbl[px];
1527  *dst++ = p1;
1528  }
1529  dst += stride;
1530  }
1531 
1532  memcpy(dst_in, dst_in + stride, width);
1533  dst = dst_in + stride + stride;
1534  for (i = 2; i < height - 1; i += 2) {
1535  for (j = 0; j < width; j++) {
1536  px = (*(dst - stride) << 8) | *(dst + stride);
1537  *dst++ = itbl[px];
1538  }
1539  dst += stride;
1540  }
1541 }
1542 
1543 static int old_codec47(SANMVideoContext *ctx, GetByteContext *gb, int top, int left,
1544  int width, int height)
1545 {
1546  uint32_t decoded_size;
1547  int i, j;
1548  uint8_t *dst = (uint8_t *)ctx->frm0;
1549  uint8_t *prev1 = (uint8_t *)ctx->frm1;
1550  uint8_t *prev2 = (uint8_t *)ctx->frm2;
1551  uint8_t auxcol[2];
1552 
1553  width = FFALIGN(width, 8);
1554  if (width > ctx->aligned_width)
1555  return AVERROR_INVALIDDATA;
1556 
1557  if (FFALIGN(height, 8) > ctx->aligned_height)
1558  return AVERROR_INVALIDDATA;
1559 
1560  if (bytestream2_get_bytes_left(gb) < 26)
1561  return AVERROR_INVALIDDATA;
1562 
1563  int seq = bytestream2_get_le16u(gb);
1564  int compr = bytestream2_get_byteu(gb);
1565  int new_rot = bytestream2_get_byteu(gb);
1566  int skip = bytestream2_get_byteu(gb);
1567 
1568  bytestream2_skip(gb, 3);
1569  bytestream2_get_bufferu(gb, ctx->c47cb, 4);
1570  auxcol[0] = bytestream2_get_byteu(gb);
1571  auxcol[1] = bytestream2_get_byteu(gb);
1572  decoded_size = bytestream2_get_le32u(gb);
1573  bytestream2_skip(gb, 8);
1574 
1575  if (decoded_size > ctx->aligned_height * width) {
1576  decoded_size = height * width;
1577  av_log(ctx->avctx, AV_LOG_WARNING, "Decoded size is too large.\n");
1578  }
1579 
1580  if (skip & 1) {
1581  if (bytestream2_get_bytes_left(gb) < 0x8080)
1582  return AVERROR_INVALIDDATA;
1583  codec47_read_interptable(gb, ctx->c47itbl);
1584  }
1585  if (!seq) {
1586  ctx->prev_seq = -1;
1587  memset(prev1, auxcol[0], ctx->frm0_size);
1588  memset(prev2, auxcol[1], ctx->frm0_size);
1589  }
1590 
1591  switch (compr) {
1592  case 0:
1593  if (bytestream2_get_bytes_left(gb) < width * height)
1594  return AVERROR_INVALIDDATA;
1595  bytestream2_get_bufferu(gb, dst, width * height);
1596  break;
1597  case 1:
1598  if (bytestream2_get_bytes_left(gb) < ((width + 1) >> 1) * ((height + 1) >> 1))
1599  return AVERROR_INVALIDDATA;
1600  codec47_comp1(gb, dst, width, height, width, ctx->c47itbl);
1601  break;
1602  case 2:
1603  if (seq == ctx->prev_seq + 1) {
1604  for (j = 0; j < height; j += 8) {
1605  for (i = 0; i < width; i += 8)
1606  if (codec47_block(ctx, gb, dst + i, prev1 + i, prev2 + i, width, 8))
1607  return AVERROR_INVALIDDATA;
1608  dst += width * 8;
1609  prev1 += width * 8;
1610  prev2 += width * 8;
1611  }
1612  }
1613  break;
1614  case 3:
1615  memcpy(ctx->frm0, ctx->frm2, ctx->frm0_size);
1616  break;
1617  case 4:
1618  memcpy(ctx->frm0, ctx->frm1, ctx->frm0_size);
1619  break;
1620  case 5:
1621  if (rle_decode(ctx, gb, dst, decoded_size))
1622  return AVERROR_INVALIDDATA;
1623  break;
1624  default:
1625  avpriv_report_missing_feature(ctx->avctx,
1626  "Subcodec 47 compression %d", compr);
1627  return AVERROR_PATCHWELCOME;
1628  }
1629 
1630  blt_solid((uint8_t*)ctx->fbuf, (uint8_t*)ctx->frm0, left, top, 0, 0, width,
1631  height, width, ctx->pitch, ctx->height, width * height);
1632 
1633  if ((seq == ctx->prev_seq + 1) && new_rot)
1634  rotate_bufs(ctx, new_rot);
1635 
1636  ctx->prev_seq = seq;
1637 
1638  return 0;
1639 }
1640 
1641 // scale 4x4 input block to an 8x8 output block
1642 static void c48_4to8(uint8_t *dst, const uint8_t *src, const uint16_t w)
1643 {
1644  uint16_t p;
1645  // dst is always at least 16bit aligned
1646  for (int i = 0; i < 4; i++) {
1647  for (int j = 0; j < 8; j += 2) {
1648  p = *src++;
1649  p = (p << 8) | p;
1650  *((uint16_t *)(dst + w * 0 + j)) = p;
1651  *((uint16_t *)(dst + w * 1 + j)) = p;
1652  }
1653  dst += w * 2;
1654  }
1655 }
1656 
1657 static int c48_invalid_mv(int x, int y, const uint16_t w, int h, int blocksize, int mvofs) {
1658  if (mvofs < -x + -y*w)
1659  return AVERROR_INVALIDDATA;
1660 
1661  if (mvofs > w-x-blocksize + w*(h-y-blocksize))
1662  return AVERROR_INVALIDDATA;
1663 
1664  return 0;
1665 }
1666 
1667 static int codec48_block(GetByteContext *gb, uint8_t *dst, uint8_t *db, int x, int y,
1668  const uint16_t w, const int aligned_height, const uint8_t *itbl)
1669 {
1670  uint8_t opc, sb[16];
1671  int i, j, k, l;
1672  int16_t mvofs;
1673  uint32_t ofs;
1674 
1675  if (bytestream2_get_bytes_left(gb) < 1)
1676  return 1;
1677 
1678  opc = bytestream2_get_byteu(gb);
1679  switch (opc) {
1680  case 0xFF: // 1x1 -> 8x8 block scale
1681  if (bytestream2_get_bytes_left(gb) < 1)
1682  return 1;
1683 
1684  if (y > 0 && x > 0) {
1685  sb[15] = bytestream2_get_byteu(gb);
1686  sb[ 7] = itbl[(*(dst - 1*w + 7) << 8) | sb[15]];
1687  sb[ 3] = itbl[(*(dst - 1*w + 7) << 8) | sb[ 7]];
1688  sb[11] = itbl[(sb[15] << 8) | sb[ 7]];
1689  sb[ 1] = itbl[(*(dst + 0*w - 1) << 8) | sb[ 3]];
1690  sb[ 0] = itbl[(*(dst + 0*w - 1) << 8) | sb[ 1]];
1691  sb[ 2] = itbl[(sb[ 3] << 8) | sb[ 1]];
1692  sb[ 5] = itbl[(*(dst + 2*w - 1) << 8) | sb[ 7]];
1693  sb[ 4] = itbl[(*(dst + 2*w - 1) << 8) | sb[ 5]];
1694  sb[ 6] = itbl[(sb[ 7] << 8) | sb[ 5]];
1695  sb[ 9] = itbl[(*(dst + 3*w - 1) << 8) | sb[11]];
1696  sb[ 8] = itbl[(*(dst + 3*w - 1) << 8) | sb[ 9]];
1697  sb[10] = itbl[(sb[11] << 8) | sb[ 9]];
1698  sb[13] = itbl[(*(dst + 4*w - 1) << 8) | sb[15]];
1699  sb[12] = itbl[(*(dst + 4*w - 1) << 8) | sb[13]];
1700  sb[14] = itbl[(sb[15] << 8) | sb[13]];
1701  } else {
1702  opc = bytestream2_get_byteu(gb);
1703  for (i = 0; i < 16; i++)
1704  sb[i] = opc;
1705  }
1706  c48_4to8(dst, sb, w);
1707  break;
1708  case 0xFE: // 1x 8x8 copy from deltabuf, 16bit mv from source
1709  if (bytestream2_get_bytes_left(gb) < 2)
1710  return 1;
1711  mvofs = bytestream2_get_le16(gb);
1712  if (c48_invalid_mv(x, y, w, aligned_height, 8, mvofs))
1713  break;
1714  for (i = 0; i < 8; i++) {
1715  ofs = w * i;
1716  for (k = 0; k < 8; k++)
1717  *(dst + ofs + k) = *(db + ofs + k + mvofs);
1718  }
1719  break;
1720  case 0xFD: // 2x2 -> 8x8 block scale
1721  if (bytestream2_get_bytes_left(gb) < 4)
1722  return 1;
1723  sb[ 5] = bytestream2_get_byteu(gb);
1724  sb[ 7] = bytestream2_get_byteu(gb);
1725  sb[13] = bytestream2_get_byteu(gb);
1726  sb[15] = bytestream2_get_byteu(gb);
1727 
1728  if (y > 0 && x >0) {
1729  sb[ 1] = itbl[(*(dst - 1*w + 3) << 8) | sb[ 5]];
1730  sb[ 3] = itbl[(*(dst - 1*w + 7) << 8) | sb[ 7]];
1731  sb[ 9] = itbl[(sb[13] << 8) | sb[ 5]];
1732  sb[11] = itbl[(sb[15] << 8) | sb[ 7]];
1733  sb[ 0] = itbl[(*(dst + 0*w - 1) << 8) | sb[ 1]];
1734  sb[ 2] = itbl[(sb[ 3] << 8) | sb[ 1]];
1735  sb[ 4] = itbl[(*(dst + 2*w - 1) << 8) | sb[ 5]];
1736  sb[ 6] = itbl[(sb[ 7] << 8) | sb[ 5]];
1737  sb[ 8] = itbl[(*(dst + 3*w - 1) << 8) | sb[ 9]];
1738  sb[10] = itbl[(sb[11] << 8) | sb[ 9]];
1739  sb[12] = itbl[(*(dst + 4*w - 1) << 8) | sb[13]];
1740  sb[14] = itbl[(sb[15] << 8) | sb[13]];
1741  } else {
1742  sb[ 0] = sb[ 1] = sb[ 4] = sb[ 5];
1743  sb[ 2] = sb[ 3] = sb[ 6] = sb[ 7];
1744  sb[ 8] = sb[ 9] = sb[12] = sb[13];
1745  sb[10] = sb[11] = sb[14] = sb[15];
1746  }
1747  c48_4to8(dst, sb, w);
1748  break;
1749  case 0xFC: // 4x copy 4x4 block, per-block c37_mv from source
1750  if (bytestream2_get_bytes_left(gb) < 4)
1751  return 1;
1752  for (i = 0; i < 8; i += 4) {
1753  for (k = 0; k < 8; k += 4) {
1754  opc = bytestream2_get_byteu(gb);
1755  opc = (opc == 255) ? 0 : opc;
1756  mvofs = c37_mv[opc * 2] + (c37_mv[opc * 2 + 1] * w);
1757  if (c48_invalid_mv(x+k, y+i, w, aligned_height, 4, mvofs))
1758  continue;
1759  for (j = 0; j < 4; j++) {
1760  ofs = (w * (j + i)) + k;
1761  for (l = 0; l < 4; l++)
1762  *(dst + ofs + l) = *(db + ofs + l + mvofs);
1763  }
1764  }
1765  }
1766  break;
1767  case 0xFB: // Copy 4x 4x4 blocks, per-block mv from source
1768  if (bytestream2_get_bytes_left(gb) < 8)
1769  return 1;
1770  for (i = 0; i < 8; i += 4) {
1771  for (k = 0; k < 8; k += 4) {
1772  mvofs = bytestream2_get_le16(gb);
1773  if (c48_invalid_mv(x+k, y+i, w, aligned_height, 4, mvofs))
1774  continue;
1775  for (j = 0; j < 4; j++) {
1776  ofs = (w * (j + i)) + k;
1777  for (l = 0; l < 4; l++)
1778  *(dst + ofs + l) = *(db + ofs + l + mvofs);
1779  }
1780  }
1781  }
1782  break;
1783  case 0xFA: // scale 4x4 input block to 8x8 dest block
1784  if (bytestream2_get_bytes_left(gb) < 16)
1785  return 1;
1786  bytestream2_get_bufferu(gb, sb, 16);
1787  c48_4to8(dst, sb, w);
1788  break;
1789  case 0xF9: // 16x 2x2 copy from delta, per-block c37_mv from source
1790  if (bytestream2_get_bytes_left(gb) < 16)
1791  return 1;
1792  for (i = 0; i < 8; i += 2) {
1793  for (j = 0; j < 8; j += 2) {
1794  ofs = (w * i) + j;
1795  opc = bytestream2_get_byteu(gb);
1796  opc = (opc == 255) ? 0 : opc;
1797  mvofs = c37_mv[opc * 2] + (c37_mv[opc * 2 + 1] * w);
1798  if (c48_invalid_mv(x+j, y+i, w, aligned_height, 2, mvofs))
1799  continue;
1800  for (l = 0; l < 2; l++) {
1801  *(dst + ofs + l + 0) = *(db + ofs + l + 0 + mvofs);
1802  *(dst + ofs + l + w) = *(db + ofs + l + w + mvofs);
1803  }
1804  }
1805  }
1806  break;
1807  case 0xF8: // 16x 2x2 blocks copy, 16bit mv from source
1808  if (bytestream2_get_bytes_left(gb) < 32)
1809  return 1;
1810  for (i = 0; i < 8; i += 2) {
1811  for (j = 0; j < 8; j += 2) {
1812  ofs = w * i + j;
1813  mvofs = bytestream2_get_le16(gb);
1814  if (c48_invalid_mv(x+j, y+i, w, aligned_height, 2, mvofs))
1815  continue;
1816  for (l = 0; l < 2; l++) {
1817  *(dst + ofs + l + 0) = *(db + ofs + l + 0 + mvofs);
1818  *(dst + ofs + l + w) = *(db + ofs + l + w + mvofs);
1819  }
1820  }
1821  }
1822  break;
1823  case 0xF7: // copy 8x8 block from src to dest
1824  if (bytestream2_get_bytes_left(gb) < 64)
1825  return 1;
1826  for (i = 0; i < 8; i++) {
1827  ofs = i * w;
1828  for (l = 0; l < 8; l++)
1829  *(dst + ofs + l) = bytestream2_get_byteu(gb);
1830  }
1831  break;
1832  default: // copy 8x8 block from prev, c37_mv from source
1833  mvofs = c37_mv[opc * 2] + (c37_mv[opc * 2 + 1] * w);
1834  if (c48_invalid_mv(x, y, w, aligned_height, 8, mvofs))
1835  break;
1836  for (i = 0; i < 8; i++) {
1837  ofs = i * w;
1838  for (l = 0; l < 8; l++)
1839  *(dst + ofs + l) = *(db + ofs + l + mvofs);
1840  }
1841  break;
1842  }
1843  return 0;
1844 }
1845 
1846 static int old_codec48(SANMVideoContext *ctx, GetByteContext *gb, int top, int left,
1847  int width, int height)
1848 {
1849  uint8_t *dst, *prev;
1850  int i, j, flags, ah;
1851 
1852  width = FFALIGN(width, 8);
1853  if (width > ctx->aligned_width)
1854  return AVERROR_INVALIDDATA;
1855 
1856  ah = FFALIGN(height, 8);
1857  if (ah > ctx->aligned_height)
1858  return AVERROR_INVALIDDATA;
1859 
1860  if (bytestream2_get_bytes_left(gb) < 16)
1861  return AVERROR_INVALIDDATA;
1862 
1863  int compr = bytestream2_get_byteu(gb);
1864  int mvidx = bytestream2_get_byteu(gb);
1865  int seq = bytestream2_get_le16u(gb);
1866  uint32_t decoded_size = bytestream2_get_le32u(gb);
1867 
1868  // all codec48 videos use 1, but just to be safe...
1869  if (mvidx != 1) {
1870  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid motion base value %d.\n", mvidx);
1871  return AVERROR_INVALIDDATA;
1872  }
1873 
1874  bytestream2_skip(gb, 4);
1875  flags = bytestream2_get_byteu(gb);
1876  bytestream2_skip(gb, 3);
1877 
1878  if (flags & 8) {
1879  if (bytestream2_get_bytes_left(gb) < 0x8080)
1880  return AVERROR_INVALIDDATA;
1881  codec47_read_interptable(gb, ctx->c47itbl);
1882  }
1883 
1884  dst = (uint8_t*)ctx->frm0;
1885  prev = (uint8_t*)ctx->frm2;
1886 
1887  if (seq == 0)
1888  memset(ctx->frm2, 0, ctx->frm2_size);
1889 
1890  switch (compr) {
1891  case 0:
1892  if (bytestream2_get_bytes_left(gb) < width * height)
1893  return AVERROR_INVALIDDATA;
1894  bytestream2_get_bufferu(gb, dst, width * height);
1895  break;
1896  case 2:
1897  if (decoded_size > width * height) {
1898  av_log(ctx->avctx, AV_LOG_ERROR, "Decoded size %u is too large.\n", decoded_size);
1899  decoded_size = width * height;
1900  }
1901 
1902  if (rle_decode(ctx, gb, dst, decoded_size))
1903  return AVERROR_INVALIDDATA;
1904  break;
1905  case 3:
1906  if ((seq == 0) || (seq == ctx->prev_seq + 1)) {
1907  if ((seq & 1) || ((flags & 1) == 0) || (flags & 0x10)) {
1908  FFSWAP(uint16_t*, ctx->frm0, ctx->frm2);
1909  dst = (uint8_t*)ctx->frm0;
1910  prev = (uint8_t*)ctx->frm2;
1911  }
1912  for (j = 0; j < height; j += 8) {
1913  for (i = 0; i < width; i += 8) {
1914  if (codec48_block(gb, dst + i, prev + i, i, j, width,
1915  ah, ctx->c47itbl))
1916  return AVERROR_INVALIDDATA;
1917  }
1918  dst += width * 8;
1919  prev += width * 8;
1920  }
1921  }
1922  break;
1923  case 5:
1924  if (bytestream2_get_bytes_left(gb) < ((width + 1) >> 1) * ((height + 1) >> 1))
1925  return AVERROR_INVALIDDATA;
1926  codec47_comp1(gb, dst, width, height, width, ctx->c47itbl);
1927  break;
1928  case 6: /* this is a "stub" frame that follows a frame with flag 0x10 set. */
1929  break;
1930  default:
1931  avpriv_report_missing_feature(ctx->avctx,
1932  "Subcodec 48 compression %d", compr);
1933  return AVERROR_PATCHWELCOME;
1934  }
1935 
1936  ctx->prev_seq = seq;
1937  if ((flags & 2) == 0) {
1938  if (flags & 0x10) {
1939  /* generate an artificial frame from the 2 buffers. This will be
1940  * followed up immediately with a codec48 compression 6 frame, which
1941  * will then blit the actual decoding result (frm0) to the main buffer.
1942  */
1943  blt_ipol((uint8_t*)ctx->fbuf, (uint8_t*)ctx->frm0, (uint8_t*)ctx->frm2,
1944  left, top, 0, 0, width, height, width, ctx->pitch, ctx->height,
1945  width * height, ctx->c47itbl);
1946  return 0;
1947  }
1948  blt_solid((uint8_t*)ctx->fbuf, (uint8_t*)ctx->frm0, left, top, 0, 0, width,
1949  height, width, ctx->pitch, ctx->height, width * height);
1950  } else {
1951  blt_mask((uint8_t*)ctx->fbuf, (uint8_t*)ctx->frm0, left, top, 0, 0, width,
1952  height, width, ctx->pitch, ctx->height, width * height, 0);
1953  }
1954  return 0;
1955 }
1956 
1957 static void old_codec45(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int flag)
1958 {
1959  int t1, t2, i;
1960 
1961  if (bytestream2_get_bytes_left(gb) < 6)
1962  return;
1963 
1964  bytestream2_skip(gb, 2);
1965  t1 = bytestream2_get_le16u(gb);
1966  t2 = bytestream2_get_byteu(gb);
1967  bytestream2_skip(gb, 1);
1968  if (t2 != 1)
1969  return;
1970  if (t1 == 0) {
1971  if (bytestream2_get_bytes_left(gb) < 0x300)
1972  return;
1973  bytestream2_get_bufferu(gb, ctx->c45tbl1, 0x300);
1974  i = 0;
1975  while ((bytestream2_get_bytes_left(gb) > 1) && (i < 0x8000)) {
1976  uint8_t len = bytestream2_get_byteu(gb);
1977  uint8_t val = bytestream2_get_byteu(gb);
1978  if ((i + len) > 0x8000)
1979  len = 0x8000 - i;
1980  memset(ctx->c45tbl2 + i, val, len);
1981  i += len;
1982  }
1983  }
1984 
1985  if (flag)
1986  return;
1987 
1988  while (bytestream2_get_bytes_left(gb) > 3) {
1989  left += (int16_t)bytestream2_get_le16u(gb);
1990  top += bytestream2_get_byteu(gb);
1991  int len = bytestream2_get_byteu(gb);
1992  while (len >= 0) {
1993  if ((left > 0) && (top > 0) && (left < (ctx->width - 1))) {
1994  if (top >= (ctx->height - 1))
1995  return;
1996 
1997  uint8_t *dst = (uint8_t *)ctx->fbuf + left + top * ctx->pitch;
1998  unsigned int c1 = *(dst - 1) * 3;
1999  unsigned int c2 = *(dst + 1) * 3;
2000  unsigned int r = ctx->c45tbl1[c1 + 0] + ctx->c45tbl1[c2 + 0];
2001  unsigned int g = ctx->c45tbl1[c1 + 1] + ctx->c45tbl1[c2 + 1];
2002  unsigned int b = ctx->c45tbl1[c1 + 2] + ctx->c45tbl1[c2 + 2];
2003  c1 = *(dst - ctx->pitch) * 3;
2004  c2 = *(dst + ctx->pitch) * 3;
2005  r += ctx->c45tbl1[c1 + 0] + ctx->c45tbl1[c2 + 0];
2006  g += ctx->c45tbl1[c1 + 1] + ctx->c45tbl1[c2 + 1];
2007  b += ctx->c45tbl1[c1 + 2] + ctx->c45tbl1[c2 + 2];
2008  *dst = ctx->c45tbl2[((r << 5) & 0x7c00) | (g & 0x3e0) | (b >> 5)];
2009  }
2010  left++;
2011  len--;
2012  }
2013  left--;
2014  }
2015 }
2016 
2017 static int process_frame_obj(SANMVideoContext *ctx, GetByteContext *gb,
2018  int xoff, int yoff)
2019 {
2020  uint16_t w, h, parm2;
2021  uint8_t codec, param;
2022  int16_t left, top;
2023  int fsc;
2024 
2025  codec = bytestream2_get_byteu(gb);
2026  param = bytestream2_get_byteu(gb);
2027  left = bytestream2_get_le16u(gb) + xoff;
2028  top = bytestream2_get_le16u(gb) + yoff;
2029  w = bytestream2_get_le16u(gb);
2030  h = bytestream2_get_le16u(gb);
2031  bytestream2_skip(gb, 2);
2032  parm2 = bytestream2_get_le16u(gb);
2033 
2034  if (w < 1 || h < 1 || w > 640 || h > 480 || left > 640 || top > 480 || left + w <= 0 || top + h <= 0) {
2035  /* codec45 frames with data for the 2 tables have nonsensical dimensions */
2036  if (codec == 45) {
2037  old_codec45(ctx, gb, 0, 0, 1);
2038  return 0;
2039  }
2040 
2041  av_log(ctx->avctx, AV_LOG_WARNING,
2042  "ignoring invalid fobj dimensions: c%d %d %d @ %d %d\n",
2043  codec, w, h, left, top);
2044  return 0;
2045  }
2046 
2047  /* codecs with their own buffers */
2048  fsc = (codec == 37 || codec == 47 || codec == 48);
2049 
2050  /* special case for "Shadows of the Empire" videos: they have top=60
2051  * at all frames to vertically center the video in the 640x480 game
2052  * window, but we don't need that.
2053  */
2054  if ((w == 640) && (h == 272) && (top == 60) && (codec == 47))
2055  left = top = 0;
2056 
2057  if (!ctx->have_dimensions && (codec != 45)) {
2058  int xres, yres;
2059  if (ctx->subversion < 2) {
2060  /* Rebel Assault 1: 384x242 internal size */
2061  xres = 384;
2062  yres = 242;
2063  if (w > xres || h > yres)
2064  return AVERROR_INVALIDDATA;
2065  ctx->have_dimensions = 1;
2066  } else if (fsc) {
2067  /* these codecs work on full frames, trust their dimensions */
2068  xres = w;
2069  yres = h;
2070  ctx->have_dimensions = 1;
2071  } else {
2072  /* detect common sizes */
2073  xres = w + left;
2074  yres = h + top;
2075  if (((xres == 424) && (yres == 260)) || /* RA2 */
2076  ((xres == 320) && (yres == 200)) || /* FT/Dig */
2077  ((xres == 640) && (yres == 272)) || /* SotE */
2078  ((xres == 640) && (yres == 350)) || /* MotS */
2079  ((xres == 640) && (yres == 480))) {
2080  ctx->have_dimensions = 1;
2081  }
2082 
2083  xres = FFMAX(xres, ctx->width);
2084  yres = FFMAX(yres, ctx->height);
2085  }
2086 
2087  if ((xres < (fsc ? 8 : 1)) || (yres < (fsc ? 8 : 1)) || (xres > 640) || (yres > 480))
2088  return AVERROR_INVALIDDATA;
2089 
2090  if (ctx->width < xres || ctx->height < yres) {
2091  int ret = ff_set_dimensions(ctx->avctx, xres, yres);
2092  if (ret < 0)
2093  return ret;
2094  init_sizes(ctx, xres, yres);
2095  if (init_buffers(ctx)) {
2096  av_log(ctx->avctx, AV_LOG_ERROR, "Error resizing buffers.\n");
2097  return AVERROR(ENOMEM);
2098  }
2099  }
2100  } else {
2101  if (((w > ctx->width) || (h > ctx->height) || (w * h > ctx->buf_size)) && fsc) {
2102  /* correct unexpected overly large frames: this happens
2103  * for instance with The Dig's sq1.san video: it has a few
2104  * (all black) 640x480 frames halfway in, while the rest is
2105  * 320x200.
2106  */
2107  av_log(ctx->avctx, AV_LOG_WARNING,
2108  "resizing too large fobj: c%d %d %d @ %d %d\n", codec, w, h, left, top);
2109  w = ctx->width;
2110  h = ctx->height;
2111  }
2112  }
2113 
2114  /* users of codecs>=37 are subversion 2, enforce that for STOR/FTCH */
2115  if (fsc && ctx->subversion < 2) {
2116  ctx->subversion = 2;
2117  ctx->stor_size = 0; /* invalidate existing data */
2118  }
2119 
2120  /* clear the main buffer on the first fob */
2121  if (ctx->first_fob) {
2122  ctx->first_fob = 0;
2123  if (!fsc)
2124  memset(ctx->fbuf, 0, ctx->frm0_size);
2125  }
2126 
2127  switch (codec) {
2128  case 1:
2129  case 3:
2130  return old_codec1(ctx, gb, top, left, w, h, codec == 3);
2131  case 2:
2132  return old_codec2(ctx, gb, top, left, w, h);
2133  case 4:
2134  case 5:
2135  case 33:
2136  case 34:
2137  return old_codec4(ctx, gb, top, left, w, h, param, parm2, codec);
2138  case 20:
2139  return old_codec20(ctx, gb, top, left, w, h);
2140  case 21:
2141  return old_codec21(ctx, gb, top, left, w, h);
2142  case 23:
2143  return old_codec23(ctx, gb, top, left, w, h, param, parm2);
2144  case 31:
2145  case 32:
2146  return old_codec31(ctx, gb, top, left, w, h, param, (codec == 32));
2147  case 37:
2148  return old_codec37(ctx, gb, top, left, w, h); break;
2149  case 45:
2150  old_codec45(ctx, gb, top, left, 0); break;
2151  case 47:
2152  return old_codec47(ctx, gb, top, left, w, h); break;
2153  case 48:
2154  return old_codec48(ctx, gb, top, left, w, h); break;
2155  default:
2156  avpriv_request_sample(ctx->avctx, "Subcodec %d", codec);
2157  ctx->frame->flags |= AV_FRAME_FLAG_CORRUPT;
2158  break;
2159  }
2160  return 0;
2161 }
2162 
2163 static int process_ftch(SANMVideoContext *ctx, int size)
2164 {
2165  int xoff, yoff, ret;
2166  GetByteContext gb;
2167 
2168  /* FTCH defines additional x/y offsets */
2169  if (size == 6) {
2170  bytestream2_skip(&ctx->gb, 2);
2171  xoff = bytestream2_get_le16u(&ctx->gb);
2172  yoff = bytestream2_get_le16u(&ctx->gb);
2173  } else if (size == 12) {
2174  av_assert0(bytestream2_get_bytes_left(&ctx->gb) >= 12);
2175  bytestream2_skip(&ctx->gb, 4);
2176  xoff = bytestream2_get_be32u(&ctx->gb);
2177  yoff = bytestream2_get_be32u(&ctx->gb);
2178  } else
2179  return 1;
2180 
2181  if (ctx->stor_size > 0) {
2182  /* decode the stored FOBJ */
2183  uint8_t *bitstream = av_malloc(ctx->stor_size + AV_INPUT_BUFFER_PADDING_SIZE);
2184  if (!bitstream)
2185  return AVERROR(ENOMEM);
2186  memcpy(bitstream, ctx->stored_frame, ctx->stor_size);
2187  bytestream2_init(&gb, bitstream, ctx->stor_size);
2188  ret = process_frame_obj(ctx, &gb, xoff, yoff);
2189  av_free(bitstream);
2190  } else {
2191  /* this happens a lot in RA1: The individual files are meant to
2192  * be played in sequence, with some referencing objects STORed
2193  * by previous files, e.g. the cockpit codec21 object in RA1 LVL8.
2194  * But spamming the log with errors is also not helpful, so
2195  * here we simply ignore this case. Return 1 to indicate that
2196  * there was no valid image fetched.
2197  */
2198  ret = 1;
2199  }
2200  return ret;
2201 }
2202 
2203 static int process_xpal(SANMVideoContext *ctx, int size)
2204 {
2205  int16_t *dp = ctx->delta_pal;
2206  uint32_t *pal = ctx->pal;
2207  uint16_t cmd;
2208  uint8_t c[3];
2209  int i, j;
2210 
2211  if (size < 4)
2212  return AVERROR_INVALIDDATA;
2213  bytestream2_skip(&ctx->gb, 2);
2214  cmd = bytestream2_get_be16(&ctx->gb);
2215  size -= 4;
2216 
2217  if (cmd == 1) {
2218  for (i = 0; i < PALETTE_DELTA; i += 3) {
2219  for (j = 0; j < 3; j++) {
2220  ctx->shift_pal[i + j] += dp[i + j];
2221  c[j] = av_clip_uint8(ctx->shift_pal[i + j] >> 7) & 0xFFU;
2222  }
2223  *pal++ = 0xFFU << 24 | c[0] << 16 | c[1] << 8 | c[2];
2224  }
2225  } else if (cmd == 0 || cmd == 2) {
2226  if (size < PALETTE_DELTA * 2) {
2227  av_log(ctx->avctx, AV_LOG_ERROR,
2228  "Incorrect palette change block size %"PRIu32".\n", size);
2229  return AVERROR_INVALIDDATA;
2230  }
2231  for (i = 0; i < PALETTE_DELTA; i++)
2232  dp[i] = bytestream2_get_le16u(&ctx->gb);
2233  size -= PALETTE_DELTA * 2;
2234 
2235  if (size >= PALETTE_SIZE * 3) {
2236  for (i = 0; i < PALETTE_SIZE; i++)
2237  ctx->pal[i] = 0xFFU << 24 | bytestream2_get_be24u(&ctx->gb);
2238  if (ctx->subversion < 2)
2239  ctx->pal[0] = 0xFFU << 24;
2240  }
2241  for (i = 0, j = 0; i < PALETTE_DELTA; i += 3, j++) {
2242  ctx->shift_pal[i + 0] = (((ctx->pal[j]) >> 16) & 0xFFU) << 7;
2243  ctx->shift_pal[i + 1] = (((ctx->pal[j]) >> 8) & 0xFFU) << 7;
2244  ctx->shift_pal[i + 2] = (((ctx->pal[j]) >> 0) & 0xFFU) << 7;
2245  }
2246  }
2247  return 0;
2248 }
2249 
2250 static int bl16_decode_0(SANMVideoContext *ctx)
2251 {
2252  uint16_t *frm = ctx->frm0;
2253  int x, y;
2254 
2255  if (bytestream2_get_bytes_left(&ctx->gb) < ctx->width * ctx->height * 2) {
2256  av_log(ctx->avctx, AV_LOG_ERROR, "Insufficient data for raw frame.\n");
2257  return AVERROR_INVALIDDATA;
2258  }
2259  for (y = 0; y < ctx->height; y++) {
2260  for (x = 0; x < ctx->width; x++)
2261  frm[x] = bytestream2_get_le16u(&ctx->gb);
2262  frm += ctx->pitch;
2263  }
2264  return 0;
2265 }
2266 
2267 /* BL16 pixel interpolation function, see tgsmush.dll c690 */
2268 static inline uint16_t bl16_c1_avg_col(uint16_t c1, uint16_t c2)
2269 {
2270  return (((c2 & 0x07e0) + (c1 & 0x07e0)) & 0x00fc0) |
2271  (((c2 & 0xf800) + (c1 & 0xf800)) & 0x1f000) |
2272  (((c2 & 0x001f) + (c1 & 0x001f))) >> 1;
2273 }
2274 
2275 /* Quarter-sized keyframe encoded as stream of 16bit pixel values. Interpolate
2276  * missing pixels by averaging the colors of immediate neighbours.
2277  * Identical to codec47_comp1() but with 16bit-pixels. tgsmush.dll c6f0
2278  */
2279 static int bl16_decode_1(SANMVideoContext *ctx)
2280 {
2281  uint16_t hh, hw, hw1, c1, c2, *dst1, *dst2;
2282 
2283  hh = (ctx->height + 1) >> 1;
2284  hw1 = (ctx->width - 1) >> 1;
2285  if (!hw1 || (bytestream2_get_bytes_left(&ctx->gb) < (hh * hw1 * 2)))
2286  return AVERROR_INVALIDDATA;
2287  dst1 = (uint16_t *)ctx->frm0 + ctx->pitch; /* start with line 1 */
2288  while (hh--) {
2289  hw = hw1;
2290  c1 = bytestream2_get_le16u(&ctx->gb);
2291  dst1[0] = c1;
2292  dst1[1] = c1;
2293  dst2 = dst1 + 2;
2294  while (--hw) {
2295  c2 = bytestream2_get_le16u(&ctx->gb);
2296  *dst2++ = bl16_c1_avg_col(c1, c2);
2297  *dst2++ = c2;
2298  c1 = c2;
2299  }
2300  dst1 += ctx->pitch * 2; /* skip to overnext line */
2301  }
2302  /* line 0 is a copy of line 1 */
2303  memcpy(ctx->frm0, ctx->frm0 + ctx->pitch, ctx->pitch);
2304 
2305  /* complete the skipped lines by averaging from the pixels in the lines
2306  * above and below
2307  */
2308  dst1 = ctx->frm0 + (ctx->pitch * 2);
2309  hh = (ctx->height - 1) >> 1;
2310  while (hh--) {
2311  hw = ctx->width;
2312  dst2 = dst1;
2313  while (hw--) {
2314  c1 = *(dst2 - ctx->pitch); /* pixel from line above */
2315  c2 = *(dst2 + ctx->pitch); /* pixel from line below */
2316  *dst2++ = bl16_c1_avg_col(c1, c2);
2317  }
2318  dst1 += ctx->pitch * 2;
2319  }
2320  return 0;
2321 }
2322 
2323 static void copy_block(uint16_t *pdest, uint16_t *psrc, int block_size, ptrdiff_t pitch)
2324 {
2325  uint8_t *dst = (uint8_t *)pdest;
2326  uint8_t *src = (uint8_t *)psrc;
2327  ptrdiff_t stride = pitch * 2;
2328 
2329  switch (block_size) {
2330  case 2:
2331  copy_block4(dst, src, stride, stride, 2);
2332  break;
2333  case 4:
2334  copy_block8(dst, src, stride, stride, 4);
2335  break;
2336  case 8:
2337  copy_block16(dst, src, stride, stride, 8);
2338  break;
2339  }
2340 }
2341 
2342 static void fill_block(uint16_t *pdest, uint16_t color, int block_size, ptrdiff_t pitch)
2343 {
2344  int x, y;
2345 
2346  pitch -= block_size;
2347  for (y = 0; y < block_size; y++, pdest += pitch)
2348  for (x = 0; x < block_size; x++)
2349  *pdest++ = color;
2350 }
2351 
2352 static int draw_glyph(SANMVideoContext *ctx, uint16_t *dst, int index,
2353  uint16_t fg_color, uint16_t bg_color, int block_size,
2354  ptrdiff_t pitch)
2355 {
2356  int8_t *pglyph;
2357  uint16_t colors[2] = { fg_color, bg_color };
2358  int x, y;
2359 
2360  if (index >= NGLYPHS) {
2361  av_log(ctx->avctx, AV_LOG_ERROR, "Ignoring nonexistent glyph #%u.\n", index);
2362  return AVERROR_INVALIDDATA;
2363  }
2364 
2365  pglyph = block_size == 8 ? ctx->p8x8glyphs[index] : ctx->p4x4glyphs[index];
2366  pitch -= block_size;
2367 
2368  for (y = 0; y < block_size; y++, dst += pitch)
2369  for (x = 0; x < block_size; x++)
2370  *dst++ = colors[*pglyph++];
2371  return 0;
2372 }
2373 
2374 static int opcode_0xf7(SANMVideoContext *ctx, int cx, int cy, int block_size, ptrdiff_t pitch)
2375 {
2376  uint16_t *dst = ctx->frm0 + cx + cy * ctx->pitch;
2377 
2378  if (block_size == 2) {
2379  uint32_t indices;
2380 
2381  if (bytestream2_get_bytes_left(&ctx->gb) < 4)
2382  return AVERROR_INVALIDDATA;
2383 
2384  indices = bytestream2_get_le32u(&ctx->gb);
2385  dst[0] = ctx->codebook[indices & 0xFF];
2386  indices >>= 8;
2387  dst[1] = ctx->codebook[indices & 0xFF];
2388  indices >>= 8;
2389  dst[pitch] = ctx->codebook[indices & 0xFF];
2390  indices >>= 8;
2391  dst[pitch + 1] = ctx->codebook[indices & 0xFF];
2392  } else {
2393  uint16_t fgcolor, bgcolor;
2394  int glyph;
2395 
2396  if (bytestream2_get_bytes_left(&ctx->gb) < 3)
2397  return AVERROR_INVALIDDATA;
2398 
2399  glyph = bytestream2_get_byteu(&ctx->gb);
2400  bgcolor = ctx->codebook[bytestream2_get_byteu(&ctx->gb)];
2401  fgcolor = ctx->codebook[bytestream2_get_byteu(&ctx->gb)];
2402 
2403  draw_glyph(ctx, dst, glyph, fgcolor, bgcolor, block_size, pitch);
2404  }
2405  return 0;
2406 }
2407 
2408 static int opcode_0xf8(SANMVideoContext *ctx, int cx, int cy, int block_size, ptrdiff_t pitch)
2409 {
2410  uint16_t *dst = ctx->frm0 + cx + cy * ctx->pitch;
2411 
2412  if (block_size == 2) {
2413  if (bytestream2_get_bytes_left(&ctx->gb) < 8)
2414  return AVERROR_INVALIDDATA;
2415 
2416  dst[0] = bytestream2_get_le16u(&ctx->gb);
2417  dst[1] = bytestream2_get_le16u(&ctx->gb);
2418  dst[pitch] = bytestream2_get_le16u(&ctx->gb);
2419  dst[pitch + 1] = bytestream2_get_le16u(&ctx->gb);
2420  } else {
2421  uint16_t fgcolor, bgcolor;
2422  int glyph;
2423 
2424  if (bytestream2_get_bytes_left(&ctx->gb) < 5)
2425  return AVERROR_INVALIDDATA;
2426 
2427  glyph = bytestream2_get_byteu(&ctx->gb);
2428  bgcolor = bytestream2_get_le16u(&ctx->gb);
2429  fgcolor = bytestream2_get_le16u(&ctx->gb);
2430 
2431  draw_glyph(ctx, dst, glyph, fgcolor, bgcolor, block_size, pitch);
2432  }
2433  return 0;
2434 }
2435 
2436 static int good_mvec(SANMVideoContext *ctx, int cx, int cy, int mx, int my,
2437  int block_size)
2438 {
2439  int start_pos = cx + mx + (cy + my) * ctx->pitch;
2440  int end_pos = start_pos + (block_size - 1) * (ctx->pitch + 1);
2441 
2442  int good = start_pos >= 0 && end_pos < (ctx->buf_size >> 1);
2443 
2444  if (!good)
2445  av_log(ctx->avctx, AV_LOG_ERROR,
2446  "Ignoring invalid motion vector (%i, %i)->(%u, %u), block size = %u\n",
2447  cx + mx, cy + my, cx, cy, block_size);
2448 
2449  return good;
2450 }
2451 
2452 static int bl16_block(SANMVideoContext *ctx, int cx, int cy, int blk_size)
2453 {
2454  int16_t mx, my, index;
2455  int opcode;
2456 
2457  if (bytestream2_get_bytes_left(&ctx->gb) < 1)
2458  return AVERROR_INVALIDDATA;
2459 
2460  opcode = bytestream2_get_byteu(&ctx->gb);
2461 
2462  switch (opcode) {
2463  default:
2464  mx = c47_mv[opcode][0];
2465  my = c47_mv[opcode][1];
2466 
2467  /* The original implementation of this codec precomputes a table
2468  * of int16_t of all motion vectors a for given image width.
2469  * For widths starting at 762 pixels, the calculation of
2470  * mv table indices 1+ and 255- overflow the int16_t, inverting the
2471  * sign of the offset. This is actively exploited in e.g. the
2472  * "jonesopn_8.snm" video of "Indiana Jones and the Infernal Machine".
2473  * Therefore let the overflow happen and extract x/y components from
2474  * the new value.
2475  */
2476  if (ctx->width > 761) {
2477  index = (int16_t)(my * ctx->width + mx);
2478  mx = index % ctx->width;
2479  my = index / ctx->width;
2480  }
2481  if (good_mvec(ctx, cx, cy, mx, my, blk_size)) {
2482  copy_block(ctx->frm0 + cx + ctx->pitch * cy,
2483  ctx->frm2 + cx + mx + ctx->pitch * (cy + my),
2484  blk_size, ctx->pitch);
2485  }
2486  break;
2487  case 0xF5:
2488  if (bytestream2_get_bytes_left(&ctx->gb) < 2)
2489  return AVERROR_INVALIDDATA;
2490  index = bytestream2_get_le16u(&ctx->gb);
2491 
2492  mx = index % ctx->width;
2493  my = index / ctx->width;
2494 
2495  if (good_mvec(ctx, cx, cy, mx, my, blk_size)) {
2496  copy_block(ctx->frm0 + cx + ctx->pitch * cy,
2497  ctx->frm2 + cx + mx + ctx->pitch * (cy + my),
2498  blk_size, ctx->pitch);
2499  }
2500  break;
2501  case 0xF6:
2502  copy_block(ctx->frm0 + cx + ctx->pitch * cy,
2503  ctx->frm1 + cx + ctx->pitch * cy,
2504  blk_size, ctx->pitch);
2505  break;
2506  case 0xF7:
2507  opcode_0xf7(ctx, cx, cy, blk_size, ctx->pitch);
2508  break;
2509 
2510  case 0xF8:
2511  opcode_0xf8(ctx, cx, cy, blk_size, ctx->pitch);
2512  break;
2513  case 0xF9:
2514  case 0xFA:
2515  case 0xFB:
2516  case 0xFC:
2517  fill_block(ctx->frm0 + cx + cy * ctx->pitch,
2518  ctx->small_codebook[opcode - 0xf9], blk_size, ctx->pitch);
2519  break;
2520  case 0xFD:
2521  if (bytestream2_get_bytes_left(&ctx->gb) < 1)
2522  return AVERROR_INVALIDDATA;
2523  fill_block(ctx->frm0 + cx + cy * ctx->pitch,
2524  ctx->codebook[bytestream2_get_byteu(&ctx->gb)], blk_size, ctx->pitch);
2525  break;
2526  case 0xFE:
2527  if (bytestream2_get_bytes_left(&ctx->gb) < 2)
2528  return AVERROR_INVALIDDATA;
2529  fill_block(ctx->frm0 + cx + cy * ctx->pitch,
2530  bytestream2_get_le16u(&ctx->gb), blk_size, ctx->pitch);
2531  break;
2532  case 0xFF:
2533  if (blk_size == 2) {
2534  opcode_0xf8(ctx, cx, cy, blk_size, ctx->pitch);
2535  } else {
2536  blk_size >>= 1;
2537  if (bl16_block(ctx, cx, cy, blk_size))
2538  return AVERROR_INVALIDDATA;
2539  if (bl16_block(ctx, cx + blk_size, cy, blk_size))
2540  return AVERROR_INVALIDDATA;
2541  if (bl16_block(ctx, cx, cy + blk_size, blk_size))
2542  return AVERROR_INVALIDDATA;
2543  if (bl16_block(ctx, cx + blk_size, cy + blk_size, blk_size))
2544  return AVERROR_INVALIDDATA;
2545  }
2546  break;
2547  }
2548  return 0;
2549 }
2550 
2551 static int bl16_decode_2(SANMVideoContext *ctx)
2552 {
2553  int cx, cy, ret;
2554 
2555  for (cy = 0; cy < ctx->aligned_height; cy += 8)
2556  for (cx = 0; cx < ctx->aligned_width; cx += 8)
2557  if (ret = bl16_block(ctx, cx, cy, 8))
2558  return ret;
2559 
2560  return 0;
2561 }
2562 
2563 static int bl16_decode_5(SANMVideoContext *ctx, int rle_size)
2564 {
2565 #if HAVE_BIGENDIAN
2566  uint16_t *frm;
2567  int npixels;
2568 #endif
2569  uint8_t *dst = (uint8_t*)ctx->frm0;
2570 
2571  if (rle_decode(ctx, &ctx->gb, dst, rle_size))
2572  return AVERROR_INVALIDDATA;
2573 
2574 #if HAVE_BIGENDIAN
2575  npixels = ctx->npixels;
2576  frm = ctx->frm0;
2577  while (npixels--) {
2578  *frm = av_bswap16(*frm);
2579  frm++;
2580  }
2581 #endif
2582 
2583  return 0;
2584 }
2585 
2586 static int bl16_decode_6(SANMVideoContext *ctx)
2587 {
2588  int npixels = ctx->npixels;
2589  uint16_t *frm = ctx->frm0;
2590 
2591  if (bytestream2_get_bytes_left(&ctx->gb) < npixels) {
2592  av_log(ctx->avctx, AV_LOG_ERROR, "Insufficient data for frame.\n");
2593  return AVERROR_INVALIDDATA;
2594  }
2595  while (npixels--)
2596  *frm++ = ctx->codebook[bytestream2_get_byteu(&ctx->gb)];
2597 
2598  return 0;
2599 }
2600 
2601 /* Quarter-sized keyframe encoded as stream of codebook indices. Interpolate
2602  * missing pixels by averaging the colors of immediate neighbours.
2603  * Identical to codec47_comp1(), but without the interpolation table.
2604  * tgsmush.dll c6f0
2605  */
2606 static int bl16_decode_7(SANMVideoContext *ctx)
2607 {
2608  uint16_t hh, hw, hw1, c1, c2, *dst1, *dst2;
2609 
2610  hh = (ctx->height + 1) >> 1;
2611  hw1 = (ctx->width - 1) >> 1;
2612  if (!hw1 || (bytestream2_get_bytes_left(&ctx->gb) < (hh * hw1)))
2613  return AVERROR_INVALIDDATA;
2614  dst1 = (uint16_t *)ctx->frm0 + ctx->pitch; /* start with line 1 */
2615  while (hh--) {
2616  hw = hw1;
2617  c1 = ctx->codebook[bytestream2_get_byteu(&ctx->gb)];
2618  dst1[0] = c1; /* leftmost 2 pixels of a row are identical */
2619  dst1[1] = c1;
2620  dst2 = dst1 + 2;
2621  while (--hw) {
2622  c2 = ctx->codebook[bytestream2_get_byteu(&ctx->gb)];
2623  *dst2++ = bl16_c1_avg_col(c1, c2);
2624  *dst2++ = c2;
2625  c1 = c2;
2626  }
2627  dst1 += ctx->pitch * 2; /* skip to overnext line */
2628  }
2629  /* line 0 is a copy of line 1 */
2630  memcpy(ctx->frm0, ctx->frm0 + ctx->pitch, ctx->pitch);
2631 
2632  /* complete the skipped lines by averaging from the pixels in the lines
2633  * above and below.
2634  */
2635  dst1 = ctx->frm0 + (ctx->pitch * 2);
2636  hh = (ctx->height - 1) >> 1;
2637  while (hh--) {
2638  hw = ctx->width;
2639  dst2 = dst1;
2640  while (hw--) {
2641  c1 = *(dst2 - ctx->pitch); /* pixel from line above */
2642  c2 = *(dst2 + ctx->pitch); /* pixel from line below */
2643  *dst2++ = bl16_c1_avg_col(c1, c2);
2644  }
2645  dst1 += ctx->pitch * 2;
2646  }
2647  return 0;
2648 }
2649 
2650 static int bl16_decode_8(SANMVideoContext *ctx)
2651 {
2652  uint16_t *pdest = ctx->frm0;
2653  uint8_t *rsrc;
2654  long npixels = ctx->npixels;
2655 
2656  av_fast_malloc(&ctx->rle_buf, &ctx->rle_buf_size, npixels);
2657  if (!ctx->rle_buf) {
2658  av_log(ctx->avctx, AV_LOG_ERROR, "RLE buffer allocation failed.\n");
2659  return AVERROR(ENOMEM);
2660  }
2661  rsrc = ctx->rle_buf;
2662 
2663  if (rle_decode(ctx, &ctx->gb, rsrc, npixels))
2664  return AVERROR_INVALIDDATA;
2665 
2666  while (npixels--)
2667  *pdest++ = ctx->codebook[*rsrc++];
2668 
2669  return 0;
2670 }
2671 
2672 static void fill_frame(uint16_t *pbuf, int buf_size, uint16_t color)
2673 {
2674  if (buf_size--) {
2675  *pbuf++ = color;
2676  av_memcpy_backptr((uint8_t*)pbuf, 2, 2*buf_size);
2677  }
2678 }
2679 
2680 static int copy_output(SANMVideoContext *ctx, int sanm)
2681 {
2682  uint8_t *dst;
2683  const uint8_t *src = sanm ? (uint8_t *)ctx->frm0 : (uint8_t *)ctx->fbuf;
2684  int ret, height = ctx->height;
2685  ptrdiff_t dstpitch, srcpitch = ctx->pitch * (sanm ? sizeof(ctx->frm0[0]) : 1);
2686 
2687  if ((ret = ff_get_buffer(ctx->avctx, ctx->frame, 0)) < 0)
2688  return ret;
2689 
2690  dst = ctx->frame->data[0];
2691  dstpitch = ctx->frame->linesize[0];
2692 
2693  while (height--) {
2694  memcpy(dst, src, srcpitch);
2695  src += srcpitch;
2696  dst += dstpitch;
2697  }
2698 
2699  return 0;
2700 }
2701 
2702 static int decode_bl16(AVCodecContext *avctx,int *got_frame_ptr)
2703 {
2704  SANMVideoContext *ctx = avctx->priv_data;
2705  int i, ret, w, h, seq_num, codec, bg_color, rle_output_size, rcode;
2706 
2707  if ((ret = bytestream2_get_bytes_left(&ctx->gb)) < 560) {
2708  av_log(ctx->avctx, AV_LOG_ERROR, "Input frame too short (%d bytes).\n",
2709  ret);
2710  return AVERROR_INVALIDDATA;
2711  }
2712  bytestream2_skip(&ctx->gb, 8); // skip pad
2713 
2714  w = bytestream2_get_le32u(&ctx->gb);
2715  h = bytestream2_get_le32u(&ctx->gb);
2716 
2717  if (w != ctx->width || h != ctx->height) {
2718  avpriv_report_missing_feature(ctx->avctx, "Variable size frames");
2719  return AVERROR_PATCHWELCOME;
2720  }
2721 
2722  seq_num = bytestream2_get_le16u(&ctx->gb);
2723  codec = bytestream2_get_byteu(&ctx->gb);
2724  rcode = bytestream2_get_byteu(&ctx->gb);
2725 
2726  bytestream2_skip(&ctx->gb, 4); // skip pad
2727 
2728  for (i = 0; i < 4; i++)
2729  ctx->small_codebook[i] = bytestream2_get_le16u(&ctx->gb);
2730  bg_color = bytestream2_get_le16u(&ctx->gb);
2731 
2732  bytestream2_skip(&ctx->gb, 2); // skip pad
2733 
2734  rle_output_size = bytestream2_get_le32u(&ctx->gb);
2735  if (rle_output_size > w * ctx->aligned_height * 2) {
2736  av_log(avctx, AV_LOG_WARNING, "bl16 rle size too large, truncated: %d\n",
2737  rle_output_size);
2738  rle_output_size = w * ctx->aligned_height * 2;
2739  }
2740 
2741  for (i = 0; i < 256; i++)
2742  ctx->codebook[i] = bytestream2_get_le16u(&ctx->gb);
2743 
2744  bytestream2_skip(&ctx->gb, 8); // skip pad
2745 
2746  if (seq_num == 0) {
2747  ctx->frame->flags |= AV_FRAME_FLAG_KEY;
2748  ctx->frame->pict_type = AV_PICTURE_TYPE_I;
2749  fill_frame(ctx->frm1, ctx->npixels, bg_color);
2750  fill_frame(ctx->frm2, ctx->npixels, bg_color);
2751  } else {
2752  ctx->frame->flags &= ~AV_FRAME_FLAG_KEY;
2753  ctx->frame->pict_type = AV_PICTURE_TYPE_P;
2754  }
2755 
2756  ret = 0;
2757  switch (codec) {
2758  case 0: ret = bl16_decode_0(ctx); break;
2759  case 1: ret = bl16_decode_1(ctx); break;
2760  case 2: ret = bl16_decode_2(ctx); break;
2761  case 3: memcpy(ctx->frm0, ctx->frm2, ctx->frm2_size); break;
2762  case 4: memcpy(ctx->frm0, ctx->frm1, ctx->frm1_size); break;
2763  case 5: ret = bl16_decode_5(ctx, rle_output_size); break;
2764  case 6: ret = bl16_decode_6(ctx); break;
2765  case 7: ret = bl16_decode_7(ctx); break;
2766  case 8: ret = bl16_decode_8(ctx); break;
2767  default:
2768  avpriv_request_sample(ctx->avctx, "Unknown/unsupported compression type %d", codec);
2769  return AVERROR_PATCHWELCOME;
2770  }
2771 
2772  if (ret) {
2773  av_log(avctx, AV_LOG_ERROR,
2774  "Subcodec %d: error decoding frame.\n", codec);
2775  return ret;
2776  }
2777 
2778  ret = copy_output(ctx, 1);
2779  if (rcode)
2780  rotate_bufs(ctx, rcode);
2781  if (ret)
2782  return ret;
2783 
2784  *got_frame_ptr = 1;
2785  return 0;
2786 }
2787 
2788 static int decode_anim(AVCodecContext *avctx, int *got_frame_ptr)
2789 {
2790  SANMVideoContext *ctx = avctx->priv_data;
2791  int i, ret, to_store = 0, have_img = 0;
2792 
2793  ctx->first_fob = 1;
2794  while (bytestream2_get_bytes_left(&ctx->gb) >= 8) {
2795  uint32_t sig, size;
2796  int pos;
2797 
2798  sig = bytestream2_get_be32u(&ctx->gb);
2799  size = bytestream2_get_be32u(&ctx->gb);
2800  pos = bytestream2_tell(&ctx->gb);
2801 
2802  if (bytestream2_get_bytes_left(&ctx->gb) < size) {
2803  av_log(avctx, AV_LOG_ERROR, "Incorrect chunk size %"PRIu32".\n", size);
2804  break;
2805  }
2806  switch (sig) {
2807  case MKBETAG('N', 'P', 'A', 'L'):
2808  if (size != PALETTE_SIZE * 3) {
2809  av_log(avctx, AV_LOG_ERROR,
2810  "Incorrect palette block size %"PRIu32".\n", size);
2811  return AVERROR_INVALIDDATA;
2812  }
2813  for (i = 0; i < PALETTE_SIZE; i++)
2814  ctx->pal[i] = 0xFFU << 24 | bytestream2_get_be24u(&ctx->gb);
2815  if (ctx->subversion < 2)
2816  ctx->pal[0] = 0xFFU << 24;
2817  break;
2818  case MKBETAG('F', 'O', 'B', 'J'):
2819  if (size < 16)
2820  return AVERROR_INVALIDDATA;
2821  GetByteContext fc;
2822  bytestream2_init(&fc, ctx->gb.buffer, size);
2823  if (ret = process_frame_obj(ctx, &fc, 0, 0)) {
2824  return ret;
2825  }
2826  have_img = 1;
2827 
2828  /* STOR: for ANIMv0/1 store the whole FOBJ datablock, as it
2829  * needs to be replayed on FTCH, since none of the codecs
2830  * it uses work on the full buffer.
2831  * For ANIMv2, it's enough to store the current framebuffer.
2832  */
2833  if (to_store) {
2834  to_store = 0;
2835  if (ctx->subversion < 2) {
2836  if (size <= ctx->stored_frame_size) {
2837  bytestream2_seek(&fc, 0, SEEK_SET);
2838  bytestream2_get_bufferu(&fc, ctx->stored_frame, size);
2839  ctx->stor_size = size;
2840  } else {
2841  av_log(avctx, AV_LOG_ERROR, "FOBJ too large for STOR\n");
2842  ret = AVERROR(ENOMEM);
2843  }
2844  } else {
2845  memcpy(ctx->stored_frame, ctx->fbuf, ctx->buf_size);
2846  ctx->stor_size = ctx->buf_size;
2847  }
2848  }
2849  bytestream2_skip(&ctx->gb, size);
2850  break;
2851  case MKBETAG('X', 'P', 'A', 'L'):
2852  if (ret = process_xpal(ctx, size))
2853  return ret;
2854  break;
2855  case MKBETAG('S', 'T', 'O', 'R'):
2856  to_store = 1;
2857  break;
2858  case MKBETAG('F', 'T', 'C', 'H'):
2859  if (ctx->subversion < 2) {
2860  if ((ret = process_ftch(ctx, size)) < 0)
2861  return ret;
2862  have_img = (ret == 0) ? 1 : 0;
2863  } else {
2864  if (ctx->stor_size > 0) {
2865  memcpy(ctx->fbuf, ctx->stored_frame, ctx->buf_size);
2866  have_img = 1;
2867  }
2868  }
2869  break;
2870  default:
2871  bytestream2_skip(&ctx->gb, size);
2872  av_log(avctx, AV_LOG_DEBUG,
2873  "Unknown/unsupported chunk %"PRIx32".\n", sig);
2874  break;
2875  }
2876 
2877  /* the sizes of chunks are usually a multiple of 2. However
2878  * there are a few unaligned FOBJs in RA1 L2PLAY.ANM only (looks
2879  * like a game bug) and IACT audio chunks which have odd sizes
2880  * but are padded with a zero byte.
2881  */
2882  bytestream2_seek(&ctx->gb, pos + size, SEEK_SET);
2883  if ((pos + size) & 1) {
2884  if (bytestream2_peek_byte(&ctx->gb) == 0)
2885  bytestream2_skip(&ctx->gb, 1);
2886  }
2887  }
2888 
2889  if (have_img) {
2890  if ((ret = copy_output(ctx, 0)))
2891  return ret;
2892  memcpy(ctx->frame->data[1], ctx->pal, 1024);
2893  *got_frame_ptr = 1;
2894  }
2895  return 0;
2896 }
2897 
2898 static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
2899  int *got_frame_ptr, AVPacket *pkt)
2900 {
2901  SANMVideoContext *ctx = avctx->priv_data;
2902  int ret;
2903 
2904  ctx->frame = frame;
2905  bytestream2_init(&ctx->gb, pkt->data, pkt->size);
2906 
2907  if (!ctx->version) {
2908  if ((ret = decode_anim(avctx, got_frame_ptr)))
2909  return ret;
2910  } else {
2911  if ((ret = decode_bl16(avctx, got_frame_ptr)))
2912  return ret;
2913  }
2914  return pkt->size;
2915 }
2916 
2917 const FFCodec ff_sanm_decoder = {
2918  .p.name = "sanm",
2919  CODEC_LONG_NAME("LucasArts SANM/Smush video"),
2920  .p.type = AVMEDIA_TYPE_VIDEO,
2921  .p.id = AV_CODEC_ID_SANM,
2922  .priv_data_size = sizeof(SANMVideoContext),
2923  .init = decode_init,
2924  .close = decode_end,
2925  FF_CODEC_DECODE_CB(decode_frame),
2926  .p.capabilities = AV_CODEC_CAP_DR1,
2927 };
SANMVideoContext::width
int width
Definition: sanm.c:274
flags
const SwsFlags flags[]
Definition: swscale.c:61
rle_decode
static int rle_decode(SANMVideoContext *ctx, GetByteContext *gb, uint8_t *dst, const int out_size)
Definition: sanm.c:746
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_CODEC_ID_SANM
@ AV_CODEC_ID_SANM
Definition: codec_id.h:236
SANMVideoContext::fbuf_size
uint32_t fbuf_size
Definition: sanm.c:281
bl16_decode_6
static int bl16_decode_6(SANMVideoContext *ctx)
Definition: sanm.c:2586
codec47_comp1
static void codec47_comp1(GetByteContext *gb, uint8_t *dst_in, int width, const int height, const ptrdiff_t stride, const uint8_t *itbl)
Definition: sanm.c:1510
BOTTOM_EDGE
@ BOTTOM_EDGE
Definition: sanm.c:308
SANMVideoContext::rle_buf
uint8_t * rle_buf
Definition: sanm.c:285
old_codec37
static int old_codec37(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int width, int height)
Definition: sanm.c:1220
fill_block
static void fill_block(uint16_t *pdest, uint16_t color, int block_size, ptrdiff_t pitch)
Definition: sanm.c:2342
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(const GetByteContext *g)
Definition: bytestream.h:158
make_glyphs
static void make_glyphs(int8_t *pglyphs, const int8_t *xvec, const int8_t *yvec, const int side_length)
Construct glyphs by iterating through vector coordinates.
Definition: sanm.c:386
blt_mask
static void blt_mask(uint8_t *dst, const uint8_t *src, int16_t left, int16_t top, uint16_t srcxoff, uint16_t srcyoff, uint16_t srcwidth, uint16_t srcheight, const uint16_t srcpitch, const uint16_t dstpitch, const uint16_t dstheight, int32_t size, const uint8_t skipcolor)
Definition: sanm.c:1086
color
Definition: vf_paletteuse.c:513
GetByteContext
Definition: bytestream.h:33
SANMVideoContext::pal
uint32_t pal[PALETTE_SIZE]
Definition: sanm.c:270
bytestream2_tell
static av_always_inline int bytestream2_tell(const GetByteContext *g)
Definition: bytestream.h:192
bl16_decode_5
static int bl16_decode_5(SANMVideoContext *ctx, int rle_size)
Definition: sanm.c:2563
src1
const pixel * src1
Definition: h264pred_template.c:420
SANMVideoContext::stored_frame
uint8_t * stored_frame
Definition: sanm.c:280
SANMVideoContext::aligned_height
int aligned_height
Definition: sanm.c:275
SANMVideoContext::p4x4glyphs
int8_t p4x4glyphs[NGLYPHS][16]
Definition: sanm.c:293
good_mvec
static int good_mvec(SANMVideoContext *ctx, int cx, int cy, int mx, int my, int block_size)
Definition: sanm.c:2436
mask
int mask
Definition: mediacodecdec_common.c:154
out_size
static int out_size
Definition: movenc.c:56
blt_solid
static void blt_solid(uint8_t *dst, const uint8_t *src, int16_t left, int16_t top, uint16_t srcxoff, uint16_t srcyoff, uint16_t srcwidth, uint16_t srcheight, const uint16_t srcpitch, const uint16_t dstpitch, const uint16_t dstheight, int32_t size)
Definition: sanm.c:1034
old_codec31
static int old_codec31(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int width, int height, int p1, int opaque)
Definition: sanm.c:950
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
AVPacket::data
uint8_t * data
Definition: packet.h:588
b
#define b
Definition: input.c:42
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: sanm.c:670
bl16_decode_1
static int bl16_decode_1(SANMVideoContext *ctx)
Definition: sanm.c:2279
bl16_decode_0
static int bl16_decode_0(SANMVideoContext *ctx)
Definition: sanm.c:2250
interp_point
static void interp_point(int8_t *points, int x0, int y0, int x1, int y1, int pos, int npoints)
Definition: sanm.c:366
FFCodec
Definition: codec_internal.h:127
copy_block8
static void copy_block8(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
Definition: copy_block.h:47
bl16_block
static int bl16_block(SANMVideoContext *ctx, int cx, int cy, int blk_size)
Definition: sanm.c:2452
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
c1
static const uint64_t c1
Definition: murmur3.c:52
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Definition: utils.c:91
ff_sanm_decoder
const FFCodec ff_sanm_decoder
Definition: sanm.c:2917
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:56
c48_invalid_mv
static int c48_invalid_mv(int x, int y, const uint16_t w, int h, int blocksize, int mvofs)
Definition: sanm.c:1657
px
#define px
Definition: ops_tmpl_float.c:35
close
static av_cold void close(AVCodecParserContext *s)
Definition: apv_parser.c:197
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
SANMVideoContext::frame
AVFrame * frame
Definition: sanm.c:278
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition: dsp.h:57
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
copy_output
static int copy_output(SANMVideoContext *ctx, int sanm)
Definition: sanm.c:2680
LEFT_EDGE
@ LEFT_EDGE
Definition: sanm.c:305
glyph8_x
static const int8_t glyph8_x[GLYPH_COORD_VECT_SIZE]
Definition: sanm.c:45
SANMVideoContext::gb
GetByteContext gb
Definition: sanm.c:267
destroy_buffers
static void destroy_buffers(SANMVideoContext *ctx)
Definition: sanm.c:451
val
static double val(void *priv, double ch)
Definition: aeval.c:77
loop
static int loop
Definition: ffplay.c:337
SANMVideoContext::small_codebook
uint16_t small_codebook[4]
Definition: sanm.c:291
DIR_LEFT
@ DIR_LEFT
Definition: sanm.c:313
which_edge
static enum GlyphEdge which_edge(int x, int y, int edge_size)
Return enum GlyphEdge of box where point (x, y) lies.
Definition: sanm.c:327
NO_EDGE
@ NO_EDGE
Definition: sanm.c:309
SANMVideoContext::stor_size
uint32_t stor_size
Definition: sanm.c:282
TOP_EDGE
@ TOP_EDGE
Definition: sanm.c:306
avassert.h
SANMVideoContext::have_dimensions
int have_dimensions
Definition: sanm.c:269
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:111
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:642
bl16_decode_7
static int bl16_decode_7(SANMVideoContext *ctx)
Definition: sanm.c:2606
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:447
clip
clip
Definition: af_crystalizer.c:122
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:523
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:347
process_frame_obj
static int process_frame_obj(SANMVideoContext *ctx, GetByteContext *gb, int xoff, int yoff)
Definition: sanm.c:2017
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1414
c48_4to8
static void c48_4to8(uint8_t *dst, const uint8_t *src, const uint16_t w)
Definition: sanm.c:1642
g
const char * g
Definition: vf_curves.c:128
old_codec47
static int old_codec47(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int width, int height)
Definition: sanm.c:1543
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:494
SANMVideoContext::npixels
long npixels
Definition: sanm.c:288
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
old_codec2
static int old_codec2(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int width, int height)
Definition: sanm.c:1016
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
SANMVideoContext::c45tbl2
uint8_t c45tbl2[0x8000]
Definition: sanm.c:301
opcode_0xf8
static int opcode_0xf8(SANMVideoContext *ctx, int cx, int cy, int block_size, ptrdiff_t pitch)
Definition: sanm.c:2408
ctx
static AVFormatContext * ctx
Definition: movenc.c:49
SANMVideoContext::stored_frame_size
uint32_t stored_frame_size
Definition: sanm.c:283
decode.h
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
codec47_read_interptable
static void codec47_read_interptable(GetByteContext *gb, uint8_t *itbl)
Definition: sanm.c:1494
bl16_decode_2
static int bl16_decode_2(SANMVideoContext *ctx)
Definition: sanm.c:2551
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition: dsp.h:57
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
GlyphEdge
GlyphEdge
Definition: sanm.c:304
init_sizes
static void init_sizes(SANMVideoContext *ctx, int width, int height)
Definition: sanm.c:438
copy_block16
static void copy_block16(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
Definition: copy_block.h:68
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:207
SANMVideoContext::aligned_width
int aligned_width
Definition: sanm.c:275
old_codec23
static int old_codec23(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int width, int height, uint8_t param, uint16_t param2)
Definition: sanm.c:772
SANMVideoContext::avctx
AVCodecContext * avctx
Definition: sanm.c:266
SANMVideoContext::subversion
int subversion
Definition: sanm.c:269
draw_glyph
static int draw_glyph(SANMVideoContext *ctx, uint16_t *dst, int index, uint16_t fg_color, uint16_t bg_color, int block_size, ptrdiff_t pitch)
Definition: sanm.c:2352
bl16_decode_8
static int bl16_decode_8(SANMVideoContext *ctx)
Definition: sanm.c:2650
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
PALETTE_SIZE
#define PALETTE_SIZE
Definition: sanm.c:34
SANMVideoContext::frm1_size
uint32_t frm1_size
Definition: sanm.c:281
SANMVideoContext::frm1
uint16_t * frm1
Definition: sanm.c:279
rotate_bufs
static void rotate_bufs(SANMVideoContext *ctx, int rotate_code)
Definition: sanm.c:617
SANMVideoContext::c47itbl
uint8_t c47itbl[0x10000]
Definition: sanm.c:295
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
codec4_gen_tiles
static void codec4_gen_tiles(SANMVideoContext *ctx, uint16_t param1)
Definition: sanm.c:550
glyph4_y
static const int8_t glyph4_y[GLYPH_COORD_VECT_SIZE]
Definition: sanm.c:41
NGLYPHS
#define NGLYPHS
Definition: sanm.c:32
SANMVideoContext::frm2_size
uint32_t frm2_size
Definition: sanm.c:281
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1747
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:578
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:589
SANMVideoContext
Definition: sanm.c:265
height
#define height
Definition: dsp.h:89
codec37_mv
static void codec37_mv(uint8_t *dst, const uint8_t *src, int height, int stride, int x, int y)
Definition: sanm.c:1201
codec_internal.h
glyph8_y
static const int8_t glyph8_y[GLYPH_COORD_VECT_SIZE]
Definition: sanm.c:49
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
size
int size
Definition: twinvq_data.h:10344
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:98
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
SANMVideoContext::version
int version
Definition: sanm.c:269
bl16_c1_avg_col
static uint16_t bl16_c1_avg_col(uint16_t c1, uint16_t c2)
Definition: sanm.c:2268
SANMVideoContext::frm0
uint16_t * frm0
Definition: sanm.c:279
c47_mv
static const int8_t c47_mv[256][2]
Definition: sanm.c:54
SANMVideoContext::c4param
uint16_t c4param
Definition: sanm.c:298
SANMVideoContext::c23lut
uint8_t c23lut[256]
Definition: sanm.c:296
old_codec4
static int old_codec4(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int w, int h, uint8_t param, uint16_t param2, int codec)
Definition: sanm.c:679
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: sanm.c:624
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:622
PALETTE_DELTA
#define PALETTE_DELTA
Definition: sanm.c:35
copy_block4
static void copy_block4(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
Definition: copy_block.h:37
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
old_codec20
static int old_codec20(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, const int w, const int h)
Definition: sanm.c:1192
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
AV_FRAME_FLAG_CORRUPT
#define AV_FRAME_FLAG_CORRUPT
The frame data may be corrupted, e.g.
Definition: frame.h:638
fill_frame
static void fill_frame(uint16_t *pbuf, int buf_size, uint16_t color)
Definition: sanm.c:2672
copy_block.h
copy_block
static void copy_block(uint16_t *pdest, uint16_t *psrc, int block_size, ptrdiff_t pitch)
Definition: sanm.c:2323
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:522
src2
const pixel * src2
Definition: h264pred_template.c:421
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
process_xpal
static int process_xpal(SANMVideoContext *ctx, int size)
Definition: sanm.c:2203
SANMVideoContext::shift_pal
int16_t shift_pal[PALETTE_DELTA]
Definition: sanm.c:271
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
SANMVideoContext::fbuf
uint16_t * fbuf
Definition: sanm.c:279
SANMVideoContext::first_fob
int first_fob
Definition: sanm.c:269
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:600
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:639
decode_anim
static int decode_anim(AVCodecContext *avctx, int *got_frame_ptr)
Definition: sanm.c:2788
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:526
avcodec.h
SANMVideoContext::codebook
uint16_t codebook[256]
Definition: sanm.c:290
GlyphDir
GlyphDir
Definition: sanm.c:312
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
DIR_DOWN
@ DIR_DOWN
Definition: sanm.c:316
ret
ret
Definition: filter_design.txt:187
glyph4_x
static const int8_t glyph4_x[GLYPH_COORD_VECT_SIZE]
Definition: sanm.c:37
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
SANMVideoContext::frm2
uint16_t * frm2
Definition: sanm.c:279
av_malloc
void * av_malloc(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:98
DIR_RIGHT
@ DIR_RIGHT
Definition: sanm.c:315
pos
unsigned int pos
Definition: spdifenc.c:414
decode_bl16
static int decode_bl16(AVCodecContext *avctx, int *got_frame_ptr)
Definition: sanm.c:2702
c37_mv
static const int8_t c37_mv[]
Definition: sanm.c:109
flag
#define flag(name)
Definition: cbs_av1.c:496
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
run_len
static const uint8_t run_len[7][16]
Definition: h264_cavlc.c:217
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
GLYPH_COORD_VECT_SIZE
#define GLYPH_COORD_VECT_SIZE
Definition: sanm.c:33
old_codec21
static int old_codec21(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int width, int height)
Definition: sanm.c:838
codec47_block
static int codec47_block(SANMVideoContext *ctx, GetByteContext *gb, uint8_t *dst, uint8_t *prev1, uint8_t *prev2, int stride, int size)
Definition: sanm.c:1408
AVCodecContext
main external API structure.
Definition: avcodec.h:439
c2
static const uint64_t c2
Definition: murmur3.c:53
SANMVideoContext::c47cb
uint8_t c47cb[4]
Definition: sanm.c:299
SANMVideoContext::rle_buf_size
unsigned int rle_buf_size
Definition: sanm.c:286
SANMVideoContext::buf_size
long buf_size
Definition: sanm.c:288
codec48_block
static int codec48_block(GetByteContext *gb, uint8_t *dst, uint8_t *db, int x, int y, const uint16_t w, const int aligned_height, const uint8_t *itbl)
Definition: sanm.c:1667
blt_ipol
static void blt_ipol(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int16_t left, int16_t top, uint16_t srcxoff, uint16_t srcyoff, uint16_t srcwidth, uint16_t srcheight, const uint16_t srcpitch, const uint16_t dstpitch, const uint16_t dstheight, int32_t size, const uint8_t *itbl)
Definition: sanm.c:1138
av_fast_padded_mallocz
void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_padded_malloc except that buffer will always be 0-initialized after call.
Definition: utils.c:66
which_direction
static enum GlyphDir which_direction(enum GlyphEdge edge0, enum GlyphEdge edge1)
Definition: sanm.c:343
SANMVideoContext::c4tbl
uint8_t c4tbl[2][256][16]
Definition: sanm.c:297
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
codec4_load_tiles
static int codec4_load_tiles(SANMVideoContext *ctx, GetByteContext *gb, uint16_t param2, uint8_t clr)
Definition: sanm.c:599
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
SANMVideoContext::c45tbl1
uint8_t c45tbl1[0x300]
Definition: sanm.c:300
RIGHT_EDGE
@ RIGHT_EDGE
Definition: sanm.c:307
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
SANMVideoContext::p8x8glyphs
int8_t p8x8glyphs[NGLYPHS][64]
Definition: sanm.c:294
mem.h
bytestream2_get_bufferu
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:277
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
opcode_0xf7
static int opcode_0xf7(SANMVideoContext *ctx, int cx, int cy, int block_size, ptrdiff_t pitch)
Definition: sanm.c:2374
w
uint8_t w
Definition: llvidencdsp.c:39
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:565
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:466
codec33_gen_tiles
static void codec33_gen_tiles(SANMVideoContext *ctx, int8_t param1)
Definition: sanm.c:486
old_codec48
static int old_codec48(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int width, int height)
Definition: sanm.c:1846
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:557
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:600
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
old_codec45
static void old_codec45(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int flag)
Definition: sanm.c:1957
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
DIR_UP
@ DIR_UP
Definition: sanm.c:314
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
process_ftch
static int process_ftch(SANMVideoContext *ctx, int size)
Definition: sanm.c:2163
h
h
Definition: vp9dsp_template.c:2070
old_codec1
static int old_codec1(SANMVideoContext *ctx, GetByteContext *gb, int top, int left, int width, int height, int opaque)
Definition: sanm.c:883
SANMVideoContext::delta_pal
int16_t delta_pal[PALETTE_DELTA]
Definition: sanm.c:271
stride
#define stride
Definition: h264pred_template.c:536
NO_DIR
@ NO_DIR
Definition: sanm.c:317
pkt
static AVPacket * pkt
Definition: demux_decode.c:55
width
#define width
Definition: dsp.h:89
av_bswap16
#define av_bswap16
Definition: bswap.h:28
SANMVideoContext::pitch
ptrdiff_t pitch
Definition: sanm.c:273
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:383
src
#define src
Definition: vp8dsp.c:248
SANMVideoContext::frm0_size
uint32_t frm0_size
Definition: sanm.c:281
SANMVideoContext::prev_seq
int prev_seq
Definition: sanm.c:276
SANMVideoContext::height
int height
Definition: sanm.c:274
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *pkt)
Definition: sanm.c:2898
init_buffers
static av_cold int init_buffers(SANMVideoContext *ctx)
Definition: sanm.c:465
Generated on Sat Aug 15 2026 03:21:10 for FFmpeg by   doxygen 1.8.17