git.sesse.net Git - ffmpeg/blob - libavcodec/sheervideo.c

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