FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/sheervideo.c
Date: 2024-11-20 23:03:26
Exec Total Coverage
Lines: 0 1310 0.0%
Functions: 0 28 0.0%
Branches: 0 370 0.0%
Line Branch Exec Source
1 /*
2 * BitJazz SheerVideo decoder
3 * Copyright (c) 2016 Paul B Mahol
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #define CACHED_BITSTREAM_READER !ARCH_X86_32
23 #define SHEER_VLC_BITS 12
24
25 #include "libavutil/intreadwrite.h"
26 #include "avcodec.h"
27 #include "codec_internal.h"
28 #include "get_bits.h"
29 #include "thread.h"
30 #include "sheervideodata.h"
31
32 typedef struct SheerVideoContext {
33 unsigned format;
34 int alt;
35 VLC vlc[2];
36 void (*decode_frame)(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb);
37 } SheerVideoContext;
38
39 ✗ static void decode_ca4i(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
40 {
41 ✗ SheerVideoContext *s = avctx->priv_data;
42 uint16_t *dst_y, *dst_u, *dst_v, *dst_a;
43 int x, y;
44
45 ✗ dst_a = (uint16_t *)p->data[3];
46 ✗ dst_y = (uint16_t *)p->data[0];
47 ✗ dst_u = (uint16_t *)p->data[1];
48 ✗ dst_v = (uint16_t *)p->data[2];
49
50 ✗ for (y = 0; y < avctx->height; y++) {
51 ✗ if (get_bits1(gb)) {
52 ✗ for (x = 0; x < avctx->width; x++) {
53 ✗ dst_a[x] = get_bits(gb, 10);
54 ✗ dst_y[x] = get_bits(gb, 10);
55 ✗ dst_u[x] = get_bits(gb, 10);
56 ✗ dst_v[x] = get_bits(gb, 10);
57 }
58 } else {
59 ✗ int pred[4] = { 502, 512, 512, 502 };
60
61 ✗ for (x = 0; x < avctx->width; x++) {
62 int y, u, v, a;
63
64 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
65 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
66 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
67 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
68
69 ✗ dst_a[x] = pred[3] = (a + pred[3]) & 0x3ff;
70 ✗ dst_y[x] = pred[0] = (y + pred[0]) & 0x3ff;
71 ✗ dst_u[x] = pred[1] = (u + pred[1]) & 0x3ff;
72 ✗ dst_v[x] = pred[2] = (v + pred[2]) & 0x3ff;
73 }
74 }
75
76 ✗ dst_y += p->linesize[0] / 2;
77 ✗ dst_u += p->linesize[1] / 2;
78 ✗ dst_v += p->linesize[2] / 2;
79 ✗ dst_a += p->linesize[3] / 2;
80 }
81 ✗ }
82
83 ✗ static void decode_ca4p(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
84 {
85 ✗ SheerVideoContext *s = avctx->priv_data;
86 uint16_t *dst_y, *dst_u, *dst_v, *dst_a;
87 int x, y;
88
89 ✗ dst_a = (uint16_t *)p->data[3];
90 ✗ dst_y = (uint16_t *)p->data[0];
91 ✗ dst_u = (uint16_t *)p->data[1];
92 ✗ dst_v = (uint16_t *)p->data[2];
93
94 ✗ if (get_bits1(gb)) {
95 ✗ for (x = 0; x < avctx->width; x++) {
96 ✗ dst_a[x] = get_bits(gb, 10);
97 ✗ dst_y[x] = get_bits(gb, 10);
98 ✗ dst_u[x] = get_bits(gb, 10);
99 ✗ dst_v[x] = get_bits(gb, 10);
100 }
101 } else {
102 ✗ int pred[4] = { 502, 512, 512, 502 };
103
104 ✗ for (x = 0; x < avctx->width; x++) {
105 int y, u, v, a;
106
107 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
108 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
109 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
110 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
111
112 ✗ dst_a[x] = pred[3] = (a + pred[3]) & 0x3ff;
113 ✗ dst_y[x] = pred[0] = (y + pred[0]) & 0x3ff;
114 ✗ dst_u[x] = pred[1] = (u + pred[1]) & 0x3ff;
115 ✗ dst_v[x] = pred[2] = (v + pred[2]) & 0x3ff;
116 }
117 }
118
119 ✗ dst_y += p->linesize[0] / 2;
120 ✗ dst_u += p->linesize[1] / 2;
121 ✗ dst_v += p->linesize[2] / 2;
122 ✗ dst_a += p->linesize[3] / 2;
123
124 ✗ for (y = 1; y < avctx->height; y++) {
125 ✗ if (get_bits1(gb)) {
126 ✗ for (x = 0; x < avctx->width; x++) {
127 ✗ dst_a[x] = get_bits(gb, 10);
128 ✗ dst_y[x] = get_bits(gb, 10);
129 ✗ dst_u[x] = get_bits(gb, 10);
130 ✗ dst_v[x] = get_bits(gb, 10);
131 }
132 } else {
133 int pred_TL[4], pred_L[4], pred_T[4];
134 int y, u, v, a;
135
136 ✗ pred_TL[0] = pred_L[0] = dst_y[-p->linesize[0] / 2];
137 ✗ pred_TL[1] = pred_L[1] = dst_u[-p->linesize[1] / 2];
138 ✗ pred_TL[2] = pred_L[2] = dst_v[-p->linesize[2] / 2];
139 ✗ pred_TL[3] = pred_L[3] = dst_a[-p->linesize[3] / 2];
140
141 ✗ for (x = 0; x < avctx->width; x++) {
142 ✗ pred_T[0] = dst_y[-p->linesize[0] / 2 + x];
143 ✗ pred_T[1] = dst_u[-p->linesize[1] / 2 + x];
144 ✗ pred_T[2] = dst_v[-p->linesize[2] / 2 + x];
145 ✗ pred_T[3] = dst_a[-p->linesize[3] / 2 + x];
146
147 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
148 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
149 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
150 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
151
152 ✗ dst_a[x] = pred_L[3] = (a + ((3 * (pred_T[3] + pred_L[3]) - 2 * pred_TL[3]) >> 2)) & 0x3ff;
153 ✗ dst_y[x] = pred_L[0] = (y + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0x3ff;
154 ✗ dst_u[x] = pred_L[1] = (u + ((3 * (pred_T[1] + pred_L[1]) - 2 * pred_TL[1]) >> 2)) & 0x3ff;
155 ✗ dst_v[x] = pred_L[2] = (v + ((3 * (pred_T[2] + pred_L[2]) - 2 * pred_TL[2]) >> 2)) & 0x3ff;
156
157 ✗ pred_TL[0] = pred_T[0];
158 ✗ pred_TL[1] = pred_T[1];
159 ✗ pred_TL[2] = pred_T[2];
160 ✗ pred_TL[3] = pred_T[3];
161 }
162 }
163
164 ✗ dst_y += p->linesize[0] / 2;
165 ✗ dst_u += p->linesize[1] / 2;
166 ✗ dst_v += p->linesize[2] / 2;
167 ✗ dst_a += p->linesize[3] / 2;
168 }
169 ✗ }
170
171 ✗ static void decode_ybr10i(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
172 {
173 ✗ SheerVideoContext *s = avctx->priv_data;
174 uint16_t *dst_y, *dst_u, *dst_v;
175 int x, y;
176
177 ✗ dst_y = (uint16_t *)p->data[0];
178 ✗ dst_u = (uint16_t *)p->data[1];
179 ✗ dst_v = (uint16_t *)p->data[2];
180
181 ✗ for (y = 0; y < avctx->height; y++) {
182 ✗ if (get_bits1(gb)) {
183 ✗ for (x = 0; x < avctx->width; x++) {
184 ✗ dst_y[x] = get_bits(gb, 10);
185 ✗ dst_u[x] = get_bits(gb, 10);
186 ✗ dst_v[x] = get_bits(gb, 10);
187 }
188 } else {
189 ✗ int pred[4] = { 502, 512, 512, 512 };
190
191 ✗ for (x = 0; x < avctx->width; x++) {
192 int y, u, v;
193
194 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
195 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
196 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
197
198 ✗ dst_y[x] = pred[0] = (y + pred[0]) & 0x3ff;
199 ✗ dst_u[x] = pred[1] = (u + pred[1]) & 0x3ff;
200 ✗ dst_v[x] = pred[2] = (v + pred[2]) & 0x3ff;
201 }
202 }
203
204 ✗ dst_y += p->linesize[0] / 2;
205 ✗ dst_u += p->linesize[1] / 2;
206 ✗ dst_v += p->linesize[2] / 2;
207 }
208 ✗ }
209
210 ✗ static void decode_ybr10(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
211 {
212 ✗ SheerVideoContext *s = avctx->priv_data;
213 uint16_t *dst_y, *dst_u, *dst_v;
214 int x, y;
215
216 ✗ dst_y = (uint16_t *)p->data[0];
217 ✗ dst_u = (uint16_t *)p->data[1];
218 ✗ dst_v = (uint16_t *)p->data[2];
219
220 ✗ if (get_bits1(gb)) {
221 ✗ for (x = 0; x < avctx->width; x++) {
222 ✗ dst_y[x] = get_bits(gb, 10);
223 ✗ dst_u[x] = get_bits(gb, 10);
224 ✗ dst_v[x] = get_bits(gb, 10);
225 }
226 } else {
227 ✗ int pred[4] = { 502, 512, 512, 512 };
228
229 ✗ for (x = 0; x < avctx->width; x++) {
230 int y, u, v;
231
232 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
233 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
234 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
235
236 ✗ dst_y[x] = pred[0] = (y + pred[0]) & 0x3ff;
237 ✗ dst_u[x] = pred[1] = (u + pred[1]) & 0x3ff;
238 ✗ dst_v[x] = pred[2] = (v + pred[2]) & 0x3ff;
239 }
240 }
241
242 ✗ dst_y += p->linesize[0] / 2;
243 ✗ dst_u += p->linesize[1] / 2;
244 ✗ dst_v += p->linesize[2] / 2;
245
246 ✗ for (y = 1; y < avctx->height; y++) {
247 ✗ if (get_bits1(gb)) {
248 ✗ for (x = 0; x < avctx->width; x++) {
249 ✗ dst_y[x] = get_bits(gb, 10);
250 ✗ dst_u[x] = get_bits(gb, 10);
251 ✗ dst_v[x] = get_bits(gb, 10);
252 }
253 } else {
254 int pred_TL[4], pred_L[4], pred_T[4];
255 int y, u, v;
256
257 ✗ pred_TL[0] = pred_L[0] = dst_y[-p->linesize[0] / 2];
258 ✗ pred_TL[1] = pred_L[1] = dst_u[-p->linesize[1] / 2];
259 ✗ pred_TL[2] = pred_L[2] = dst_v[-p->linesize[2] / 2];
260
261 ✗ for (x = 0; x < avctx->width; x++) {
262 ✗ pred_T[0] = dst_y[-p->linesize[0] / 2 + x];
263 ✗ pred_T[1] = dst_u[-p->linesize[1] / 2 + x];
264 ✗ pred_T[2] = dst_v[-p->linesize[2] / 2 + x];
265
266 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
267 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
268 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
269
270 ✗ dst_y[x] = pred_L[0] = (y + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0x3ff;
271 ✗ dst_u[x] = pred_L[1] = (u + ((3 * (pred_T[1] + pred_L[1]) - 2 * pred_TL[1]) >> 2)) & 0x3ff;
272 ✗ dst_v[x] = pred_L[2] = (v + ((3 * (pred_T[2] + pred_L[2]) - 2 * pred_TL[2]) >> 2)) & 0x3ff;
273
274 ✗ pred_TL[0] = pred_T[0];
275 ✗ pred_TL[1] = pred_T[1];
276 ✗ pred_TL[2] = pred_T[2];
277 }
278 }
279
280 ✗ dst_y += p->linesize[0] / 2;
281 ✗ dst_u += p->linesize[1] / 2;
282 ✗ dst_v += p->linesize[2] / 2;
283 }
284 ✗ }
285
286 ✗ static void decode_yry10i(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
287 {
288 ✗ SheerVideoContext *s = avctx->priv_data;
289 uint16_t *dst_y, *dst_u, *dst_v;
290 int x, y;
291
292 ✗ dst_y = (uint16_t *)p->data[0];
293 ✗ dst_u = (uint16_t *)p->data[1];
294 ✗ dst_v = (uint16_t *)p->data[2];
295
296 ✗ for (y = 0; y < avctx->height; y++) {
297 ✗ if (get_bits1(gb)) {
298 ✗ for (x = 0; x < avctx->width; x += 2) {
299 ✗ dst_y[x ] = get_bits(gb, 10);
300 ✗ dst_u[x / 2] = get_bits(gb, 10);
301 ✗ dst_y[x + 1] = get_bits(gb, 10);
302 ✗ dst_v[x / 2] = get_bits(gb, 10);
303 }
304 } else {
305 ✗ int pred[4] = { 502, 512, 512, 0 };
306
307 ✗ for (x = 0; x < avctx->width; x += 2) {
308 int y1, y2, u, v;
309
310 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
311 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
312 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
313 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
314
315 ✗ dst_y[x ] = pred[0] = (y1 + pred[0]) & 0x3ff;
316 ✗ dst_u[x / 2] = pred[1] = (u + pred[1]) & 0x3ff;
317 ✗ dst_y[x + 1] = pred[0] = (y2 + pred[0]) & 0x3ff;
318 ✗ dst_v[x / 2] = pred[2] = (v + pred[2]) & 0x3ff;
319 }
320 }
321
322 ✗ dst_y += p->linesize[0] / 2;
323 ✗ dst_u += p->linesize[1] / 2;
324 ✗ dst_v += p->linesize[2] / 2;
325 }
326 ✗ }
327
328 ✗ static void decode_yry10(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
329 {
330 ✗ SheerVideoContext *s = avctx->priv_data;
331 uint16_t *dst_y, *dst_u, *dst_v;
332 int x, y;
333
334 ✗ dst_y = (uint16_t *)p->data[0];
335 ✗ dst_u = (uint16_t *)p->data[1];
336 ✗ dst_v = (uint16_t *)p->data[2];
337
338 ✗ if (get_bits1(gb)) {
339 ✗ for (x = 0; x < avctx->width; x += 2) {
340 ✗ dst_y[x ] = get_bits(gb, 10);
341 ✗ dst_u[x / 2] = get_bits(gb, 10);
342 ✗ dst_y[x + 1] = get_bits(gb, 10);
343 ✗ dst_v[x / 2] = get_bits(gb, 10);
344 }
345 } else {
346 ✗ int pred[4] = { 502, 512, 512, 0 };
347
348 ✗ for (x = 0; x < avctx->width; x += 2) {
349 int y1, y2, u, v;
350
351 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
352 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
353 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
354 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
355
356 ✗ dst_y[x ] = pred[0] = (y1 + pred[0]) & 0x3ff;
357 ✗ dst_u[x / 2] = pred[1] = (u + pred[1]) & 0x3ff;
358 ✗ dst_y[x + 1] = pred[0] = (y2 + pred[0]) & 0x3ff;
359 ✗ dst_v[x / 2] = pred[2] = (v + pred[2]) & 0x3ff;
360 }
361 }
362
363 ✗ dst_y += p->linesize[0] / 2;
364 ✗ dst_u += p->linesize[1] / 2;
365 ✗ dst_v += p->linesize[2] / 2;
366
367 ✗ for (y = 1; y < avctx->height; y++) {
368 ✗ if (get_bits1(gb)) {
369 ✗ for (x = 0; x < avctx->width; x += 2) {
370 ✗ dst_y[x ] = get_bits(gb, 10);
371 ✗ dst_u[x / 2] = get_bits(gb, 10);
372 ✗ dst_y[x + 1] = get_bits(gb, 10);
373 ✗ dst_v[x / 2] = get_bits(gb, 10);
374 }
375 } else {
376 int pred_TL[6], pred_L[6], pred_T[6];
377 int y1, y2, u, v;
378
379 ✗ pred_TL[0] = pred_L[0] = dst_y[-p->linesize[0] / 2];
380 ✗ pred_TL[1] = pred_L[1] = dst_u[-p->linesize[1] / 2];
381 ✗ pred_TL[2] = pred_L[2] = dst_v[-p->linesize[2] / 2];
382
383 ✗ for (x = 0; x < avctx->width; x += 2) {
384 ✗ pred_T[0] = dst_y[-p->linesize[0] / 2 + x];
385 ✗ pred_T[3] = dst_y[-p->linesize[0] / 2 + x + 1];
386 ✗ pred_T[1] = dst_u[-p->linesize[1] / 2 + x / 2];
387 ✗ pred_T[2] = dst_v[-p->linesize[2] / 2 + x / 2];
388
389 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
390 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
391 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
392 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
393
394 ✗ dst_y[x ] = pred_L[0] = (y1 + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0x3ff;
395 ✗ dst_u[x / 2] = pred_L[1] = (u + (((pred_L[1] - pred_TL[1]) >> 1) + pred_T[1])) & 0x3ff;
396 ✗ dst_y[x + 1] = pred_L[0] = (y2 + ((3 * (pred_T[3] + pred_L[0]) - 2 * pred_T[0]) >> 2)) & 0x3ff;
397 ✗ dst_v[x / 2] = pred_L[2] = (v + (((pred_L[2] - pred_TL[2]) >> 1) + pred_T[2])) & 0x3ff;
398
399 ✗ pred_TL[0] = pred_T[3];
400 ✗ pred_TL[1] = pred_T[1];
401 ✗ pred_TL[2] = pred_T[2];
402 }
403 }
404
405 ✗ dst_y += p->linesize[0] / 2;
406 ✗ dst_u += p->linesize[1] / 2;
407 ✗ dst_v += p->linesize[2] / 2;
408 }
409 ✗ }
410
411 ✗ static void decode_ca2i(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
412 {
413 ✗ SheerVideoContext *s = avctx->priv_data;
414 uint16_t *dst_y, *dst_u, *dst_v, *dst_a;
415 int x, y;
416
417 ✗ dst_y = (uint16_t *)p->data[0];
418 ✗ dst_u = (uint16_t *)p->data[1];
419 ✗ dst_v = (uint16_t *)p->data[2];
420 ✗ dst_a = (uint16_t *)p->data[3];
421
422 ✗ for (y = 0; y < avctx->height; y++) {
423 ✗ if (get_bits1(gb)) {
424 ✗ for (x = 0; x < avctx->width; x += 2) {
425 ✗ dst_a[x ] = get_bits(gb, 10);
426 ✗ dst_y[x ] = get_bits(gb, 10);
427 ✗ dst_u[x / 2] = get_bits(gb, 10);
428 ✗ dst_a[x + 1] = get_bits(gb, 10);
429 ✗ dst_y[x + 1] = get_bits(gb, 10);
430 ✗ dst_v[x / 2] = get_bits(gb, 10);
431 }
432 } else {
433 ✗ int pred[4] = { 502, 512, 512, 502 };
434
435 ✗ for (x = 0; x < avctx->width; x += 2) {
436 int y1, y2, u, v, a1, a2;
437
438 ✗ a1 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
439 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
440 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
441 ✗ a2 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
442 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
443 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
444
445 ✗ dst_y[x ] = pred[0] = (y1 + pred[0]) & 0x3ff;
446 ✗ dst_u[x / 2] = pred[1] = (u + pred[1]) & 0x3ff;
447 ✗ dst_y[x + 1] = pred[0] = (y2 + pred[0]) & 0x3ff;
448 ✗ dst_a[x ] = pred[3] = (a1 + pred[3]) & 0x3ff;
449 ✗ dst_v[x / 2] = pred[2] = (v + pred[2]) & 0x3ff;
450 ✗ dst_a[x + 1] = pred[3] = (a2 + pred[3]) & 0x3ff;
451 }
452 }
453
454 ✗ dst_y += p->linesize[0] / 2;
455 ✗ dst_u += p->linesize[1] / 2;
456 ✗ dst_v += p->linesize[2] / 2;
457 ✗ dst_a += p->linesize[3] / 2;
458 }
459 ✗ }
460
461 ✗ static void decode_ca2p(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
462 {
463 ✗ SheerVideoContext *s = avctx->priv_data;
464 uint16_t *dst_y, *dst_u, *dst_v, *dst_a;
465 int x, y;
466
467 ✗ dst_y = (uint16_t *)p->data[0];
468 ✗ dst_u = (uint16_t *)p->data[1];
469 ✗ dst_v = (uint16_t *)p->data[2];
470 ✗ dst_a = (uint16_t *)p->data[3];
471
472 ✗ if (get_bits1(gb)) {
473 ✗ for (x = 0; x < avctx->width; x += 2) {
474 ✗ dst_a[x ] = get_bits(gb, 10);
475 ✗ dst_y[x ] = get_bits(gb, 10);
476 ✗ dst_u[x / 2] = get_bits(gb, 10);
477 ✗ dst_a[x + 1] = get_bits(gb, 10);
478 ✗ dst_y[x + 1] = get_bits(gb, 10);
479 ✗ dst_v[x / 2] = get_bits(gb, 10);
480 }
481 } else {
482 ✗ int pred[4] = { 502, 512, 512, 502 };
483
484 ✗ for (x = 0; x < avctx->width; x += 2) {
485 int y1, y2, u, v, a1, a2;
486
487 ✗ a1 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
488 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
489 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
490 ✗ a2 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
491 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
492 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
493
494 ✗ dst_y[x ] = pred[0] = (y1 + pred[0]) & 0x3ff;
495 ✗ dst_u[x / 2] = pred[1] = (u + pred[1]) & 0x3ff;
496 ✗ dst_y[x + 1] = pred[0] = (y2 + pred[0]) & 0x3ff;
497 ✗ dst_a[x ] = pred[3] = (a1 + pred[3]) & 0x3ff;
498 ✗ dst_v[x / 2] = pred[2] = (v + pred[2]) & 0x3ff;
499 ✗ dst_a[x + 1] = pred[3] = (a2 + pred[3]) & 0x3ff;
500 }
501 }
502
503 ✗ dst_y += p->linesize[0] / 2;
504 ✗ dst_u += p->linesize[1] / 2;
505 ✗ dst_v += p->linesize[2] / 2;
506 ✗ dst_a += p->linesize[3] / 2;
507
508 ✗ for (y = 1; y < avctx->height; y++) {
509 ✗ if (get_bits1(gb)) {
510 ✗ for (x = 0; x < avctx->width; x += 2) {
511 ✗ dst_a[x ] = get_bits(gb, 10);
512 ✗ dst_y[x ] = get_bits(gb, 10);
513 ✗ dst_u[x / 2] = get_bits(gb, 10);
514 ✗ dst_a[x + 1] = get_bits(gb, 10);
515 ✗ dst_y[x + 1] = get_bits(gb, 10);
516 ✗ dst_v[x / 2] = get_bits(gb, 10);
517 }
518 } else {
519 int pred_TL[6], pred_L[6], pred_T[6];
520 int y1, y2, u, v, a1, a2;
521
522 ✗ pred_TL[0] = pred_L[0] = dst_y[-p->linesize[0] / 2];
523 ✗ pred_TL[1] = pred_L[1] = dst_u[-p->linesize[1] / 2];
524 ✗ pred_TL[2] = pred_L[2] = dst_v[-p->linesize[2] / 2];
525 ✗ pred_TL[4] = pred_L[4] = dst_a[-p->linesize[3] / 2];
526
527 ✗ for (x = 0; x < avctx->width; x += 2) {
528 ✗ pred_T[0] = dst_y[-p->linesize[0] / 2 + x];
529 ✗ pred_T[3] = dst_y[-p->linesize[0] / 2 + x + 1];
530 ✗ pred_T[1] = dst_u[-p->linesize[1] / 2 + x / 2];
531 ✗ pred_T[2] = dst_v[-p->linesize[2] / 2 + x / 2];
532 ✗ pred_T[4] = dst_a[-p->linesize[3] / 2 + x];
533 ✗ pred_T[5] = dst_a[-p->linesize[3] / 2 + x + 1];
534
535 ✗ a1 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
536 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
537 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
538 ✗ a2 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
539 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
540 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
541
542 ✗ dst_y[x ] = pred_L[0] = (y1 + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0x3ff;
543 ✗ dst_u[x / 2] = pred_L[1] = (u + (((pred_L[1] - pred_TL[1]) >> 1) + pred_T[1])) & 0x3ff;
544 ✗ dst_y[x + 1] = pred_L[0] = (y2 + ((3 * (pred_T[3] + pred_L[0]) - 2 * pred_T[0]) >> 2)) & 0x3ff;
545 ✗ dst_v[x / 2] = pred_L[2] = (v + (((pred_L[2] - pred_TL[2]) >> 1) + pred_T[2])) & 0x3ff;
546 ✗ dst_a[x ] = pred_L[4] = (a1 + ((3 * (pred_T[4] + pred_L[4]) - 2 * pred_TL[4]) >> 2)) & 0x3ff;
547 ✗ dst_a[x + 1] = pred_L[4] = (a2 + ((3 * (pred_T[5] + pred_L[4]) - 2 * pred_T[4]) >> 2)) & 0x3ff;
548
549 ✗ pred_TL[0] = pred_T[3];
550 ✗ pred_TL[1] = pred_T[1];
551 ✗ pred_TL[2] = pred_T[2];
552 ✗ pred_TL[4] = pred_T[5];
553 }
554 }
555
556 ✗ dst_y += p->linesize[0] / 2;
557 ✗ dst_u += p->linesize[1] / 2;
558 ✗ dst_v += p->linesize[2] / 2;
559 ✗ dst_a += p->linesize[3] / 2;
560 }
561 ✗ }
562
563 ✗ static void decode_c82i(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
564 {
565 ✗ SheerVideoContext *s = avctx->priv_data;
566 uint8_t *dst_y, *dst_u, *dst_v, *dst_a;
567 int x, y;
568
569 ✗ dst_y = p->data[0];
570 ✗ dst_u = p->data[1];
571 ✗ dst_v = p->data[2];
572 ✗ dst_a = p->data[3];
573
574 ✗ for (y = 0; y < avctx->height; y += 1) {
575 ✗ if (get_bits1(gb)) {
576 ✗ for (x = 0; x < avctx->width; x += 2) {
577 ✗ dst_a[x ] = get_bits(gb, 8);
578 ✗ dst_y[x ] = get_bits(gb, 8);
579 ✗ dst_u[x / 2] = get_bits(gb, 8);
580 ✗ dst_a[x + 1] = get_bits(gb, 8);
581 ✗ dst_y[x + 1] = get_bits(gb, 8);
582 ✗ dst_v[x / 2] = get_bits(gb, 8);
583 }
584 } else {
585 ✗ int pred[4] = { 125, -128, -128, 125 };
586
587 ✗ for (x = 0; x < avctx->width; x += 2) {
588 int y1, y2, u, v, a1, a2;
589
590 ✗ a1 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
591 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
592 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
593 ✗ a2 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
594 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
595 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
596
597 ✗ dst_y[x ] = pred[0] = (y1 + pred[0]) & 0xff;
598 ✗ dst_y[x + 1] = pred[0] = (y2 + pred[0]) & 0xff;
599 ✗ dst_u[x / 2] = pred[1] = (u + pred[1]) & 0xff;
600 ✗ dst_v[x / 2] = pred[2] = (v + pred[2]) & 0xff;
601 ✗ dst_a[x ] = pred[3] = (a1 + pred[3]) & 0xff;
602 ✗ dst_a[x + 1] = pred[3] = (a2 + pred[3]) & 0xff;
603 }
604 }
605
606 ✗ dst_y += p->linesize[0];
607 ✗ dst_u += p->linesize[1];
608 ✗ dst_v += p->linesize[2];
609 ✗ dst_a += p->linesize[3];
610 }
611 ✗ }
612
613 ✗ static void decode_c82p(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
614 {
615 ✗ SheerVideoContext *s = avctx->priv_data;
616 uint8_t *dst_y, *dst_u, *dst_v, *dst_a;
617 int x, y;
618
619 ✗ dst_y = p->data[0];
620 ✗ dst_u = p->data[1];
621 ✗ dst_v = p->data[2];
622 ✗ dst_a = p->data[3];
623
624 ✗ if (get_bits1(gb)) {
625 ✗ for (x = 0; x < avctx->width; x += 2) {
626 ✗ dst_a[x ] = get_bits(gb, 8);
627 ✗ dst_y[x ] = get_bits(gb, 8);
628 ✗ dst_u[x / 2] = get_bits(gb, 8);
629 ✗ dst_a[x + 1] = get_bits(gb, 8);
630 ✗ dst_y[x + 1] = get_bits(gb, 8);
631 ✗ dst_v[x / 2] = get_bits(gb, 8);
632 }
633 } else {
634 ✗ int pred[4] = { 125, -128, -128, 125 };
635
636 ✗ for (x = 0; x < avctx->width; x += 2) {
637 int y1, y2, u, v, a1, a2;
638
639 ✗ a1 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
640 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
641 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
642 ✗ a2 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
643 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
644 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
645
646 ✗ dst_y[x ] = pred[0] = (y1 + pred[0]) & 0xff;
647 ✗ dst_u[x / 2] = pred[1] = (u + pred[1]) & 0xff;
648 ✗ dst_y[x + 1] = pred[0] = (y2 + pred[0]) & 0xff;
649 ✗ dst_a[x ] = pred[3] = (a1 + pred[3]) & 0xff;
650 ✗ dst_v[x / 2] = pred[2] = (v + pred[2]) & 0xff;
651 ✗ dst_a[x + 1] = pred[3] = (a2 + pred[3]) & 0xff;
652 }
653 }
654
655 ✗ dst_y += p->linesize[0];
656 ✗ dst_u += p->linesize[1];
657 ✗ dst_v += p->linesize[2];
658 ✗ dst_a += p->linesize[3];
659
660 ✗ for (y = 1; y < avctx->height; y++) {
661 ✗ if (get_bits1(gb)) {
662 ✗ for (x = 0; x < avctx->width; x += 2) {
663 ✗ dst_a[x ] = get_bits(gb, 8);
664 ✗ dst_y[x ] = get_bits(gb, 8);
665 ✗ dst_u[x / 2] = get_bits(gb, 8);
666 ✗ dst_a[x + 1] = get_bits(gb, 8);
667 ✗ dst_y[x + 1] = get_bits(gb, 8);
668 ✗ dst_v[x / 2] = get_bits(gb, 8);
669 }
670 } else {
671 int pred_TL[6], pred_L[6], pred_T[6];
672 int y1, y2, u, v, a1, a2;
673
674 ✗ pred_TL[0] = pred_L[0] = dst_y[-p->linesize[0]];
675 ✗ pred_TL[1] = pred_L[1] = dst_u[-p->linesize[1]];
676 ✗ pred_TL[2] = pred_L[2] = dst_v[-p->linesize[2]];
677 ✗ pred_TL[4] = pred_L[4] = dst_a[-p->linesize[3]];
678
679 ✗ for (x = 0; x < avctx->width; x += 2) {
680 ✗ pred_T[0] = dst_y[-p->linesize[0] + x];
681 ✗ pred_T[3] = dst_y[-p->linesize[0] + x + 1];
682 ✗ pred_T[1] = dst_u[-p->linesize[1] + x / 2];
683 ✗ pred_T[2] = dst_v[-p->linesize[2] + x / 2];
684 ✗ pred_T[4] = dst_a[-p->linesize[3] + x];
685 ✗ pred_T[5] = dst_a[-p->linesize[3] + x + 1];
686
687 ✗ a1 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
688 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
689 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
690 ✗ a2 = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
691 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
692 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
693
694 ✗ dst_y[x ] = pred_L[0] = (y1 + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0xff;
695 ✗ dst_u[x / 2] = pred_L[1] = (u + (((pred_L[1] - pred_TL[1]) >> 1) + pred_T[1])) & 0xff;
696 ✗ dst_y[x + 1] = pred_L[0] = (y2 + ((3 * (pred_T[3] + pred_L[0]) - 2 * pred_T[0]) >> 2)) & 0xff;
697 ✗ dst_v[x / 2] = pred_L[2] = (v + (((pred_L[2] - pred_TL[2]) >> 1) + pred_T[2])) & 0xff;
698 ✗ dst_a[x ] = pred_L[4] = (a1 + ((3 * (pred_T[4] + pred_L[4]) - 2 * pred_TL[4]) >> 2)) & 0xff;
699 ✗ dst_a[x + 1] = pred_L[4] = (a2 + ((3 * (pred_T[5] + pred_L[4]) - 2 * pred_T[4]) >> 2)) & 0xff;
700
701 ✗ pred_TL[0] = pred_T[3];
702 ✗ pred_TL[1] = pred_T[1];
703 ✗ pred_TL[2] = pred_T[2];
704 ✗ pred_TL[4] = pred_T[5];
705 }
706 }
707
708 ✗ dst_y += p->linesize[0];
709 ✗ dst_u += p->linesize[1];
710 ✗ dst_v += p->linesize[2];
711 ✗ dst_a += p->linesize[3];
712 }
713 ✗ }
714
715 ✗ static void decode_ybyr(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
716 {
717 ✗ SheerVideoContext *s = avctx->priv_data;
718 uint8_t *dst_y, *dst_u, *dst_v;
719 int x, y;
720
721 ✗ dst_y = p->data[0];
722 ✗ dst_u = p->data[1];
723 ✗ dst_v = p->data[2];
724
725 ✗ if (get_bits1(gb)) {
726 ✗ for (x = 0; x < avctx->width; x += 2) {
727 ✗ dst_y[x ] = get_bits(gb, 8);
728 ✗ dst_u[x / 2] = get_bits(gb, 8) + 128;
729 ✗ dst_y[x + 1] = get_bits(gb, 8);
730 ✗ dst_v[x / 2] = get_bits(gb, 8) + 128;
731 }
732 } else {
733 ✗ int pred[4] = { -128, 128, 128, 0 };
734
735 ✗ for (x = 0; x < avctx->width; x += 2) {
736 int y1, y2, u, v;
737
738 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
739 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
740 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
741 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
742
743 ✗ dst_y[x ] = pred[0] = (y1 + pred[0]) & 0xff;
744 ✗ dst_u[x / 2] = pred[1] = (u + pred[1]) & 0xff;
745 ✗ dst_y[x + 1] = pred[0] = (y2 + pred[0]) & 0xff;
746 ✗ dst_v[x / 2] = pred[2] = (v + pred[2]) & 0xff;
747 }
748 }
749
750 ✗ dst_y += p->linesize[0];
751 ✗ dst_u += p->linesize[1];
752 ✗ dst_v += p->linesize[2];
753
754 ✗ for (y = 1; y < avctx->height; y++) {
755 ✗ if (get_bits1(gb)) {
756 ✗ for (x = 0; x < avctx->width; x += 2) {
757 ✗ dst_y[x ] = get_bits(gb, 8);
758 ✗ dst_u[x / 2] = get_bits(gb, 8) + 128;
759 ✗ dst_y[x + 1] = get_bits(gb, 8);
760 ✗ dst_v[x / 2] = get_bits(gb, 8) + 128;
761 }
762 } else {
763 int pred_TL[4], pred_L[4], pred_T[4];
764 int y1, y2, u, v;
765
766 ✗ pred_TL[0] = pred_L[0] = dst_y[-p->linesize[0]];
767 ✗ pred_TL[1] = pred_L[1] = dst_u[-p->linesize[1]];
768 ✗ pred_TL[2] = pred_L[2] = dst_v[-p->linesize[2]];
769
770 ✗ for (x = 0; x < avctx->width; x += 2) {
771 ✗ pred_T[0] = dst_y[-p->linesize[0] + x];
772 ✗ pred_T[3] = dst_y[-p->linesize[0] + x + 1];
773 ✗ pred_T[1] = dst_u[-p->linesize[1] + x / 2];
774 ✗ pred_T[2] = dst_v[-p->linesize[2] + x / 2];
775
776 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
777 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
778 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
779 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
780
781 ✗ dst_y[x ] = pred_L[0] = (y1 + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0xff;
782 ✗ dst_u[x / 2] = pred_L[1] = (u + (((pred_L[1] - pred_TL[1]) >> 1) + pred_T[1])) & 0xff;
783 ✗ dst_y[x + 1] = pred_L[0] = (y2 + ((3 * (pred_T[3] + pred_L[0]) - 2 * pred_T[0]) >> 2)) & 0xff;
784 ✗ dst_v[x / 2] = pred_L[2] = (v + (((pred_L[2] - pred_TL[2]) >> 1) + pred_T[2])) & 0xff;
785
786 ✗ pred_TL[0] = pred_T[3];
787 ✗ pred_TL[1] = pred_T[1];
788 ✗ pred_TL[2] = pred_T[2];
789 }
790 }
791
792 ✗ dst_y += p->linesize[0];
793 ✗ dst_u += p->linesize[1];
794 ✗ dst_v += p->linesize[2];
795 }
796 ✗ }
797
798 ✗ static void decode_byryi(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
799 {
800 ✗ SheerVideoContext *s = avctx->priv_data;
801 uint8_t *dst_y, *dst_u, *dst_v;
802 int x, y;
803
804 ✗ dst_y = p->data[0];
805 ✗ dst_u = p->data[1];
806 ✗ dst_v = p->data[2];
807
808 ✗ if (get_bits1(gb)) {
809 ✗ for (x = 0; x < avctx->width; x += 2) {
810 ✗ dst_y[x ] = get_bits(gb, 8);
811 ✗ dst_u[x / 2] = get_bits(gb, 8);
812 ✗ dst_y[x + 1] = get_bits(gb, 8);
813 ✗ dst_v[x / 2] = get_bits(gb, 8);
814 }
815 } else {
816 ✗ int pred[4] = { 125, -128, -128, 0 };
817
818 ✗ for (x = 0; x < avctx->width; x += 2) {
819 int y1, y2, u, v;
820
821 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
822 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
823 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
824 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
825
826 ✗ dst_y[x ] = pred[0] = (y1 + pred[0]) & 0xff;
827 ✗ dst_u[x / 2] = pred[1] = (u + pred[1]) & 0xff;
828 ✗ dst_y[x + 1] = pred[0] = (y2 + pred[0]) & 0xff;
829 ✗ dst_v[x / 2] = pred[2] = (v + pred[2]) & 0xff;
830 }
831 }
832
833 ✗ dst_y += p->linesize[0];
834 ✗ dst_u += p->linesize[1];
835 ✗ dst_v += p->linesize[2];
836
837 ✗ for (y = 1; y < avctx->height; y++) {
838 ✗ if (get_bits1(gb)) {
839 ✗ for (x = 0; x < avctx->width; x += 2) {
840 ✗ dst_y[x ] = get_bits(gb, 8);
841 ✗ dst_u[x / 2] = get_bits(gb, 8);
842 ✗ dst_y[x + 1] = get_bits(gb, 8);
843 ✗ dst_v[x / 2] = get_bits(gb, 8);
844 }
845 } else {
846 int pred_L[4];
847 int y1, y2, u, v;
848
849 ✗ pred_L[0] = dst_y[-p->linesize[0]];
850 ✗ pred_L[1] = dst_u[-p->linesize[1]];
851 ✗ pred_L[2] = dst_v[-p->linesize[2]];
852
853 ✗ for (x = 0; x < avctx->width; x += 2) {
854 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
855 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
856 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
857 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
858
859 ✗ dst_y[x ] = pred_L[0] = (y1 + pred_L[0]) & 0xff;
860 ✗ dst_u[x / 2] = pred_L[1] = (u + pred_L[1]) & 0xff;
861 ✗ dst_y[x + 1] = pred_L[0] = (y2 + pred_L[0]) & 0xff;
862 ✗ dst_v[x / 2] = pred_L[2] = (v + pred_L[2]) & 0xff;
863 }
864 }
865
866 ✗ dst_y += p->linesize[0];
867 ✗ dst_u += p->linesize[1];
868 ✗ dst_v += p->linesize[2];
869 }
870 ✗ }
871
872 ✗ static void decode_byry(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
873 {
874 ✗ SheerVideoContext *s = avctx->priv_data;
875 uint8_t *dst_y, *dst_u, *dst_v;
876 int x, y;
877
878 ✗ dst_y = p->data[0];
879 ✗ dst_u = p->data[1];
880 ✗ dst_v = p->data[2];
881
882 ✗ if (get_bits1(gb)) {
883 ✗ for (x = 0; x < avctx->width; x += 2) {
884 ✗ dst_y[x ] = get_bits(gb, 8);
885 ✗ dst_u[x / 2] = get_bits(gb, 8);
886 ✗ dst_y[x + 1] = get_bits(gb, 8);
887 ✗ dst_v[x / 2] = get_bits(gb, 8);
888 }
889 } else {
890 ✗ int pred[4] = { 125, -128, -128, 0 };
891
892 ✗ for (x = 0; x < avctx->width; x += 2) {
893 int y1, y2, u, v;
894
895 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
896 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
897 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
898 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
899
900 ✗ dst_y[x ] = pred[0] = (y1 + pred[0]) & 0xff;
901 ✗ dst_u[x / 2] = pred[1] = (u + pred[1]) & 0xff;
902 ✗ dst_y[x + 1] = pred[0] = (y2 + pred[0]) & 0xff;
903 ✗ dst_v[x / 2] = pred[2] = (v + pred[2]) & 0xff;
904 }
905 }
906
907 ✗ dst_y += p->linesize[0];
908 ✗ dst_u += p->linesize[1];
909 ✗ dst_v += p->linesize[2];
910
911 ✗ for (y = 1; y < avctx->height; y++) {
912 ✗ if (get_bits1(gb)) {
913 ✗ for (x = 0; x < avctx->width; x += 2) {
914 ✗ dst_y[x ] = get_bits(gb, 8);
915 ✗ dst_u[x / 2] = get_bits(gb, 8);
916 ✗ dst_y[x + 1] = get_bits(gb, 8);
917 ✗ dst_v[x / 2] = get_bits(gb, 8);
918 }
919 } else {
920 int pred_TL[4], pred_L[4], pred_T[4];
921 int y1, y2, u, v;
922
923 ✗ pred_TL[0] = pred_L[0] = dst_y[-p->linesize[0]];
924 ✗ pred_TL[1] = pred_L[1] = dst_u[-p->linesize[1]];
925 ✗ pred_TL[2] = pred_L[2] = dst_v[-p->linesize[2]];
926
927 ✗ for (x = 0; x < avctx->width; x += 2) {
928 ✗ pred_T[0] = dst_y[-p->linesize[0] + x];
929 ✗ pred_T[3] = dst_y[-p->linesize[0] + x + 1];
930 ✗ pred_T[1] = dst_u[-p->linesize[1] + x / 2];
931 ✗ pred_T[2] = dst_v[-p->linesize[2] + x / 2];
932
933 ✗ y1 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
934 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
935 ✗ y2 = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
936 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
937
938 ✗ dst_y[x ] = pred_L[0] = (y1 + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0xff;
939 ✗ dst_u[x / 2] = pred_L[1] = (u + (((pred_L[1] - pred_TL[1]) >> 1) + pred_T[1])) & 0xff;
940 ✗ dst_y[x + 1] = pred_L[0] = (y2 + ((3 * (pred_T[3] + pred_L[0]) - 2 * pred_T[0]) >> 2)) & 0xff;
941 ✗ dst_v[x / 2] = pred_L[2] = (v + (((pred_L[2] - pred_TL[2]) >> 1) + pred_T[2])) & 0xff;
942
943 ✗ pred_TL[0] = pred_T[3];
944 ✗ pred_TL[1] = pred_T[1];
945 ✗ pred_TL[2] = pred_T[2];
946 }
947 }
948
949 ✗ dst_y += p->linesize[0];
950 ✗ dst_u += p->linesize[1];
951 ✗ dst_v += p->linesize[2];
952 }
953 ✗ }
954
955 ✗ static void decode_ybri(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
956 {
957 ✗ SheerVideoContext *s = avctx->priv_data;
958 uint8_t *dst_y, *dst_u, *dst_v;
959 int x, y;
960
961 ✗ dst_y = p->data[0];
962 ✗ dst_u = p->data[1];
963 ✗ dst_v = p->data[2];
964
965 ✗ if (get_bits1(gb)) {
966 ✗ for (x = 0; x < avctx->width; x++) {
967 ✗ dst_y[x] = get_bits(gb, 8);
968 ✗ dst_u[x] = get_bits(gb, 8);
969 ✗ dst_v[x] = get_bits(gb, 8);
970 }
971 } else {
972 ✗ int pred[4] = { s->alt ? 125 : -146, -128, -128, -128 };
973
974 ✗ for (x = 0; x < avctx->width; x++) {
975 int y, u, v;
976
977 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
978 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
979 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
980
981 ✗ dst_y[x] = pred[0] = (y + pred[0]) & 0xff;
982 ✗ dst_u[x] = pred[1] = (u + pred[1]) & 0xff;
983 ✗ dst_v[x] = pred[2] = (v + pred[2]) & 0xff;
984 }
985 }
986
987 ✗ dst_y += p->linesize[0];
988 ✗ dst_u += p->linesize[1];
989 ✗ dst_v += p->linesize[2];
990
991 ✗ for (y = 1; y < avctx->height; y++) {
992 ✗ if (get_bits1(gb)) {
993 ✗ for (x = 0; x < avctx->width; x++) {
994 ✗ dst_y[x] = get_bits(gb, 8);
995 ✗ dst_u[x] = get_bits(gb, 8);
996 ✗ dst_v[x] = get_bits(gb, 8);
997 }
998 } else {
999 int pred_L[4];
1000 int y, u, v;
1001
1002 ✗ pred_L[0] = dst_y[-p->linesize[0]];
1003 ✗ pred_L[1] = dst_u[-p->linesize[1]];
1004 ✗ pred_L[2] = dst_v[-p->linesize[2]];
1005
1006 ✗ for (x = 0; x < avctx->width; x++) {
1007 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1008 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1009 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1010
1011 ✗ dst_y[x] = pred_L[0] = (y + pred_L[0]) & 0xff;
1012 ✗ dst_u[x] = pred_L[1] = (u + pred_L[1]) & 0xff;
1013 ✗ dst_v[x] = pred_L[2] = (v + pred_L[2]) & 0xff;
1014 }
1015 }
1016
1017 ✗ dst_y += p->linesize[0];
1018 ✗ dst_u += p->linesize[1];
1019 ✗ dst_v += p->linesize[2];
1020 }
1021 ✗ }
1022
1023 ✗ static void decode_ybr(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1024 {
1025 ✗ SheerVideoContext *s = avctx->priv_data;
1026 uint8_t *dst_y, *dst_u, *dst_v;
1027 int x, y;
1028
1029 ✗ dst_y = p->data[0];
1030 ✗ dst_u = p->data[1];
1031 ✗ dst_v = p->data[2];
1032
1033 ✗ if (get_bits1(gb)) {
1034 ✗ for (x = 0; x < avctx->width; x++) {
1035 ✗ dst_y[x] = get_bits(gb, 8);
1036 ✗ dst_u[x] = get_bits(gb, 8);
1037 ✗ dst_v[x] = get_bits(gb, 8);
1038 }
1039 } else {
1040 ✗ int pred[4] = { s->alt ? 125 : -146, -128, -128, -128 };
1041
1042 ✗ for (x = 0; x < avctx->width; x++) {
1043 int y, u, v;
1044
1045 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1046 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1047 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1048
1049 ✗ dst_y[x] = pred[0] = (y + pred[0]) & 0xff;
1050 ✗ dst_u[x] = pred[1] = (u + pred[1]) & 0xff;
1051 ✗ dst_v[x] = pred[2] = (v + pred[2]) & 0xff;
1052 }
1053 }
1054
1055 ✗ dst_y += p->linesize[0];
1056 ✗ dst_u += p->linesize[1];
1057 ✗ dst_v += p->linesize[2];
1058
1059 ✗ for (y = 1; y < avctx->height; y++) {
1060 ✗ if (get_bits1(gb)) {
1061 ✗ for (x = 0; x < avctx->width; x++) {
1062 ✗ dst_y[x] = get_bits(gb, 8);
1063 ✗ dst_u[x] = get_bits(gb, 8);
1064 ✗ dst_v[x] = get_bits(gb, 8);
1065 }
1066 } else {
1067 int pred_TL[4], pred_L[4], pred_T[4];
1068 int y, u, v;
1069
1070 ✗ pred_TL[0] = pred_L[0] = dst_y[-p->linesize[0]];
1071 ✗ pred_TL[1] = pred_L[1] = dst_u[-p->linesize[1]];
1072 ✗ pred_TL[2] = pred_L[2] = dst_v[-p->linesize[2]];
1073
1074 ✗ for (x = 0; x < avctx->width; x++) {
1075 ✗ pred_T[0] = dst_y[-p->linesize[0] + x];
1076 ✗ pred_T[1] = dst_u[-p->linesize[1] + x];
1077 ✗ pred_T[2] = dst_v[-p->linesize[2] + x];
1078
1079 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1080 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1081 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1082
1083 ✗ dst_y[x] = pred_L[0] = (y + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0xff;
1084 ✗ dst_u[x] = pred_L[1] = (u + ((3 * (pred_T[1] + pred_L[1]) - 2 * pred_TL[1]) >> 2)) & 0xff;
1085 ✗ dst_v[x] = pred_L[2] = (v + ((3 * (pred_T[2] + pred_L[2]) - 2 * pred_TL[2]) >> 2)) & 0xff;
1086
1087 ✗ pred_TL[0] = pred_T[0];
1088 ✗ pred_TL[1] = pred_T[1];
1089 ✗ pred_TL[2] = pred_T[2];
1090 }
1091 }
1092
1093 ✗ dst_y += p->linesize[0];
1094 ✗ dst_u += p->linesize[1];
1095 ✗ dst_v += p->linesize[2];
1096 }
1097 ✗ }
1098
1099 ✗ static void decode_aybri(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1100 {
1101 ✗ SheerVideoContext *s = avctx->priv_data;
1102 uint8_t *dst_a, *dst_y, *dst_u, *dst_v;
1103 int x, y;
1104
1105 ✗ dst_a = p->data[3];
1106 ✗ dst_y = p->data[0];
1107 ✗ dst_u = p->data[1];
1108 ✗ dst_v = p->data[2];
1109
1110 ✗ if (get_bits1(gb)) {
1111 ✗ for (x = 0; x < avctx->width; x++) {
1112 ✗ dst_a[x] = get_bits(gb, 8);
1113 ✗ dst_y[x] = get_bits(gb, 8);
1114 ✗ dst_u[x] = get_bits(gb, 8);
1115 ✗ dst_v[x] = get_bits(gb, 8);
1116 }
1117 } else {
1118 ✗ int pred[4] = { 125, s->alt ? 125 : -146, -128, -128 };
1119
1120 ✗ for (x = 0; x < avctx->width; x++) {
1121 int a, y, u, v;
1122
1123 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1124 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1125 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1126 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1127
1128 ✗ dst_a[x] = pred[0] = (a + pred[0]) & 0xff;
1129 ✗ dst_y[x] = pred[1] = (y + pred[1]) & 0xff;
1130 ✗ dst_u[x] = pred[2] = (u + pred[2]) & 0xff;
1131 ✗ dst_v[x] = pred[3] = (v + pred[3]) & 0xff;
1132 }
1133 }
1134
1135 ✗ dst_a += p->linesize[3];
1136 ✗ dst_y += p->linesize[0];
1137 ✗ dst_u += p->linesize[1];
1138 ✗ dst_v += p->linesize[2];
1139
1140 ✗ for (y = 1; y < avctx->height; y++) {
1141 ✗ if (get_bits1(gb)) {
1142 ✗ for (x = 0; x < avctx->width; x++) {
1143 ✗ dst_a[x] = get_bits(gb, 8);
1144 ✗ dst_y[x] = get_bits(gb, 8);
1145 ✗ dst_u[x] = get_bits(gb, 8);
1146 ✗ dst_v[x] = get_bits(gb, 8);
1147 }
1148 } else {
1149 int pred_L[4];
1150 int a, y, u, v;
1151
1152 ✗ pred_L[0] = dst_a[-p->linesize[3]];
1153 ✗ pred_L[1] = dst_y[-p->linesize[0]];
1154 ✗ pred_L[2] = dst_u[-p->linesize[1]];
1155 ✗ pred_L[3] = dst_v[-p->linesize[2]];
1156
1157 ✗ for (x = 0; x < avctx->width; x++) {
1158 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1159 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1160 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1161 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1162
1163 ✗ dst_a[x] = pred_L[0] = (a + pred_L[0]) & 0xff;
1164 ✗ dst_y[x] = pred_L[1] = (y + pred_L[1]) & 0xff;
1165 ✗ dst_u[x] = pred_L[2] = (u + pred_L[2]) & 0xff;
1166 ✗ dst_v[x] = pred_L[3] = (v + pred_L[3]) & 0xff;
1167 }
1168 }
1169
1170 ✗ dst_a += p->linesize[3];
1171 ✗ dst_y += p->linesize[0];
1172 ✗ dst_u += p->linesize[1];
1173 ✗ dst_v += p->linesize[2];
1174 }
1175 ✗ }
1176
1177 ✗ static void decode_aybr(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1178 {
1179 ✗ SheerVideoContext *s = avctx->priv_data;
1180 uint8_t *dst_a, *dst_y, *dst_u, *dst_v;
1181 int x, y;
1182
1183 ✗ dst_a = p->data[3];
1184 ✗ dst_y = p->data[0];
1185 ✗ dst_u = p->data[1];
1186 ✗ dst_v = p->data[2];
1187
1188 ✗ if (get_bits1(gb)) {
1189 ✗ for (x = 0; x < avctx->width; x++) {
1190 ✗ dst_a[x] = get_bits(gb, 8);
1191 ✗ dst_y[x] = get_bits(gb, 8);
1192 ✗ dst_u[x] = get_bits(gb, 8);
1193 ✗ dst_v[x] = get_bits(gb, 8);
1194 }
1195 } else {
1196 ✗ int pred[4] = { 125, s->alt ? 125 : -146, -128, -128 };
1197
1198 ✗ for (x = 0; x < avctx->width; x++) {
1199 int a, y, u, v;
1200
1201 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1202 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1203 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1204 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1205
1206 ✗ dst_a[x] = pred[0] = (a + pred[0]) & 0xff;
1207 ✗ dst_y[x] = pred[1] = (y + pred[1]) & 0xff;
1208 ✗ dst_u[x] = pred[2] = (u + pred[2]) & 0xff;
1209 ✗ dst_v[x] = pred[3] = (v + pred[3]) & 0xff;
1210 }
1211 }
1212
1213 ✗ dst_a += p->linesize[3];
1214 ✗ dst_y += p->linesize[0];
1215 ✗ dst_u += p->linesize[1];
1216 ✗ dst_v += p->linesize[2];
1217
1218 ✗ for (y = 1; y < avctx->height; y++) {
1219 ✗ if (get_bits1(gb)) {
1220 ✗ for (x = 0; x < avctx->width; x++) {
1221 ✗ dst_a[x] = get_bits(gb, 8);
1222 ✗ dst_y[x] = get_bits(gb, 8);
1223 ✗ dst_u[x] = get_bits(gb, 8);
1224 ✗ dst_v[x] = get_bits(gb, 8);
1225 }
1226 } else {
1227 int pred_TL[4], pred_L[4], pred_T[4];
1228 int a, y, u, v;
1229
1230 ✗ pred_TL[0] = pred_L[0] = dst_a[-p->linesize[3]];
1231 ✗ pred_TL[1] = pred_L[1] = dst_y[-p->linesize[0]];
1232 ✗ pred_TL[2] = pred_L[2] = dst_u[-p->linesize[1]];
1233 ✗ pred_TL[3] = pred_L[3] = dst_v[-p->linesize[2]];
1234
1235 ✗ for (x = 0; x < avctx->width; x++) {
1236 ✗ pred_T[0] = dst_a[-p->linesize[3] + x];
1237 ✗ pred_T[1] = dst_y[-p->linesize[0] + x];
1238 ✗ pred_T[2] = dst_u[-p->linesize[1] + x];
1239 ✗ pred_T[3] = dst_v[-p->linesize[2] + x];
1240
1241 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1242 ✗ y = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1243 ✗ u = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1244 ✗ v = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1245
1246 ✗ dst_a[x] = pred_L[0] = (a + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0xff;
1247 ✗ dst_y[x] = pred_L[1] = (y + ((3 * (pred_T[1] + pred_L[1]) - 2 * pred_TL[1]) >> 2)) & 0xff;
1248 ✗ dst_u[x] = pred_L[2] = (u + ((3 * (pred_T[2] + pred_L[2]) - 2 * pred_TL[2]) >> 2)) & 0xff;
1249 ✗ dst_v[x] = pred_L[3] = (v + ((3 * (pred_T[3] + pred_L[3]) - 2 * pred_TL[3]) >> 2)) & 0xff;
1250
1251 ✗ pred_TL[0] = pred_T[0];
1252 ✗ pred_TL[1] = pred_T[1];
1253 ✗ pred_TL[2] = pred_T[2];
1254 ✗ pred_TL[3] = pred_T[3];
1255 }
1256 }
1257
1258 ✗ dst_a += p->linesize[3];
1259 ✗ dst_y += p->linesize[0];
1260 ✗ dst_u += p->linesize[1];
1261 ✗ dst_v += p->linesize[2];
1262 }
1263 ✗ }
1264
1265 ✗ static void decode_argxi(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1266 {
1267 ✗ SheerVideoContext *s = avctx->priv_data;
1268 uint16_t *dst_r, *dst_g, *dst_b, *dst_a;
1269 int x, y;
1270
1271 ✗ dst_r = (uint16_t *)p->data[2];
1272 ✗ dst_g = (uint16_t *)p->data[0];
1273 ✗ dst_b = (uint16_t *)p->data[1];
1274 ✗ dst_a = (uint16_t *)p->data[3];
1275
1276 ✗ for (y = 0; y < avctx->height; y++) {
1277 ✗ if (get_bits1(gb)) {
1278 ✗ for (x = 0; x < avctx->width; x++) {
1279 ✗ dst_a[x] = get_bits(gb, 10);
1280 ✗ dst_r[x] = get_bits(gb, 10);
1281 ✗ dst_g[x] = get_bits(gb, 10);
1282 ✗ dst_b[x] = get_bits(gb, 10);
1283 }
1284 } else {
1285 ✗ int pred[4] = { 512, 512, 512, 512 };
1286
1287 ✗ for (x = 0; x < avctx->width; x++) {
1288 int r, g, b, a;
1289
1290 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1291 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1292 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1293 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1294
1295 ✗ dst_a[x] = pred[3] = (a + pred[3]) & 0x3ff;
1296 ✗ dst_r[x] = pred[0] = (r + pred[0]) & 0x3ff;
1297 ✗ dst_g[x] = pred[1] = (r + g + pred[1]) & 0x3ff;
1298 ✗ dst_b[x] = pred[2] = (r + g + b + pred[2]) & 0x3ff;
1299 }
1300 }
1301
1302 ✗ dst_r += p->linesize[2] / 2;
1303 ✗ dst_g += p->linesize[0] / 2;
1304 ✗ dst_b += p->linesize[1] / 2;
1305 ✗ dst_a += p->linesize[3] / 2;
1306 }
1307 ✗ }
1308
1309 ✗ static void decode_argx(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1310 {
1311 ✗ SheerVideoContext *s = avctx->priv_data;
1312 uint16_t *dst_r, *dst_g, *dst_b, *dst_a;
1313 int x, y;
1314
1315 ✗ dst_r = (uint16_t *)p->data[2];
1316 ✗ dst_g = (uint16_t *)p->data[0];
1317 ✗ dst_b = (uint16_t *)p->data[1];
1318 ✗ dst_a = (uint16_t *)p->data[3];
1319
1320 ✗ if (get_bits1(gb)) {
1321 ✗ for (x = 0; x < avctx->width; x++) {
1322 ✗ dst_a[x] = get_bits(gb, 10);
1323 ✗ dst_r[x] = get_bits(gb, 10);
1324 ✗ dst_g[x] = get_bits(gb, 10);
1325 ✗ dst_b[x] = get_bits(gb, 10);
1326 }
1327 } else {
1328 ✗ int pred[4] = { 512, 512, 512, 512 };
1329
1330 ✗ for (x = 0; x < avctx->width; x++) {
1331 int r, g, b, a;
1332
1333 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1334 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1335 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1336 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1337
1338 ✗ dst_a[x] = pred[3] = (a + pred[3]) & 0x3ff;
1339 ✗ dst_r[x] = pred[0] = (r + pred[0]) & 0x3ff;
1340 ✗ dst_g[x] = pred[1] = (r + g + pred[1]) & 0x3ff;
1341 ✗ dst_b[x] = pred[2] = (r + g + b + pred[2]) & 0x3ff;
1342 }
1343 }
1344
1345 ✗ dst_r += p->linesize[2] / 2;
1346 ✗ dst_g += p->linesize[0] / 2;
1347 ✗ dst_b += p->linesize[1] / 2;
1348 ✗ dst_a += p->linesize[3] / 2;
1349
1350 ✗ for (y = 1; y < avctx->height; y++) {
1351 ✗ if (get_bits1(gb)) {
1352 ✗ for (x = 0; x < avctx->width; x++) {
1353 ✗ dst_a[x] = get_bits(gb, 10);
1354 ✗ dst_r[x] = get_bits(gb, 10);
1355 ✗ dst_g[x] = get_bits(gb, 10);
1356 ✗ dst_b[x] = get_bits(gb, 10);
1357 }
1358 } else {
1359 int pred_TL[4], pred_L[4], pred_T[4];
1360 int r, g, b, a;
1361
1362 ✗ pred_TL[0] = pred_L[0] = dst_r[-p->linesize[2] / 2];
1363 ✗ pred_TL[1] = pred_L[1] = dst_g[-p->linesize[0] / 2];
1364 ✗ pred_TL[2] = pred_L[2] = dst_b[-p->linesize[1] / 2];
1365 ✗ pred_TL[3] = pred_L[3] = dst_a[-p->linesize[3] / 2];
1366
1367 ✗ for (x = 0; x < avctx->width; x++) {
1368 ✗ pred_T[0] = dst_r[-p->linesize[2] / 2 + x];
1369 ✗ pred_T[1] = dst_g[-p->linesize[0] / 2 + x];
1370 ✗ pred_T[2] = dst_b[-p->linesize[1] / 2 + x];
1371 ✗ pred_T[3] = dst_a[-p->linesize[3] / 2 + x];
1372
1373 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1374 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1375 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1376 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1377
1378 ✗ dst_a[x] = pred_L[3] = (a + ((3 * (pred_T[3] + pred_L[3]) - 2 * pred_TL[3]) >> 2)) & 0x3ff;
1379 ✗ dst_r[x] = pred_L[0] = (r + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0x3ff;
1380 ✗ dst_g[x] = pred_L[1] = (r + g + ((3 * (pred_T[1] + pred_L[1]) - 2 * pred_TL[1]) >> 2)) & 0x3ff;
1381 ✗ dst_b[x] = pred_L[2] = (r + g + b + ((3 * (pred_T[2] + pred_L[2]) - 2 * pred_TL[2]) >> 2)) & 0x3ff;
1382
1383 ✗ pred_TL[0] = pred_T[0];
1384 ✗ pred_TL[1] = pred_T[1];
1385 ✗ pred_TL[2] = pred_T[2];
1386 ✗ pred_TL[3] = pred_T[3];
1387 }
1388 }
1389
1390 ✗ dst_r += p->linesize[2] / 2;
1391 ✗ dst_g += p->linesize[0] / 2;
1392 ✗ dst_b += p->linesize[1] / 2;
1393 ✗ dst_a += p->linesize[3] / 2;
1394 }
1395 ✗ }
1396
1397 ✗ static void decode_rgbxi(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1398 {
1399 ✗ SheerVideoContext *s = avctx->priv_data;
1400 uint16_t *dst_r, *dst_g, *dst_b;
1401 int x, y;
1402
1403 ✗ dst_r = (uint16_t *)p->data[2];
1404 ✗ dst_g = (uint16_t *)p->data[0];
1405 ✗ dst_b = (uint16_t *)p->data[1];
1406
1407 ✗ for (y = 0; y < avctx->height; y++) {
1408 ✗ if (get_bits1(gb)) {
1409 ✗ for (x = 0; x < avctx->width; x++) {
1410 ✗ dst_r[x] = get_bits(gb, 10);
1411 ✗ dst_g[x] = get_bits(gb, 10);
1412 ✗ dst_b[x] = get_bits(gb, 10);
1413 }
1414 } else {
1415 ✗ int pred[4] = { 512, 512, 512, 0 };
1416
1417 ✗ for (x = 0; x < avctx->width; x++) {
1418 int r, g, b;
1419
1420 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1421 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1422 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1423
1424 ✗ dst_r[x] = pred[0] = (r + pred[0]) & 0x3ff;
1425 ✗ dst_g[x] = pred[1] = (r + g + pred[1]) & 0x3ff;
1426 ✗ dst_b[x] = pred[2] = (r + g + b + pred[2]) & 0x3ff;
1427 }
1428 }
1429
1430 ✗ dst_r += p->linesize[2] / 2;
1431 ✗ dst_g += p->linesize[0] / 2;
1432 ✗ dst_b += p->linesize[1] / 2;
1433 }
1434 ✗ }
1435
1436 ✗ static void decode_rgbx(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1437 {
1438 ✗ SheerVideoContext *s = avctx->priv_data;
1439 uint16_t *dst_r, *dst_g, *dst_b;
1440 int x, y;
1441
1442 ✗ dst_r = (uint16_t *)p->data[2];
1443 ✗ dst_g = (uint16_t *)p->data[0];
1444 ✗ dst_b = (uint16_t *)p->data[1];
1445
1446 ✗ if (get_bits1(gb)) {
1447 ✗ for (x = 0; x < avctx->width; x++) {
1448 ✗ dst_r[x] = get_bits(gb, 10);
1449 ✗ dst_g[x] = get_bits(gb, 10);
1450 ✗ dst_b[x] = get_bits(gb, 10);
1451 }
1452 } else {
1453 ✗ int pred[4] = { 512, 512, 512, 0 };
1454
1455 ✗ for (x = 0; x < avctx->width; x++) {
1456 int r, g, b;
1457
1458 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1459 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1460 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1461
1462 ✗ dst_r[x] = pred[0] = (r + pred[0]) & 0x3ff;
1463 ✗ dst_g[x] = pred[1] = (r + g + pred[1]) & 0x3ff;
1464 ✗ dst_b[x] = pred[2] = (r + g + b + pred[2]) & 0x3ff;
1465 }
1466 }
1467
1468 ✗ dst_r += p->linesize[2] / 2;
1469 ✗ dst_g += p->linesize[0] / 2;
1470 ✗ dst_b += p->linesize[1] / 2;
1471
1472 ✗ for (y = 1; y < avctx->height; y++) {
1473 ✗ if (get_bits1(gb)) {
1474 ✗ for (x = 0; x < avctx->width; x++) {
1475 ✗ dst_r[x] = get_bits(gb, 10);
1476 ✗ dst_g[x] = get_bits(gb, 10);
1477 ✗ dst_b[x] = get_bits(gb, 10);
1478 }
1479 } else {
1480 int pred_TL[4], pred_L[4], pred_T[4];
1481 int r, g, b;
1482
1483 ✗ pred_TL[0] = pred_L[0] = dst_r[-p->linesize[2] / 2];
1484 ✗ pred_TL[1] = pred_L[1] = dst_g[-p->linesize[0] / 2];
1485 ✗ pred_TL[2] = pred_L[2] = dst_b[-p->linesize[1] / 2];
1486
1487 ✗ for (x = 0; x < avctx->width; x++) {
1488 ✗ pred_T[0] = dst_r[-p->linesize[2] / 2 + x];
1489 ✗ pred_T[1] = dst_g[-p->linesize[0] / 2 + x];
1490 ✗ pred_T[2] = dst_b[-p->linesize[1] / 2 + x];
1491
1492 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1493 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1494 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1495
1496 ✗ dst_r[x] = pred_L[0] = (r + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0x3ff;
1497 ✗ dst_g[x] = pred_L[1] = (r + g + ((3 * (pred_T[1] + pred_L[1]) - 2 * pred_TL[1]) >> 2)) & 0x3ff;
1498 ✗ dst_b[x] = pred_L[2] = (r + g + b + ((3 * (pred_T[2] + pred_L[2]) - 2 * pred_TL[2]) >> 2)) & 0x3ff;
1499
1500 ✗ pred_TL[0] = pred_T[0];
1501 ✗ pred_TL[1] = pred_T[1];
1502 ✗ pred_TL[2] = pred_T[2];
1503 }
1504 }
1505
1506 ✗ dst_r += p->linesize[2] / 2;
1507 ✗ dst_g += p->linesize[0] / 2;
1508 ✗ dst_b += p->linesize[1] / 2;
1509 }
1510 ✗ }
1511
1512 ✗ static void decode_argbi(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1513 {
1514 ✗ SheerVideoContext *s = avctx->priv_data;
1515 uint8_t *dst;
1516 int x, y;
1517
1518 ✗ dst = p->data[0];
1519 ✗ if (get_bits1(gb)) {
1520 ✗ for (x = 0; x < avctx->width; x++) {
1521 ✗ dst[x * 4 + 0] = get_bits(gb, 8);
1522 ✗ dst[x * 4 + 1] = get_bits(gb, 8);
1523 ✗ dst[x * 4 + 2] = get_bits(gb, 8);
1524 ✗ dst[x * 4 + 3] = get_bits(gb, 8);
1525 }
1526 } else {
1527 ✗ int pred[4] = { -128, -128, -128, -128 };
1528
1529 ✗ for (x = 0; x < avctx->width; x++) {
1530 int a, r, g, b;
1531
1532 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1533 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1534 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1535 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1536
1537 ✗ dst[4 * x + 0] = pred[0] = (a + pred[0]) & 0xff;
1538 ✗ dst[4 * x + 1] = pred[1] = (r + pred[1]) & 0xff;
1539 ✗ dst[4 * x + 2] = pred[2] = (r + g + pred[2]) & 0xff;
1540 ✗ dst[4 * x + 3] = pred[3] = (r + g + b + pred[3]) & 0xff;
1541 }
1542 }
1543
1544 ✗ dst += p->linesize[0];
1545 ✗ for (y = 1; y < avctx->height; y++) {
1546 ✗ if (get_bits1(gb)) {
1547 ✗ for (x = 0; x < avctx->width; x++) {
1548 ✗ dst[x * 4 + 0] = get_bits(gb, 8);
1549 ✗ dst[x * 4 + 1] = get_bits(gb, 8);
1550 ✗ dst[x * 4 + 2] = get_bits(gb, 8);
1551 ✗ dst[x * 4 + 3] = get_bits(gb, 8);
1552 }
1553 } else {
1554 int pred_L[4];
1555 int a, r, g, b;
1556
1557 ✗ pred_L[0] = dst[-p->linesize[0] + 0];
1558 ✗ pred_L[1] = dst[-p->linesize[0] + 1];
1559 ✗ pred_L[2] = dst[-p->linesize[0] + 2];
1560 ✗ pred_L[3] = dst[-p->linesize[0] + 3];
1561
1562 ✗ for (x = 0; x < avctx->width; x++) {
1563 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1564 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1565 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1566 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1567
1568 ✗ dst[4 * x + 0] = pred_L[0] = (a + pred_L[0]) & 0xff;
1569 ✗ dst[4 * x + 1] = pred_L[1] = (r + pred_L[1]) & 0xff;
1570 ✗ dst[4 * x + 2] = pred_L[2] = (r + g + pred_L[2]) & 0xff;
1571 ✗ dst[4 * x + 3] = pred_L[3] = (r + g + b + pred_L[3]) & 0xff;
1572 }
1573 }
1574 ✗ dst += p->linesize[0];
1575 }
1576 ✗ }
1577
1578 ✗ static void decode_argb(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1579 {
1580 ✗ SheerVideoContext *s = avctx->priv_data;
1581 uint8_t *dst;
1582 int x, y;
1583
1584 ✗ dst = p->data[0];
1585 ✗ if (get_bits1(gb)) {
1586 ✗ for (x = 0; x < avctx->width; x++) {
1587 ✗ dst[x * 4 + 0] = get_bits(gb, 8);
1588 ✗ dst[x * 4 + 1] = get_bits(gb, 8);
1589 ✗ dst[x * 4 + 2] = get_bits(gb, 8);
1590 ✗ dst[x * 4 + 3] = get_bits(gb, 8);
1591 }
1592 } else {
1593 ✗ int pred[4] = { -128, -128, -128, -128 };
1594
1595 ✗ for (x = 0; x < avctx->width; x++) {
1596 int a, r, g, b;
1597
1598 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1599 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1600 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1601 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1602
1603 ✗ dst[4 * x + 0] = pred[0] = (a + pred[0]) & 0xff;
1604 ✗ dst[4 * x + 1] = pred[1] = (r + pred[1]) & 0xff;
1605 ✗ dst[4 * x + 2] = pred[2] = (r + g + pred[2]) & 0xff;
1606 ✗ dst[4 * x + 3] = pred[3] = (r + g + b + pred[3]) & 0xff;
1607 }
1608 }
1609
1610 ✗ dst += p->linesize[0];
1611 ✗ for (y = 1; y < avctx->height; y++) {
1612 ✗ if (get_bits1(gb)) {
1613 ✗ for (x = 0; x < avctx->width; x++) {
1614 ✗ dst[x * 4 + 0] = get_bits(gb, 8);
1615 ✗ dst[x * 4 + 1] = get_bits(gb, 8);
1616 ✗ dst[x * 4 + 2] = get_bits(gb, 8);
1617 ✗ dst[x * 4 + 3] = get_bits(gb, 8);
1618 }
1619 } else {
1620 int pred_TL[4], pred_L[4], pred_T[4];
1621 int a, r, g, b;
1622
1623 ✗ pred_TL[0] = pred_L[0] = dst[-p->linesize[0] + 0];
1624 ✗ pred_TL[1] = pred_L[1] = dst[-p->linesize[0] + 1];
1625 ✗ pred_TL[2] = pred_L[2] = dst[-p->linesize[0] + 2];
1626 ✗ pred_TL[3] = pred_L[3] = dst[-p->linesize[0] + 3];
1627
1628 ✗ for (x = 0; x < avctx->width; x++) {
1629 ✗ pred_T[0] = dst[-p->linesize[0] + 4 * x + 0];
1630 ✗ pred_T[1] = dst[-p->linesize[0] + 4 * x + 1];
1631 ✗ pred_T[2] = dst[-p->linesize[0] + 4 * x + 2];
1632 ✗ pred_T[3] = dst[-p->linesize[0] + 4 * x + 3];
1633
1634 ✗ a = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1635 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1636 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1637 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1638
1639 ✗ dst[4 * x + 0] = pred_L[0] = (a + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0xff;
1640 ✗ dst[4 * x + 1] = pred_L[1] = (r + ((3 * (pred_T[1] + pred_L[1]) - 2 * pred_TL[1]) >> 2)) & 0xff;
1641 ✗ dst[4 * x + 2] = pred_L[2] = (r + g + ((3 * (pred_T[2] + pred_L[2]) - 2 * pred_TL[2]) >> 2)) & 0xff;
1642 ✗ dst[4 * x + 3] = pred_L[3] = (r + g + b + ((3 * (pred_T[3] + pred_L[3]) - 2 * pred_TL[3]) >> 2)) & 0xff;
1643
1644 ✗ pred_TL[0] = pred_T[0];
1645 ✗ pred_TL[1] = pred_T[1];
1646 ✗ pred_TL[2] = pred_T[2];
1647 ✗ pred_TL[3] = pred_T[3];
1648 }
1649 }
1650 ✗ dst += p->linesize[0];
1651 }
1652 ✗ }
1653
1654 ✗ static void decode_rgbi(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1655 {
1656 ✗ SheerVideoContext *s = avctx->priv_data;
1657 uint8_t *dst;
1658 int x, y;
1659
1660 ✗ dst = p->data[0];
1661 ✗ if (get_bits1(gb)) {
1662 ✗ for (x = 0; x < avctx->width; x++) {
1663 ✗ dst[x * 4 + 0] = get_bits(gb, 8);
1664 ✗ dst[x * 4 + 1] = get_bits(gb, 8);
1665 ✗ dst[x * 4 + 2] = get_bits(gb, 8);
1666 }
1667 } else {
1668 ✗ int pred[4] = { -128, -128, -128, -128 };
1669
1670 ✗ for (x = 0; x < avctx->width; x++) {
1671 int r, g, b;
1672
1673 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1674 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1675 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1676
1677 ✗ dst[4 * x + 0] = pred[0] = (r + pred[0]) & 0xff;
1678 ✗ dst[4 * x + 1] = pred[1] = (r + g + pred[1]) & 0xff;
1679 ✗ dst[4 * x + 2] = pred[2] = (r + g + b + pred[2]) & 0xff;
1680 }
1681 }
1682
1683 ✗ dst += p->linesize[0];
1684 ✗ for (y = 1; y < avctx->height; y++) {
1685 ✗ if (get_bits1(gb)) {
1686 ✗ for (x = 0; x < avctx->width; x++) {
1687 ✗ dst[x * 4 + 0] = get_bits(gb, 8);
1688 ✗ dst[x * 4 + 1] = get_bits(gb, 8);
1689 ✗ dst[x * 4 + 2] = get_bits(gb, 8);
1690 }
1691 } else {
1692 int pred_L[4];
1693 int r, g, b;
1694
1695 ✗ pred_L[0] = dst[-p->linesize[0] + 0];
1696 ✗ pred_L[1] = dst[-p->linesize[0] + 1];
1697 ✗ pred_L[2] = dst[-p->linesize[0] + 2];
1698
1699 ✗ for (x = 0; x < avctx->width; x++) {
1700 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1701 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1702 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1703
1704 ✗ dst[4 * x + 0] = pred_L[0] = (r + pred_L[0]) & 0xff;
1705 ✗ dst[4 * x + 1] = pred_L[1] = (r + g + pred_L[1]) & 0xff;
1706 ✗ dst[4 * x + 2] = pred_L[2] = (r + g + b + pred_L[2]) & 0xff;
1707 }
1708 }
1709 ✗ dst += p->linesize[0];
1710 }
1711 ✗ }
1712
1713 ✗ static void decode_rgb(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
1714 {
1715 ✗ SheerVideoContext *s = avctx->priv_data;
1716 uint8_t *dst;
1717 int x, y;
1718
1719 ✗ dst = p->data[0];
1720 ✗ if (get_bits1(gb)) {
1721 ✗ for (x = 0; x < avctx->width; x++) {
1722 ✗ dst[x * 4 + 0] = get_bits(gb, 8);
1723 ✗ dst[x * 4 + 1] = get_bits(gb, 8);
1724 ✗ dst[x * 4 + 2] = get_bits(gb, 8);
1725 }
1726 } else {
1727 ✗ int pred[4] = { -128, -128, -128, -128 };
1728
1729 ✗ for (x = 0; x < avctx->width; x++) {
1730 int r, g, b;
1731
1732 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1733 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1734 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1735
1736 ✗ dst[4 * x + 0] = pred[0] = (r + pred[0]) & 0xff;
1737 ✗ dst[4 * x + 1] = pred[1] = (r + g + pred[1]) & 0xff;
1738 ✗ dst[4 * x + 2] = pred[2] = (r + g + b + pred[2]) & 0xff;
1739 }
1740 }
1741
1742 ✗ dst += p->linesize[0];
1743 ✗ for (y = 1; y < avctx->height; y++) {
1744 ✗ if (get_bits1(gb)) {
1745 ✗ for (x = 0; x < avctx->width; x++) {
1746 ✗ dst[x * 4 + 0] = get_bits(gb, 8);
1747 ✗ dst[x * 4 + 1] = get_bits(gb, 8);
1748 ✗ dst[x * 4 + 2] = get_bits(gb, 8);
1749 }
1750 } else {
1751 int pred_TL[4], pred_L[4], pred_T[4];
1752 int r, g, b;
1753
1754 ✗ pred_TL[0] = pred_L[0] = dst[-p->linesize[0] + 0];
1755 ✗ pred_TL[1] = pred_L[1] = dst[-p->linesize[0] + 1];
1756 ✗ pred_TL[2] = pred_L[2] = dst[-p->linesize[0] + 2];
1757
1758 ✗ for (x = 0; x < avctx->width; x++) {
1759 ✗ pred_T[0] = dst[-p->linesize[0] + 4 * x + 0];
1760 ✗ pred_T[1] = dst[-p->linesize[0] + 4 * x + 1];
1761 ✗ pred_T[2] = dst[-p->linesize[0] + 4 * x + 2];
1762
1763 ✗ r = get_vlc2(gb, s->vlc[0].table, SHEER_VLC_BITS, 2);
1764 ✗ g = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1765 ✗ b = get_vlc2(gb, s->vlc[1].table, SHEER_VLC_BITS, 2);
1766
1767 ✗ dst[4 * x + 0] = pred_L[0] = (r + ((3 * (pred_T[0] + pred_L[0]) - 2 * pred_TL[0]) >> 2)) & 0xff;
1768 ✗ dst[4 * x + 1] = pred_L[1] = (r + g + ((3 * (pred_T[1] + pred_L[1]) - 2 * pred_TL[1]) >> 2)) & 0xff;
1769 ✗ dst[4 * x + 2] = pred_L[2] = (r + g + b + ((3 * (pred_T[2] + pred_L[2]) - 2 * pred_TL[2]) >> 2)) & 0xff;
1770
1771 ✗ pred_TL[0] = pred_T[0];
1772 ✗ pred_TL[1] = pred_T[1];
1773 ✗ pred_TL[2] = pred_T[2];
1774 }
1775 }
1776 ✗ dst += p->linesize[0];
1777 }
1778 ✗ }
1779
1780 ✗ static av_cold int build_vlc(VLC *vlc, const SheerTable *table)
1781 {
1782 ✗ const uint8_t *cur = table->lens;
1783 uint8_t lens[1024];
1784 ✗ unsigned count = 0;
1785
1786 ✗ for (int step = 1, len = 1; len > 0; len += step) {
1787 ✗ unsigned new_count = count;
1788
1789 ✗ if (len == 16) {
1790 ✗ new_count += table->nb_16s;
1791 ✗ step = -1;
1792 } else
1793 ✗ new_count += *cur++;
1794
1795 ✗ for (; count < new_count; count++)
1796 ✗ lens[count] = len;
1797 }
1798
1799 ✗ ff_vlc_free(vlc);
1800 ✗ return ff_vlc_init_from_lengths(vlc, SHEER_VLC_BITS, count,
1801 lens, sizeof(*lens), NULL, 0, 0, 0, 0, NULL);
1802 }
1803
1804 ✗ static int decode_frame(AVCodecContext *avctx, AVFrame *p,
1805 int *got_frame, AVPacket *avpkt)
1806 {
1807 ✗ SheerVideoContext *s = avctx->priv_data;
1808 const SheerTable *table;
1809 GetBitContext gb;
1810 unsigned format;
1811 int ret;
1812
1813 ✗ if (avpkt->size <= 20)
1814 ✗ return AVERROR_INVALIDDATA;
1815
1816 ✗ if (AV_RL32(avpkt->data) != MKTAG('S','h','i','r') &&
1817 ✗ AV_RL32(avpkt->data) != MKTAG('Z','w','a','k'))
1818 ✗ return AVERROR_INVALIDDATA;
1819
1820 ✗ s->alt = 0;
1821 ✗ format = AV_RL32(avpkt->data + 16);
1822 ✗ av_log(avctx, AV_LOG_DEBUG, "format: %s\n", av_fourcc2str(format));
1823 ✗ switch (format) {
1824 ✗ case MKTAG(' ', 'R', 'G', 'B'):
1825 ✗ avctx->pix_fmt = AV_PIX_FMT_RGB0;
1826 ✗ s->decode_frame = decode_rgb;
1827 ✗ table = rgb;
1828 ✗ break;
1829 ✗ case MKTAG(' ', 'r', 'G', 'B'):
1830 ✗ avctx->pix_fmt = AV_PIX_FMT_RGB0;
1831 ✗ s->decode_frame = decode_rgbi;
1832 ✗ table = rgbi;
1833 ✗ break;
1834 ✗ case MKTAG('A', 'R', 'G', 'X'):
1835 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
1836 ✗ s->decode_frame = decode_argx;
1837 ✗ table = rgbx;
1838 ✗ break;
1839 ✗ case MKTAG('A', 'r', 'G', 'X'):
1840 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
1841 ✗ s->decode_frame = decode_argxi;
1842 ✗ table = rgbxi;
1843 ✗ break;
1844 ✗ case MKTAG('R', 'G', 'B', 'X'):
1845 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRP10;
1846 ✗ s->decode_frame = decode_rgbx;
1847 ✗ table = rgbx;
1848 ✗ break;
1849 ✗ case MKTAG('r', 'G', 'B', 'X'):
1850 ✗ avctx->pix_fmt = AV_PIX_FMT_GBRP10;
1851 ✗ s->decode_frame = decode_rgbxi;
1852 ✗ table = rgbxi;
1853 ✗ break;
1854 ✗ case MKTAG('A', 'R', 'G', 'B'):
1855 ✗ avctx->pix_fmt = AV_PIX_FMT_ARGB;
1856 ✗ s->decode_frame = decode_argb;
1857 ✗ table = rgb;
1858 ✗ break;
1859 ✗ case MKTAG('A', 'r', 'G', 'B'):
1860 ✗ avctx->pix_fmt = AV_PIX_FMT_ARGB;
1861 ✗ s->decode_frame = decode_argbi;
1862 ✗ table = rgbi;
1863 ✗ break;
1864 ✗ case MKTAG('A', 'Y', 'B', 'R'):
1865 ✗ s->alt = 1;
1866 ✗ case MKTAG('A', 'Y', 'b', 'R'):
1867 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
1868 ✗ s->decode_frame = decode_aybr;
1869 ✗ table = ybr;
1870 ✗ break;
1871 ✗ case MKTAG('A', 'y', 'B', 'R'):
1872 ✗ s->alt = 1;
1873 ✗ case MKTAG('A', 'y', 'b', 'R'):
1874 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
1875 ✗ s->decode_frame = decode_aybri;
1876 ✗ table = ybri;
1877 ✗ break;
1878 ✗ case MKTAG(' ', 'Y', 'B', 'R'):
1879 ✗ s->alt = 1;
1880 ✗ case MKTAG(' ', 'Y', 'b', 'R'):
1881 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV444P;
1882 ✗ s->decode_frame = decode_ybr;
1883 ✗ table = ybr;
1884 ✗ break;
1885 ✗ case MKTAG(' ', 'y', 'B', 'R'):
1886 ✗ s->alt = 1;
1887 ✗ case MKTAG(' ', 'y', 'b', 'R'):
1888 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV444P;
1889 ✗ s->decode_frame = decode_ybri;
1890 ✗ table = ybri;
1891 ✗ break;
1892 ✗ case MKTAG('Y', 'B', 'R', 0x0a):
1893 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
1894 ✗ s->decode_frame = decode_ybr10;
1895 ✗ table = ybr10;
1896 ✗ break;
1897 ✗ case MKTAG('y', 'B', 'R', 0x0a):
1898 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
1899 ✗ s->decode_frame = decode_ybr10i;
1900 ✗ table = ybr10i;
1901 ✗ break;
1902 ✗ case MKTAG('C', 'A', '4', 'p'):
1903 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA444P10;
1904 ✗ s->decode_frame = decode_ca4p;
1905 ✗ table = ybr10;
1906 ✗ break;
1907 ✗ case MKTAG('C', 'A', '4', 'i'):
1908 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA444P10;
1909 ✗ s->decode_frame = decode_ca4i;
1910 ✗ table = ybr10i;
1911 ✗ break;
1912 ✗ case MKTAG('B', 'Y', 'R', 'Y'):
1913 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV422P;
1914 ✗ s->decode_frame = decode_byry;
1915 ✗ table = byry;
1916 ✗ break;
1917 ✗ case MKTAG('B', 'Y', 'R', 'y'):
1918 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV422P;
1919 ✗ s->decode_frame = decode_byryi;
1920 ✗ table = byryi;
1921 ✗ break;
1922 ✗ case MKTAG('Y', 'b', 'Y', 'r'):
1923 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV422P;
1924 ✗ s->decode_frame = decode_ybyr;
1925 ✗ table = ybyr;
1926 ✗ break;
1927 ✗ case MKTAG('C', '8', '2', 'p'):
1928 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
1929 ✗ s->decode_frame = decode_c82p;
1930 ✗ table = byry;
1931 ✗ break;
1932 ✗ case MKTAG('C', '8', '2', 'i'):
1933 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
1934 ✗ s->decode_frame = decode_c82i;
1935 ✗ table = byryi;
1936 ✗ break;
1937 ✗ case MKTAG(0xa2, 'Y', 'R', 'Y'):
1938 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
1939 ✗ s->decode_frame = decode_yry10;
1940 ✗ table = yry10;
1941 ✗ break;
1942 ✗ case MKTAG(0xa2, 'Y', 'R', 'y'):
1943 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
1944 ✗ s->decode_frame = decode_yry10i;
1945 ✗ table = yry10i;
1946 ✗ break;
1947 ✗ case MKTAG('C', 'A', '2', 'p'):
1948 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA422P10;
1949 ✗ s->decode_frame = decode_ca2p;
1950 ✗ table = yry10;
1951 ✗ break;
1952 ✗ case MKTAG('C', 'A', '2', 'i'):
1953 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA422P10;
1954 ✗ s->decode_frame = decode_ca2i;
1955 ✗ table = yry10i;
1956 ✗ break;
1957 ✗ default:
1958 ✗ avpriv_request_sample(avctx, "unsupported format: 0x%X", format);
1959 ✗ return AVERROR_PATCHWELCOME;
1960 }
1961
1962 ✗ if (s->format != format) {
1963 ✗ if ((ret = build_vlc(&s->vlc[0], &table[0])) < 0 ||
1964 ✗ (ret = build_vlc(&s->vlc[1], &table[1])) < 0) {
1965 ✗ s->format = 0;
1966 ✗ return ret;
1967 }
1968 ✗ s->format = format;
1969 }
1970 ✗ if (avpkt->size < 20 + avctx->width * avctx->height / 16) {
1971 ✗ av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
1972 ✗ return AVERROR_INVALIDDATA;
1973 }
1974
1975 ✗ if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0)
1976 ✗ return ret;
1977
1978 ✗ if ((ret = init_get_bits8(&gb, avpkt->data + 20, avpkt->size - 20)) < 0)
1979 ✗ return ret;
1980
1981 ✗ s->decode_frame(avctx, p, &gb);
1982
1983 ✗ *got_frame = 1;
1984
1985 ✗ return avpkt->size;
1986 }
1987
1988 ✗ static av_cold int decode_end(AVCodecContext *avctx)
1989 {
1990 ✗ SheerVideoContext *s = avctx->priv_data;
1991
1992 ✗ ff_vlc_free(&s->vlc[0]);
1993 ✗ ff_vlc_free(&s->vlc[1]);
1994
1995 ✗ return 0;
1996 }
1997
1998 const FFCodec ff_sheervideo_decoder = {
1999 .p.name = "sheervideo",
2000 CODEC_LONG_NAME("BitJazz SheerVideo"),
2001 .p.type = AVMEDIA_TYPE_VIDEO,
2002 .p.id = AV_CODEC_ID_SHEERVIDEO,
2003 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
2004 .priv_data_size = sizeof(SheerVideoContext),
2005 .close = decode_end,
2006 FF_CODEC_DECODE_CB(decode_frame),
2007 };
2008