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