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 <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "libavutil/intreadwrite.h"
27 #include "avcodec.h"
28 #include "get_bits.h"
29 #include "internal.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
decode_ca4i(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
66 y = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
67 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
68 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_ca4p(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
109 y = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
110 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
111 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[1].bits, 2);
149 y = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
150 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
151 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_ybr10i(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
196 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
197 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_ybr10(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
234 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
235 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[0].bits, 2);
268 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
269 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_yry10i(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
312 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
313 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
314 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_yry10(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
353 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
354 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
355 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[0].bits, 2);
391 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
392 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
393 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_ca2i(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
440 y1 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
441 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
442 a2 = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
443 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
444 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_ca2p(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
489 y1 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
490 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
491 a2 = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
492 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
493 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[1].bits, 2);
537 y1 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
538 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
539 a2 = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
540 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
541 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_c82i(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
592 y1 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
593 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
594 a2 = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
595 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
596 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_c82p(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
641 y1 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
642 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
643 a2 = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
644 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
645 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[1].bits, 2);
689 y1 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
690 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
691 a2 = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
692 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
693 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_ybyr(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
740 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
741 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
742 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[0].bits, 2);
778 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
779 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
780 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_byryi(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
823 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
824 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
825 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[0].bits, 2);
856 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
857 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
858 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_byry(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
897 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
898 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
899 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[0].bits, 2);
935 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
936 y2 = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
937 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_ybri(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
979 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
980 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[0].bits, 2);
1009 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1010 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_ybr(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
1047 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1048 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[0].bits, 2);
1081 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1082 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_aybri(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
1125 y = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1126 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1127 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[1].bits, 2);
1160 y = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1161 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1162 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_aybr(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
1203 y = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1204 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1205 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[1].bits, 2);
1243 y = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1244 u = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1245 v = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_argxi(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
1292 r = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1293 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1294 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_argx(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
1335 r = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1336 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1337 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[1].bits, 2);
1375 r = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1376 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1377 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_rgbxi(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
1422 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1423 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_rgbx(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
1460 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1461 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[0].bits, 2);
1494 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1495 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_argbi(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
1534 r = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1535 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1536 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[1].bits, 2);
1565 r = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1566 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1567 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_argb(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[1].bits, 2);
1600 r = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1601 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1602 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[1].bits, 2);
1636 r = get_vlc2(gb, s->vlc[0].table, s->vlc[0].bits, 2);
1637 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1638 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_rgbi(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
1675 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1676 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[0].bits, 2);
1702 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1703 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
decode_rgb(AVCodecContext * avctx,AVFrame * p,GetBitContext * gb)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, s->vlc[0].bits, 2);
1734 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1735 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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, s->vlc[0].bits, 2);
1765 g = get_vlc2(gb, s->vlc[1].table, s->vlc[1].bits, 2);
1766 b = get_vlc2(gb, s->vlc[1].table, s->vlc[1].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
build_vlc(VLC * vlc,const uint8_t * len,int count)1781 static int build_vlc(VLC *vlc, const uint8_t *len, int count)
1782 {
1783 uint32_t codes[1024];
1784 uint8_t bits[1024];
1785 uint16_t syms[1024];
1786 uint64_t index;
1787 int i;
1788
1789 index = 0;
1790 for (i = 0; i < count; i++) {
1791 codes[i] = index >> (32 - len[i]);
1792 bits[i] = len[i];
1793 syms[i] = i;
1794 index += 1ULL << (32 - len[i]);
1795 }
1796
1797 ff_free_vlc(vlc);
1798 return ff_init_vlc_sparse(vlc, 16, count,
1799 bits, sizeof(*bits), sizeof(*bits),
1800 codes, sizeof(*codes), sizeof(*codes),
1801 syms, sizeof(*syms), sizeof(*syms), 0);
1802 }
1803
decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)1804 static int decode_frame(AVCodecContext *avctx,
1805 void *data, int *got_frame,
1806 AVPacket *avpkt)
1807 {
1808 SheerVideoContext *s = avctx->priv_data;
1809 ThreadFrame frame = { .f = data };
1810 AVFrame *p = data;
1811 GetBitContext gb;
1812 unsigned format;
1813 int ret;
1814
1815 if (avpkt->size <= 20)
1816 return AVERROR_INVALIDDATA;
1817
1818 if (AV_RL32(avpkt->data) != MKTAG('S','h','i','r') &&
1819 AV_RL32(avpkt->data) != MKTAG('Z','w','a','k'))
1820 return AVERROR_INVALIDDATA;
1821
1822 s->alt = 0;
1823 format = AV_RL32(avpkt->data + 16);
1824 av_log(avctx, AV_LOG_DEBUG, "format: %s\n", av_fourcc2str(format));
1825 switch (format) {
1826 case MKTAG(' ', 'R', 'G', 'B'):
1827 avctx->pix_fmt = AV_PIX_FMT_RGB0;
1828 s->decode_frame = decode_rgb;
1829 if (s->format != format) {
1830 ret = build_vlc(&s->vlc[0], l_r_rgb, 256);
1831 ret |= build_vlc(&s->vlc[1], l_g_rgb, 256);
1832 }
1833 break;
1834 case MKTAG(' ', 'r', 'G', 'B'):
1835 avctx->pix_fmt = AV_PIX_FMT_RGB0;
1836 s->decode_frame = decode_rgbi;
1837 if (s->format != format) {
1838 ret = build_vlc(&s->vlc[0], l_r_rgbi, 256);
1839 ret |= build_vlc(&s->vlc[1], l_g_rgbi, 256);
1840 }
1841 break;
1842 case MKTAG('A', 'R', 'G', 'X'):
1843 avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
1844 s->decode_frame = decode_argx;
1845 if (s->format != format) {
1846 ret = build_vlc(&s->vlc[0], l_r_rgbx, 1024);
1847 ret |= build_vlc(&s->vlc[1], l_g_rgbx, 1024);
1848 }
1849 break;
1850 case MKTAG('A', 'r', 'G', 'X'):
1851 avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
1852 s->decode_frame = decode_argxi;
1853 if (s->format != format) {
1854 ret = build_vlc(&s->vlc[0], l_r_rgbxi, 1024);
1855 ret |= build_vlc(&s->vlc[1], l_g_rgbxi, 1024);
1856 }
1857 break;
1858 case MKTAG('R', 'G', 'B', 'X'):
1859 avctx->pix_fmt = AV_PIX_FMT_GBRP10;
1860 s->decode_frame = decode_rgbx;
1861 if (s->format != format) {
1862 ret = build_vlc(&s->vlc[0], l_r_rgbx, 1024);
1863 ret |= build_vlc(&s->vlc[1], l_g_rgbx, 1024);
1864 }
1865 break;
1866 case MKTAG('r', 'G', 'B', 'X'):
1867 avctx->pix_fmt = AV_PIX_FMT_GBRP10;
1868 s->decode_frame = decode_rgbxi;
1869 if (s->format != format) {
1870 ret = build_vlc(&s->vlc[0], l_r_rgbxi, 1024);
1871 ret |= build_vlc(&s->vlc[1], l_g_rgbxi, 1024);
1872 }
1873 break;
1874 case MKTAG('A', 'R', 'G', 'B'):
1875 avctx->pix_fmt = AV_PIX_FMT_ARGB;
1876 s->decode_frame = decode_argb;
1877 if (s->format != format) {
1878 ret = build_vlc(&s->vlc[0], l_r_rgb, 256);
1879 ret |= build_vlc(&s->vlc[1], l_g_rgb, 256);
1880 }
1881 break;
1882 case MKTAG('A', 'r', 'G', 'B'):
1883 avctx->pix_fmt = AV_PIX_FMT_ARGB;
1884 s->decode_frame = decode_argbi;
1885 if (s->format != format) {
1886 ret = build_vlc(&s->vlc[0], l_r_rgbi, 256);
1887 ret |= build_vlc(&s->vlc[1], l_g_rgbi, 256);
1888 }
1889 break;
1890 case MKTAG('A', 'Y', 'B', 'R'):
1891 s->alt = 1;
1892 case MKTAG('A', 'Y', 'b', 'R'):
1893 avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
1894 s->decode_frame = decode_aybr;
1895 if (s->format != format) {
1896 ret = build_vlc(&s->vlc[0], l_y_ybr, 256);
1897 ret |= build_vlc(&s->vlc[1], l_u_ybr, 256);
1898 }
1899 break;
1900 case MKTAG('A', 'y', 'B', 'R'):
1901 s->alt = 1;
1902 case MKTAG('A', 'y', 'b', 'R'):
1903 avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
1904 s->decode_frame = decode_aybri;
1905 if (s->format != format) {
1906 ret = build_vlc(&s->vlc[0], l_y_ybri, 256);
1907 ret |= build_vlc(&s->vlc[1], l_u_ybri, 256);
1908 }
1909 break;
1910 case MKTAG(' ', 'Y', 'B', 'R'):
1911 s->alt = 1;
1912 case MKTAG(' ', 'Y', 'b', 'R'):
1913 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
1914 s->decode_frame = decode_ybr;
1915 if (s->format != format) {
1916 ret = build_vlc(&s->vlc[0], l_y_ybr, 256);
1917 ret |= build_vlc(&s->vlc[1], l_u_ybr, 256);
1918 }
1919 break;
1920 case MKTAG(' ', 'y', 'B', 'R'):
1921 s->alt = 1;
1922 case MKTAG(' ', 'y', 'b', 'R'):
1923 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
1924 s->decode_frame = decode_ybri;
1925 if (s->format != format) {
1926 ret = build_vlc(&s->vlc[0], l_y_ybri, 256);
1927 ret |= build_vlc(&s->vlc[1], l_u_ybri, 256);
1928 }
1929 break;
1930 case MKTAG('Y', 'B', 'R', 0x0a):
1931 avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
1932 s->decode_frame = decode_ybr10;
1933 if (s->format != format) {
1934 ret = build_vlc(&s->vlc[0], l_y_ybr10, 1024);
1935 ret |= build_vlc(&s->vlc[1], l_u_ybr10, 1024);
1936 }
1937 break;
1938 case MKTAG('y', 'B', 'R', 0x0a):
1939 avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
1940 s->decode_frame = decode_ybr10i;
1941 if (s->format != format) {
1942 ret = build_vlc(&s->vlc[0], l_y_ybr10i, 1024);
1943 ret |= build_vlc(&s->vlc[1], l_u_ybr10i, 1024);
1944 }
1945 break;
1946 case MKTAG('C', 'A', '4', 'p'):
1947 avctx->pix_fmt = AV_PIX_FMT_YUVA444P10;
1948 s->decode_frame = decode_ca4p;
1949 if (s->format != format) {
1950 ret = build_vlc(&s->vlc[0], l_y_ybr10, 1024);
1951 ret |= build_vlc(&s->vlc[1], l_u_ybr10, 1024);
1952 }
1953 break;
1954 case MKTAG('C', 'A', '4', 'i'):
1955 avctx->pix_fmt = AV_PIX_FMT_YUVA444P10;
1956 s->decode_frame = decode_ca4i;
1957 if (s->format != format) {
1958 ret = build_vlc(&s->vlc[0], l_y_ybr10i, 1024);
1959 ret |= build_vlc(&s->vlc[1], l_u_ybr10i, 1024);
1960 }
1961 break;
1962 case MKTAG('B', 'Y', 'R', 'Y'):
1963 avctx->pix_fmt = AV_PIX_FMT_YUV422P;
1964 s->decode_frame = decode_byry;
1965 if (s->format != format) {
1966 ret = build_vlc(&s->vlc[0], l_y_byry, 256);
1967 ret |= build_vlc(&s->vlc[1], l_u_byry, 256);
1968 }
1969 break;
1970 case MKTAG('B', 'Y', 'R', 'y'):
1971 avctx->pix_fmt = AV_PIX_FMT_YUV422P;
1972 s->decode_frame = decode_byryi;
1973 if (s->format != format) {
1974 ret = build_vlc(&s->vlc[0], l_y_byryi, 256);
1975 ret |= build_vlc(&s->vlc[1], l_u_byryi, 256);
1976 }
1977 break;
1978 case MKTAG('Y', 'b', 'Y', 'r'):
1979 avctx->pix_fmt = AV_PIX_FMT_YUV422P;
1980 s->decode_frame = decode_ybyr;
1981 if (s->format != format) {
1982 ret = build_vlc(&s->vlc[0], l_y_ybyr, 256);
1983 ret |= build_vlc(&s->vlc[1], l_u_ybyr, 256);
1984 }
1985 break;
1986 case MKTAG('C', '8', '2', 'p'):
1987 avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
1988 s->decode_frame = decode_c82p;
1989 if (s->format != format) {
1990 ret = build_vlc(&s->vlc[0], l_y_byry, 256);
1991 ret |= build_vlc(&s->vlc[1], l_u_byry, 256);
1992 }
1993 break;
1994 case MKTAG('C', '8', '2', 'i'):
1995 avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
1996 s->decode_frame = decode_c82i;
1997 if (s->format != format) {
1998 ret = build_vlc(&s->vlc[0], l_y_byryi, 256);
1999 ret |= build_vlc(&s->vlc[1], l_u_byryi, 256);
2000 }
2001 break;
2002 case MKTAG(0xa2, 'Y', 'R', 'Y'):
2003 avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
2004 s->decode_frame = decode_yry10;
2005 if (s->format != format) {
2006 ret = build_vlc(&s->vlc[0], l_y_yry10, 1024);
2007 ret |= build_vlc(&s->vlc[1], l_u_yry10, 1024);
2008 }
2009 break;
2010 case MKTAG(0xa2, 'Y', 'R', 'y'):
2011 avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
2012 s->decode_frame = decode_yry10i;
2013 if (s->format != format) {
2014 ret = build_vlc(&s->vlc[0], l_y_yry10i, 1024);
2015 ret |= build_vlc(&s->vlc[1], l_u_yry10i, 1024);
2016 }
2017 break;
2018 case MKTAG('C', 'A', '2', 'p'):
2019 avctx->pix_fmt = AV_PIX_FMT_YUVA422P10;
2020 s->decode_frame = decode_ca2p;
2021 if (s->format != format) {
2022 ret = build_vlc(&s->vlc[0], l_y_yry10, 1024);
2023 ret |= build_vlc(&s->vlc[1], l_u_yry10, 1024);
2024 }
2025 break;
2026 case MKTAG('C', 'A', '2', 'i'):
2027 avctx->pix_fmt = AV_PIX_FMT_YUVA422P10;
2028 s->decode_frame = decode_ca2i;
2029 if (s->format != format) {
2030 ret = build_vlc(&s->vlc[0], l_y_yry10i, 1024);
2031 ret |= build_vlc(&s->vlc[1], l_u_yry10i, 1024);
2032 }
2033 break;
2034 default:
2035 avpriv_request_sample(avctx, "unsupported format: 0x%X", format);
2036 return AVERROR_PATCHWELCOME;
2037 }
2038
2039 if (avpkt->size < 20 + avctx->width * avctx->height / 16) {
2040 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
2041 return AVERROR_INVALIDDATA;
2042 }
2043
2044 if (s->format != format) {
2045 if (ret < 0)
2046 return ret;
2047 s->format = format;
2048 }
2049
2050 p->pict_type = AV_PICTURE_TYPE_I;
2051 p->key_frame = 1;
2052
2053 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2054 return ret;
2055
2056 if ((ret = init_get_bits8(&gb, avpkt->data + 20, avpkt->size - 20)) < 0)
2057 return ret;
2058
2059 s->decode_frame(avctx, p, &gb);
2060
2061 *got_frame = 1;
2062
2063 return avpkt->size;
2064 }
2065
decode_end(AVCodecContext * avctx)2066 static av_cold int decode_end(AVCodecContext *avctx)
2067 {
2068 SheerVideoContext *s = avctx->priv_data;
2069
2070 ff_free_vlc(&s->vlc[0]);
2071 ff_free_vlc(&s->vlc[1]);
2072
2073 return 0;
2074 }
2075
2076 AVCodec ff_sheervideo_decoder = {
2077 .name = "sheervideo",
2078 .long_name = NULL_IF_CONFIG_SMALL("BitJazz SheerVideo"),
2079 .type = AVMEDIA_TYPE_VIDEO,
2080 .id = AV_CODEC_ID_SHEERVIDEO,
2081 .priv_data_size = sizeof(SheerVideoContext),
2082 .close = decode_end,
2083 .decode = decode_frame,
2084 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
2085 };
2086