GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/sheervideo.c Lines: 0 1333 0.0 %
Date: 2020-08-14 10:39:37 Branches: 0 414 0.0 %

Line Branch Exec Source
1
/*
2
 * BitJazz SheerVideo decoder
3
 * Copyright (c) 2016 Paul B Mahol
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
#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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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, 12, count,
1799
                              bits,  sizeof(*bits),  sizeof(*bits),
1800
                              codes, sizeof(*codes), sizeof(*codes),
1801
                              syms,  sizeof(*syms),  sizeof(*syms), 0);
1802
}
1803
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
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
};