FFmpeg coverage

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