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