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

   1 /*
   2  * Resolume DXV decoder
   3  * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
   4  * Copyright (C) 2018 Paul B Mahol
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include <stdint.h>
  24
  25 #include "libavutil/imgutils.h"
  26
  27 #include "mathops.h"
  28 #include "avcodec.h"
  29 #include "bytestream.h"
  30 #include "internal.h"
  31 #include "lzf.h"
  32 #include "texturedsp.h"
  33 #include "thread.h"
  34
  35 typedef struct DXVContext {
  36     TextureDSPContext texdsp;
  37     GetByteContext gbc;
  38
  39     uint8_t *tex_data;   // Compressed texture
  40     uint8_t *ctex_data;  // Compressed texture
  41     int tex_rat;         // Compression ratio
  42     int tex_step;        // Distance between blocks
  43     int ctex_step;       // Distance between blocks
  44     int64_t tex_size;    // Texture size
  45     int64_t ctex_size;   // Texture size
  46
  47     /* Optimal number of slices for parallel decoding */
  48     int slice_count;
  49
  50     uint8_t *op_data[4]; // Opcodes
  51     int64_t op_size[4];  // Opcodes size
  52
  53     int texture_block_w;
  54     int texture_block_h;
  55
  56     int ctexture_block_w;
  57     int ctexture_block_h;
  58
  59     /* Pointer to the selected decompression function */
  60     int (*tex_funct)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block);
  61     int (*tex_funct_planar[2])(uint8_t *plane0, ptrdiff_t stride0,
  62                                uint8_t *plane1, ptrdiff_t stride1,
  63                                const uint8_t *block);
  64 } DXVContext;
  65
  66 static void decompress_indices(uint8_t *dst, const uint8_t *src)
  67 {
  68     int block, i;
  69
  70     for (block = 0; block < 2; block++) {
  71         int tmp = AV_RL24(src);
  72
  73         /* Unpack 8x3 bit from last 3 byte block */
  74         for (i = 0; i < 8; i++)
  75             dst[i] = (tmp >> (i * 3)) & 0x7;
  76
  77         src += 3;
  78         dst += 8;
  79     }
  80 }
  81
  82 static int extract_component(int yo0, int yo1, int code)
  83 {
  84     int yo;
  85
  86     if (yo0 == yo1) {
  87         yo = yo0;
  88     } else if (code == 0) {
  89         yo = yo0;
  90     } else if (code == 1) {
  91         yo = yo1;
  92     } else {
  93         if (yo0 > yo1) {
  94             yo = (uint8_t) (((8 - code) * yo0 +
  95                              (code - 1) * yo1) / 7);
  96         } else {
  97             if (code == 6) {
  98                 yo = 0;
  99             } else if (code == 7) {
 100                 yo = 255;
 101             } else {
 102                 yo = (uint8_t) (((6 - code) * yo0 +
 103                                  (code - 1) * yo1) / 5);
 104             }
 105         }
 106     }
 107
 108     return yo;
 109 }
 110
 111 static int cocg_block(uint8_t *plane0, ptrdiff_t stride0,
 112                       uint8_t *plane1, ptrdiff_t stride1,
 113                       const uint8_t *block)
 114 {
 115     uint8_t co_indices[16];
 116     uint8_t cg_indices[16];
 117     uint8_t co0 = *(block);
 118     uint8_t co1 = *(block + 1);
 119     uint8_t cg0 = *(block + 8);
 120     uint8_t cg1 = *(block + 9);
 121     int x, y;
 122
 123     decompress_indices(co_indices, block + 2);
 124     decompress_indices(cg_indices, block + 10);
 125
 126     for (y = 0; y < 4; y++) {
 127         for (x = 0; x < 4; x++) {
 128             int co_code = co_indices[x + y * 4];
 129             int cg_code = cg_indices[x + y * 4];
 130
 131             plane0[x] = extract_component(cg0, cg1, cg_code);
 132             plane1[x] = extract_component(co0, co1, co_code);
 133         }
 134         plane0 += stride0;
 135         plane1 += stride1;
 136     }
 137
 138     return 16;
 139 }
 140
 141 static void yao_subblock(uint8_t *dst, uint8_t *yo_indices,
 142                         ptrdiff_t stride, const uint8_t *block)
 143 {
 144     uint8_t yo0 = *(block);
 145     uint8_t yo1 = *(block + 1);
 146     int x, y;
 147
 148     decompress_indices(yo_indices, block + 2);
 149
 150     for (y = 0; y < 4; y++) {
 151         for (x = 0; x < 4; x++) {
 152             int yo_code = yo_indices[x + y * 4];
 153
 154             dst[x] = extract_component(yo0, yo1, yo_code);
 155         }
 156         dst += stride;
 157     }
 158 }
 159
 160 static int yo_block(uint8_t *dst, ptrdiff_t stride,
 161                     uint8_t *unused0, ptrdiff_t unused1,
 162                     const uint8_t *block)
 163 {
 164     uint8_t yo_indices[16];
 165
 166     yao_subblock(dst,      yo_indices, stride, block);
 167     yao_subblock(dst + 4,  yo_indices, stride, block + 8);
 168     yao_subblock(dst + 8,  yo_indices, stride, block + 16);
 169     yao_subblock(dst + 12, yo_indices, stride, block + 24);
 170
 171     return 32;
 172 }
 173
 174 static int yao_block(uint8_t *plane0, ptrdiff_t stride0,
 175                      uint8_t *plane3, ptrdiff_t stride1,
 176                      const uint8_t *block)
 177 {
 178     uint8_t yo_indices[16];
 179     uint8_t a_indices[16];
 180
 181     yao_subblock(plane0,      yo_indices, stride0, block);
 182     yao_subblock(plane3,      a_indices,  stride1, block + 8);
 183     yao_subblock(plane0 + 4,  yo_indices, stride0, block + 16);
 184     yao_subblock(plane3 + 4,  a_indices,  stride1, block + 24);
 185     yao_subblock(plane0 + 8,  yo_indices, stride0, block + 32);
 186     yao_subblock(plane3 + 8,  a_indices,  stride1, block + 40);
 187     yao_subblock(plane0 + 12, yo_indices, stride0, block + 48);
 188     yao_subblock(plane3 + 12, a_indices,  stride1, block + 56);
 189
 190     return 64;
 191 }
 192
 193 static int decompress_texture_thread(AVCodecContext *avctx, void *arg,
 194                                      int slice, int thread_nb)
 195 {
 196     DXVContext *ctx = avctx->priv_data;
 197     AVFrame *frame = arg;
 198     const uint8_t *d = ctx->tex_data;
 199     int w_block = avctx->coded_width / ctx->texture_block_w;
 200     int h_block = avctx->coded_height / ctx->texture_block_h;
 201     int x, y;
 202     int start_slice, end_slice;
 203
 204     start_slice = h_block * slice / ctx->slice_count;
 205     end_slice = h_block * (slice + 1) / ctx->slice_count;
 206
 207     if (ctx->tex_funct) {
 208         for (y = start_slice; y < end_slice; y++) {
 209             uint8_t *p = frame->data[0] + y * frame->linesize[0] * ctx->texture_block_h;
 210             int off = y * w_block;
 211             for (x = 0; x < w_block; x++) {
 212                 ctx->tex_funct(p + x * 4 * ctx->texture_block_w, frame->linesize[0],
 213                                d + (off + x) * ctx->tex_step);
 214             }
 215         }
 216     } else {
 217         const uint8_t *c = ctx->ctex_data;
 218
 219         for (y = start_slice; y < end_slice; y++) {
 220             uint8_t *p0 = frame->data[0] + y * frame->linesize[0] * ctx->texture_block_h;
 221             uint8_t *p3 = ctx->tex_step != 64 ? NULL : frame->data[3] + y * frame->linesize[3] * ctx->texture_block_h;
 222             int off = y * w_block;
 223             for (x = 0; x < w_block; x++) {
 224                 ctx->tex_funct_planar[0](p0 + x * ctx->texture_block_w, frame->linesize[0],
 225                                          p3 != NULL ? p3 + x * ctx->texture_block_w : NULL, frame->linesize[3],
 226                                          d + (off + x) * ctx->tex_step);
 227             }
 228         }
 229
 230         w_block = (avctx->coded_width / 2) / ctx->ctexture_block_w;
 231         h_block = (avctx->coded_height / 2) / ctx->ctexture_block_h;
 232         start_slice = h_block * slice / ctx->slice_count;
 233         end_slice = h_block * (slice + 1) / ctx->slice_count;
 234
 235         for (y = start_slice; y < end_slice; y++) {
 236             uint8_t *p0 = frame->data[1] + y * frame->linesize[1] * ctx->ctexture_block_h;
 237             uint8_t *p1 = frame->data[2] + y * frame->linesize[2] * ctx->ctexture_block_h;
 238             int off = y * w_block;
 239             for (x = 0; x < w_block; x++) {
 240                 ctx->tex_funct_planar[1](p0 + x * ctx->ctexture_block_w, frame->linesize[1],
 241                                          p1 + x * ctx->ctexture_block_w, frame->linesize[2],
 242                                          c + (off + x) * ctx->ctex_step);
 243             }
 244         }
 245     }
 246
 247     return 0;
 248 }
 249
 250 /* This scheme addresses already decoded elements depending on 2-bit status:
 251  *   0 -> copy new element
 252  *   1 -> copy one element from position -x
 253  *   2 -> copy one element from position -(get_byte() + 2) * x
 254  *   3 -> copy one element from position -(get_16le() + 0x102) * x
 255  * x is always 2 for dxt1 and 4 for dxt5. */
 256 #define CHECKPOINT(x)                                                         \
 257     do {                                                                      \
 258         if (state == 0) {                                                     \
 259             value = bytestream2_get_le32(gbc);                                \
 260             state = 16;                                                       \
 261         }                                                                     \
 262         op = value & 0x3;                                                     \
 263         value >>= 2;                                                          \
 264         state--;                                                              \
 265         switch (op) {                                                         \
 266         case 1:                                                               \
 267             idx = x;                                                          \
 268             break;                                                            \
 269         case 2:                                                               \
 270             idx = (bytestream2_get_byte(gbc) + 2) * x;                        \
 271             if (idx > pos) {                                                  \
 272                 av_log(avctx, AV_LOG_ERROR, "idx %d > %d\n", idx, pos);       \
 273                 return AVERROR_INVALIDDATA;                                   \
 274             }                                                                 \
 275             break;                                                            \
 276         case 3:                                                               \
 277             idx = (bytestream2_get_le16(gbc) + 0x102) * x;                    \
 278             if (idx > pos) {                                                  \
 279                 av_log(avctx, AV_LOG_ERROR, "idx %d > %d\n", idx, pos);       \
 280                 return AVERROR_INVALIDDATA;                                   \
 281             }                                                                 \
 282             break;                                                            \
 283         }                                                                     \
 284     } while(0)
 285
 286 static int dxv_decompress_dxt1(AVCodecContext *avctx)
 287 {
 288     DXVContext *ctx = avctx->priv_data;
 289     GetByteContext *gbc = &ctx->gbc;
 290     uint32_t value, prev, op;
 291     int idx = 0, state = 0;
 292     int pos = 2;
 293
 294     /* Copy the first two elements */
 295     AV_WL32(ctx->tex_data, bytestream2_get_le32(gbc));
 296     AV_WL32(ctx->tex_data + 4, bytestream2_get_le32(gbc));
 297
 298     /* Process input until the whole texture has been filled */
 299     while (pos + 2 <= ctx->tex_size / 4) {
 300         CHECKPOINT(2);
 301
 302         /* Copy two elements from a previous offset or from the input buffer */
 303         if (op) {
 304             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 305             AV_WL32(ctx->tex_data + 4 * pos, prev);
 306             pos++;
 307
 308             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 309             AV_WL32(ctx->tex_data + 4 * pos, prev);
 310             pos++;
 311         } else {
 312             CHECKPOINT(2);
 313
 314             if (op)
 315                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 316             else
 317                 prev = bytestream2_get_le32(gbc);
 318             AV_WL32(ctx->tex_data + 4 * pos, prev);
 319             pos++;
 320
 321             CHECKPOINT(2);
 322
 323             if (op)
 324                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 325             else
 326                 prev = bytestream2_get_le32(gbc);
 327             AV_WL32(ctx->tex_data + 4 * pos, prev);
 328             pos++;
 329         }
 330     }
 331
 332     return 0;
 333 }
 334
 335 typedef struct OpcodeTable {
 336     int16_t next;
 337     uint8_t val1;
 338     uint8_t val2;
 339 } OpcodeTable;
 340
 341 static int fill_ltable(GetByteContext *gb, uint32_t *table, int *nb_elements)
 342 {
 343     unsigned half = 512, bits = 1023, left = 1024, input, mask;
 344     int value, counter = 0, rshift = 10, lshift = 30;
 345
 346     mask = bytestream2_get_le32(gb) >> 2;
 347     while (left) {
 348         if (counter >= 256)
 349             return AVERROR_INVALIDDATA;
 350         value = bits & mask;
 351         left -= bits & mask;
 352         mask >>= rshift;
 353         lshift -= rshift;
 354         table[counter++] = value;
 355         if (lshift < 16) {
 356             if (bytestream2_get_bytes_left(gb) <= 0)
 357                 return AVERROR_INVALIDDATA;
 358
 359             input = bytestream2_get_le16(gb);
 360             mask += input << lshift;
 361             lshift += 16;
 362         }
 363         if (left < half) {
 364             half >>= 1;
 365             bits >>= 1;
 366             rshift--;
 367         }
 368     }
 369
 370     for (; !table[counter - 1]; counter--)
 371         if (counter <= 0)
 372             return AVERROR_INVALIDDATA;
 373
 374     *nb_elements = counter;
 375
 376     if (counter < 256)
 377         memset(&table[counter], 0, 4 * (256 - counter));
 378
 379     if (lshift >= 16)
 380         bytestream2_seek(gb, -2, SEEK_CUR);
 381
 382     return 0;
 383 }
 384
 385 static int fill_optable(unsigned *table0, OpcodeTable *table1, int nb_elements)
 386 {
 387     unsigned table2[256] = { 0 };
 388     unsigned x = 0;
 389     int val0, val1, i, j = 2, k = 0;
 390
 391     table2[0] = table0[0];
 392     for (i = 0; i < nb_elements - 1; i++, table2[i] = val0) {
 393         val0 = table0[i + 1] + table2[i];
 394     }
 395
 396     if (!table2[0]) {
 397         do {
 398             k++;
 399         } while (!table2[k]);
 400     }
 401
 402     j = 2;
 403     for (i = 1024; i > 0; i--) {
 404         for (table1[x].val1 = k; k < 256 && j > table2[k]; k++);
 405         x = (x - 383) & 0x3FF;
 406         j++;
 407     }
 408
 409     if (nb_elements > 0)
 410         memcpy(&table2[0], table0, 4 * nb_elements);
 411
 412     for (i = 0; i < 1024; i++) {
 413         val0 = table1[i].val1;
 414         val1 = table2[val0];
 415         table2[val0]++;
 416         x = 31 - ff_clz(val1);
 417         if (x > 10)
 418             return AVERROR_INVALIDDATA;
 419         table1[i].val2 = 10 - x;
 420         table1[i].next = (val1 << table1[i].val2) - 1024;
 421     }
 422
 423     return 0;
 424 }
 425
 426 static int get_opcodes(GetByteContext *gb, uint32_t *table, uint8_t *dst, int op_size, int nb_elements)
 427 {
 428     OpcodeTable optable[1024];
 429     int sum, x, val, lshift, rshift, ret, size_in_bits, i, idx;
 430     unsigned endoffset, newoffset, offset;
 431     unsigned next;
 432     uint8_t *src = (uint8_t *)gb->buffer;
 433
 434     ret = fill_optable(table, optable, nb_elements);
 435     if (ret < 0)
 436         return ret;
 437
 438     size_in_bits = bytestream2_get_le32(gb);
 439     endoffset = ((size_in_bits + 7) >> 3) - 4;
 440     if (endoffset <= 0 || bytestream2_get_bytes_left(gb) < endoffset)
 441         return AVERROR_INVALIDDATA;
 442
 443     offset = endoffset;
 444     next = AV_RL32(src + endoffset);
 445     rshift = (((size_in_bits & 0xFF) - 1) & 7) + 15;
 446     lshift = 32 - rshift;
 447     idx = (next >> rshift) & 0x3FF;
 448     for (i = 0; i < op_size; i++) {
 449         dst[i] = optable[idx].val1;
 450         val = optable[idx].val2;
 451         sum = val + lshift;
 452         x = (next << lshift) >> 1 >> (31 - val);
 453         newoffset = offset - (sum >> 3);
 454         lshift = sum & 7;
 455         idx = x + optable[idx].next;
 456         offset = newoffset;
 457         if (offset > endoffset)
 458             return AVERROR_INVALIDDATA;
 459         next = AV_RL32(src + offset);
 460     }
 461
 462     bytestream2_skip(gb, (size_in_bits + 7 >> 3) - 4);
 463
 464     return 0;
 465 }
 466
 467 static int dxv_decompress_opcodes(GetByteContext *gb, void *dstp, size_t op_size)
 468 {
 469     int pos = bytestream2_tell(gb);
 470     int flag = bytestream2_peek_byte(gb);
 471
 472     if ((flag & 3) == 0) {
 473         bytestream2_skip(gb, 1);
 474         bytestream2_get_buffer(gb, dstp, op_size);
 475     } else if ((flag & 3) == 1) {
 476         bytestream2_skip(gb, 1);
 477         memset(dstp, bytestream2_get_byte(gb), op_size);
 478     } else {
 479         uint32_t table[256];
 480         int ret, elements = 0;
 481
 482         ret = fill_ltable(gb, table, &elements);
 483         if (ret < 0)
 484             return ret;
 485         ret = get_opcodes(gb, table, dstp, op_size, elements);
 486         if (ret < 0)
 487             return ret;
 488     }
 489     return bytestream2_tell(gb) - pos;
 490 }
 491
 492 static int dxv_decompress_cgo(DXVContext *ctx, GetByteContext *gb,
 493                               uint8_t *tex_data, int tex_size,
 494                               uint8_t *op_data, int *oindex,
 495                               int op_size,
 496                               uint8_t **dstp, int *statep,
 497                               uint8_t **tab0, uint8_t **tab1,
 498                               int offset)
 499 {
 500     uint8_t *dst = *dstp;
 501     uint8_t *tptr0, *tptr1, *tptr3;
 502     int oi = *oindex;
 503     int state = *statep;
 504     int opcode, v, vv;
 505
 506     if (state <= 0) {
 507         if (oi >= op_size)
 508             return AVERROR_INVALIDDATA;
 509         opcode = op_data[oi++];
 510         if (!opcode) {
 511             v = bytestream2_get_byte(gb);
 512             if (v == 255) {
 513                 do {
 514                     if (bytestream2_get_bytes_left(gb) <= 0)
 515                         return AVERROR_INVALIDDATA;
 516                     opcode = bytestream2_get_le16(gb);
 517                     v += opcode;
 518                 } while (opcode == 0xFFFF);
 519             }
 520             AV_WL32(dst, AV_RL32(dst - (8 + offset)));
 521             AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
 522             state = v + 4;
 523             goto done;
 524         }
 525
 526         switch (opcode) {
 527         case 1:
 528             AV_WL32(dst, AV_RL32(dst - (8 + offset)));
 529             AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
 530             break;
 531         case 2:
 532             vv = (8 + offset) * (bytestream2_get_le16(gb) + 1);
 533             if (vv < 0 || vv > dst - tex_data)
 534                 return AVERROR_INVALIDDATA;
 535             tptr0 = dst - vv;
 536             v = AV_RL32(tptr0);
 537             AV_WL32(dst, AV_RL32(tptr0));
 538             AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
 539             tab0[0x9E3779B1 * (uint16_t)v >> 24] = dst;
 540             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 541             break;
 542         case 3:
 543             AV_WL32(dst, bytestream2_get_le32(gb));
 544             AV_WL32(dst + 4, bytestream2_get_le32(gb));
 545             tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 546             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 547             break;
 548         case 4:
 549             tptr3 = tab1[bytestream2_get_byte(gb)];
 550             if (!tptr3)
 551                 return AVERROR_INVALIDDATA;
 552             AV_WL16(dst, bytestream2_get_le16(gb));
 553             AV_WL16(dst + 2, AV_RL16(tptr3));
 554             dst[4] = tptr3[2];
 555             AV_WL16(dst + 5, bytestream2_get_le16(gb));
 556             dst[7] = bytestream2_get_byte(gb);
 557             tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 558             break;
 559         case 5:
 560             tptr3 = tab1[bytestream2_get_byte(gb)];
 561             if (!tptr3)
 562                 return AVERROR_INVALIDDATA;
 563             AV_WL16(dst, bytestream2_get_le16(gb));
 564             AV_WL16(dst + 2, bytestream2_get_le16(gb));
 565             dst[4] = bytestream2_get_byte(gb);
 566             AV_WL16(dst + 5, AV_RL16(tptr3));
 567             dst[7] = tptr3[2];
 568             tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 569             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 570             break;
 571         case 6:
 572             tptr0 = tab1[bytestream2_get_byte(gb)];
 573             if (!tptr0)
 574                 return AVERROR_INVALIDDATA;
 575             tptr1 = tab1[bytestream2_get_byte(gb)];
 576             if (!tptr1)
 577                 return AVERROR_INVALIDDATA;
 578             AV_WL16(dst, bytestream2_get_le16(gb));
 579             AV_WL16(dst + 2, AV_RL16(tptr0));
 580             dst[4] = tptr0[2];
 581             AV_WL16(dst + 5, AV_RL16(tptr1));
 582             dst[7] = tptr1[2];
 583             tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 584             break;
 585         case 7:
 586             v = (8 + offset) * (bytestream2_get_le16(gb) + 1);
 587             if (v < 0 || v > dst - tex_data)
 588                 return AVERROR_INVALIDDATA;
 589             tptr0 = dst - v;
 590             AV_WL16(dst, bytestream2_get_le16(gb));
 591             AV_WL16(dst + 2, AV_RL16(tptr0 + 2));
 592             AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
 593             tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 594             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 595             break;
 596         case 8:
 597             tptr1 = tab0[bytestream2_get_byte(gb)];
 598             if (!tptr1)
 599                 return AVERROR_INVALIDDATA;
 600             AV_WL16(dst, AV_RL16(tptr1));
 601             AV_WL16(dst + 2, bytestream2_get_le16(gb));
 602             AV_WL32(dst + 4, bytestream2_get_le32(gb));
 603             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 604             break;
 605         case 9:
 606             tptr1 = tab0[bytestream2_get_byte(gb)];
 607             if (!tptr1)
 608                 return AVERROR_INVALIDDATA;
 609             tptr3 = tab1[bytestream2_get_byte(gb)];
 610             if (!tptr3)
 611                 return AVERROR_INVALIDDATA;
 612             AV_WL16(dst, AV_RL16(tptr1));
 613             AV_WL16(dst + 2, AV_RL16(tptr3));
 614             dst[4] = tptr3[2];
 615             AV_WL16(dst + 5, bytestream2_get_le16(gb));
 616             dst[7] = bytestream2_get_byte(gb);
 617             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 618             break;
 619         case 10:
 620             tptr1 = tab0[bytestream2_get_byte(gb)];
 621             if (!tptr1)
 622                 return AVERROR_INVALIDDATA;
 623             tptr3 = tab1[bytestream2_get_byte(gb)];
 624             if (!tptr3)
 625                 return AVERROR_INVALIDDATA;
 626             AV_WL16(dst, AV_RL16(tptr1));
 627             AV_WL16(dst + 2, bytestream2_get_le16(gb));
 628             dst[4] = bytestream2_get_byte(gb);
 629             AV_WL16(dst + 5, AV_RL16(tptr3));
 630             dst[7] = tptr3[2];
 631             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 632             break;
 633         case 11:
 634             tptr0 = tab0[bytestream2_get_byte(gb)];
 635             if (!tptr0)
 636                 return AVERROR_INVALIDDATA;
 637             tptr3 = tab1[bytestream2_get_byte(gb)];
 638             if (!tptr3)
 639                 return AVERROR_INVALIDDATA;
 640             tptr1 = tab1[bytestream2_get_byte(gb)];
 641             if (!tptr1)
 642                 return AVERROR_INVALIDDATA;
 643             AV_WL16(dst, AV_RL16(tptr0));
 644             AV_WL16(dst + 2, AV_RL16(tptr3));
 645             dst[4] = tptr3[2];
 646             AV_WL16(dst + 5, AV_RL16(tptr1));
 647             dst[7] = tptr1[2];
 648             break;
 649         case 12:
 650             tptr1 = tab0[bytestream2_get_byte(gb)];
 651             if (!tptr1)
 652                 return AVERROR_INVALIDDATA;
 653             v = (8 + offset) * (bytestream2_get_le16(gb) + 1);
 654             if (v < 0 || v > dst - tex_data)
 655                 return AVERROR_INVALIDDATA;
 656             tptr0 = dst - v;
 657             AV_WL16(dst, AV_RL16(tptr1));
 658             AV_WL16(dst + 2, AV_RL16(tptr0 + 2));
 659             AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
 660             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 661             break;
 662         case 13:
 663             AV_WL16(dst, AV_RL16(dst - (8 + offset)));
 664             AV_WL16(dst + 2, bytestream2_get_le16(gb));
 665             AV_WL32(dst + 4, bytestream2_get_le32(gb));
 666             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 667             break;
 668         case 14:
 669             tptr3 = tab1[bytestream2_get_byte(gb)];
 670             if (!tptr3)
 671                 return AVERROR_INVALIDDATA;
 672             AV_WL16(dst, AV_RL16(dst - (8 + offset)));
 673             AV_WL16(dst + 2, AV_RL16(tptr3));
 674             dst[4] = tptr3[2];
 675             AV_WL16(dst + 5, bytestream2_get_le16(gb));
 676             dst[7] = bytestream2_get_byte(gb);
 677             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 678             break;
 679         case 15:
 680             tptr3 = tab1[bytestream2_get_byte(gb)];
 681             if (!tptr3)
 682                 return AVERROR_INVALIDDATA;
 683             AV_WL16(dst, AV_RL16(dst - (8 + offset)));
 684             AV_WL16(dst + 2, bytestream2_get_le16(gb));
 685             dst[4] = bytestream2_get_byte(gb);
 686             AV_WL16(dst + 5, AV_RL16(tptr3));
 687             dst[7] = tptr3[2];
 688             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 689             break;
 690         case 16:
 691             tptr3 = tab1[bytestream2_get_byte(gb)];
 692             if (!tptr3)
 693                 return AVERROR_INVALIDDATA;
 694             tptr1 = tab1[bytestream2_get_byte(gb)];
 695             if (!tptr1)
 696                 return AVERROR_INVALIDDATA;
 697             AV_WL16(dst, AV_RL16(dst - (8 + offset)));
 698             AV_WL16(dst + 2, AV_RL16(tptr3));
 699             dst[4] = tptr3[2];
 700             AV_WL16(dst + 5, AV_RL16(tptr1));
 701             dst[7] = tptr1[2];
 702             break;
 703         case 17:
 704             v = (8 + offset) * (bytestream2_get_le16(gb) + 1);
 705             if (v < 0 || v > dst - tex_data)
 706                 return AVERROR_INVALIDDATA;
 707             AV_WL16(dst, AV_RL16(dst - (8 + offset)));
 708             AV_WL16(dst + 2, AV_RL16(&dst[-v + 2]));
 709             AV_WL32(dst + 4, AV_RL32(&dst[-v + 4]));
 710             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 711             break;
 712         default:
 713             break;
 714         }
 715     } else {
 716 done:
 717         AV_WL32(dst, AV_RL32(dst - (8 + offset)));
 718         AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
 719         state--;
 720     }
 721     if (dst - tex_data + 8 > tex_size)
 722         return AVERROR_INVALIDDATA;
 723     dst += 8;
 724
 725     *oindex = oi;
 726     *dstp = dst;
 727     *statep = state;
 728
 729     return 0;
 730 }
 731
 732 static int dxv_decompress_cocg(DXVContext *ctx, GetByteContext *gb,
 733                                uint8_t *tex_data, int tex_size,
 734                                uint8_t *op_data0, uint8_t *op_data1,
 735                                int max_op_size0, int max_op_size1)
 736 {
 737     uint8_t *dst, *tab2[256] = { 0 }, *tab0[256] = { 0 }, *tab3[256] = { 0 }, *tab1[256] = { 0 };
 738     int op_offset = bytestream2_get_le32(gb);
 739     unsigned op_size0 = bytestream2_get_le32(gb);
 740     unsigned op_size1 = bytestream2_get_le32(gb);
 741     int data_start = bytestream2_tell(gb);
 742     int skip0, skip1, oi0 = 0, oi1 = 0;
 743     int ret, state0 = 0, state1 = 0;
 744
 745     dst = tex_data;
 746     bytestream2_skip(gb, op_offset - 12);
 747     if (op_size0 > max_op_size0)
 748         return AVERROR_INVALIDDATA;
 749     skip0 = dxv_decompress_opcodes(gb, op_data0, op_size0);
 750     if (skip0 < 0)
 751         return skip0;
 752     bytestream2_seek(gb, data_start + op_offset + skip0 - 12, SEEK_SET);
 753     if (op_size1 > max_op_size1)
 754         return AVERROR_INVALIDDATA;
 755     skip1 = dxv_decompress_opcodes(gb, op_data1, op_size1);
 756     if (skip1 < 0)
 757         return skip1;
 758     bytestream2_seek(gb, data_start, SEEK_SET);
 759
 760     AV_WL32(dst, bytestream2_get_le32(gb));
 761     AV_WL32(dst + 4, bytestream2_get_le32(gb));
 762     AV_WL32(dst + 8, bytestream2_get_le32(gb));
 763     AV_WL32(dst + 12, bytestream2_get_le32(gb));
 764
 765     tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 766     tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFF) >> 24] = dst + 2;
 767     tab2[0x9E3779B1 * AV_RL16(dst + 8) >> 24] = dst + 8;
 768     tab3[0x9E3779B1 * (AV_RL32(dst + 10) & 0xFFFFFF) >> 24] = dst + 10;
 769     dst += 16;
 770     while (dst + 10 < tex_data + tex_size) {
 771         ret = dxv_decompress_cgo(ctx, gb, tex_data, tex_size, op_data0, &oi0, op_size0,
 772                                  &dst, &state0, tab0, tab1, 8);
 773         if (ret < 0)
 774             return ret;
 775         ret = dxv_decompress_cgo(ctx, gb, tex_data, tex_size, op_data1, &oi1, op_size1,
 776                                  &dst, &state1, tab2, tab3, 8);
 777         if (ret < 0)
 778             return ret;
 779     }
 780
 781     bytestream2_seek(gb, data_start + op_offset + skip0 + skip1 - 12, SEEK_SET);
 782
 783     return 0;
 784 }
 785
 786 static int dxv_decompress_yo(DXVContext *ctx, GetByteContext *gb,
 787                              uint8_t *tex_data, int tex_size,
 788                              uint8_t *op_data, int max_op_size)
 789 {
 790     int op_offset = bytestream2_get_le32(gb);
 791     unsigned op_size = bytestream2_get_le32(gb);
 792     int data_start = bytestream2_tell(gb);
 793     uint8_t *dst, *table0[256] = { 0 }, *table1[256] = { 0 };
 794     int ret, state = 0, skip, oi = 0, v, vv;
 795
 796     dst = tex_data;
 797     bytestream2_skip(gb, op_offset - 8);
 798     if (op_size > max_op_size)
 799         return AVERROR_INVALIDDATA;
 800     skip = dxv_decompress_opcodes(gb, op_data, op_size);
 801     if (skip < 0)
 802         return skip;
 803     bytestream2_seek(gb, data_start, SEEK_SET);
 804
 805     v = bytestream2_get_le32(gb);
 806     AV_WL32(dst, v);
 807     vv = bytestream2_get_le32(gb);
 808     table0[0x9E3779B1 * (uint16_t)v >> 24] = dst;
 809     AV_WL32(dst + 4, vv);
 810     table1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFF) >> 24] = dst + 2;
 811     dst += 8;
 812
 813     while (dst < tex_data + tex_size) {
 814         ret = dxv_decompress_cgo(ctx, gb, tex_data, tex_size, op_data, &oi, op_size,
 815                                  &dst, &state, table0, table1, 0);
 816         if (ret < 0)
 817             return ret;
 818     }
 819
 820     bytestream2_seek(gb, data_start + op_offset + skip - 8, SEEK_SET);
 821
 822     return 0;
 823 }
 824
 825 static int dxv_decompress_ycg6(AVCodecContext *avctx)
 826 {
 827     DXVContext *ctx = avctx->priv_data;
 828     GetByteContext *gb = &ctx->gbc;
 829     int ret;
 830
 831     ret = dxv_decompress_yo(ctx, gb, ctx->tex_data, ctx->tex_size,
 832                             ctx->op_data[0], ctx->op_size[0]);
 833     if (ret < 0)
 834         return ret;
 835
 836     return dxv_decompress_cocg(ctx, gb, ctx->ctex_data, ctx->ctex_size,
 837                                ctx->op_data[1], ctx->op_data[2],
 838                                ctx->op_size[1], ctx->op_size[2]);
 839 }
 840
 841 static int dxv_decompress_yg10(AVCodecContext *avctx)
 842 {
 843     DXVContext *ctx = avctx->priv_data;
 844     GetByteContext *gb = &ctx->gbc;
 845     int ret;
 846
 847     ret = dxv_decompress_cocg(ctx, gb, ctx->tex_data, ctx->tex_size,
 848                               ctx->op_data[0], ctx->op_data[3],
 849                               ctx->op_size[0], ctx->op_size[3]);
 850     if (ret < 0)
 851         return ret;
 852
 853     return dxv_decompress_cocg(ctx, gb, ctx->ctex_data, ctx->ctex_size,
 854                                ctx->op_data[1], ctx->op_data[2],
 855                                ctx->op_size[1], ctx->op_size[2]);
 856 }
 857
 858 static int dxv_decompress_dxt5(AVCodecContext *avctx)
 859 {
 860     DXVContext *ctx = avctx->priv_data;
 861     GetByteContext *gbc = &ctx->gbc;
 862     uint32_t value, op;
 863     int idx, prev, state = 0;
 864     int pos = 4;
 865     int run = 0;
 866     int probe, check;
 867
 868     /* Copy the first four elements */
 869     AV_WL32(ctx->tex_data +  0, bytestream2_get_le32(gbc));
 870     AV_WL32(ctx->tex_data +  4, bytestream2_get_le32(gbc));
 871     AV_WL32(ctx->tex_data +  8, bytestream2_get_le32(gbc));
 872     AV_WL32(ctx->tex_data + 12, bytestream2_get_le32(gbc));
 873
 874     /* Process input until the whole texture has been filled */
 875     while (pos + 2 <= ctx->tex_size / 4) {
 876         if (run) {
 877             run--;
 878
 879             prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 880             AV_WL32(ctx->tex_data + 4 * pos, prev);
 881             pos++;
 882             prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 883             AV_WL32(ctx->tex_data + 4 * pos, prev);
 884             pos++;
 885         } else {
 886             if (bytestream2_get_bytes_left(gbc) < 1)
 887                 return AVERROR_INVALIDDATA;
 888             if (state == 0) {
 889                 value = bytestream2_get_le32(gbc);
 890                 state = 16;
 891             }
 892             op = value & 0x3;
 893             value >>= 2;
 894             state--;
 895
 896             switch (op) {
 897             case 0:
 898                 /* Long copy */
 899                 check = bytestream2_get_byte(gbc) + 1;
 900                 if (check == 256) {
 901                     do {
 902                         probe = bytestream2_get_le16(gbc);
 903                         check += probe;
 904                     } while (probe == 0xFFFF);
 905                 }
 906                 while (check && pos + 4 <= ctx->tex_size / 4) {
 907                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 908                     AV_WL32(ctx->tex_data + 4 * pos, prev);
 909                     pos++;
 910
 911                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 912                     AV_WL32(ctx->tex_data + 4 * pos, prev);
 913                     pos++;
 914
 915                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 916                     AV_WL32(ctx->tex_data + 4 * pos, prev);
 917                     pos++;
 918
 919                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 920                     AV_WL32(ctx->tex_data + 4 * pos, prev);
 921                     pos++;
 922
 923                     check--;
 924                 }
 925
 926                 /* Restart (or exit) the loop */
 927                 continue;
 928                 break;
 929             case 1:
 930                 /* Load new run value */
 931                 run = bytestream2_get_byte(gbc);
 932                 if (run == 255) {
 933                     do {
 934                         probe = bytestream2_get_le16(gbc);
 935                         run += probe;
 936                     } while (probe == 0xFFFF);
 937                 }
 938
 939                 /* Copy two dwords from previous data */
 940                 prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 941                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 942                 pos++;
 943
 944                 prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 945                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 946                 pos++;
 947                 break;
 948             case 2:
 949                 /* Copy two dwords from a previous index */
 950                 idx = 8 + bytestream2_get_le16(gbc);
 951                 if (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4)
 952                     return AVERROR_INVALIDDATA;
 953                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 954                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 955                 pos++;
 956
 957                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 958                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 959                 pos++;
 960                 break;
 961             case 3:
 962                 /* Copy two dwords from input */
 963                 prev = bytestream2_get_le32(gbc);
 964                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 965                 pos++;
 966
 967                 prev = bytestream2_get_le32(gbc);
 968                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 969                 pos++;
 970                 break;
 971             }
 972         }
 973
 974         CHECKPOINT(4);
 975         if (pos + 2 > ctx->tex_size / 4)
 976             return AVERROR_INVALIDDATA;
 977
 978         /* Copy two elements from a previous offset or from the input buffer */
 979         if (op) {
 980             if (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4)
 981                 return AVERROR_INVALIDDATA;
 982             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 983             AV_WL32(ctx->tex_data + 4 * pos, prev);
 984             pos++;
 985
 986             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 987             AV_WL32(ctx->tex_data + 4 * pos, prev);
 988             pos++;
 989         } else {
 990             CHECKPOINT(4);
 991
 992             if (op && (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4))
 993                 return AVERROR_INVALIDDATA;
 994             if (op)
 995                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 996             else
 997                 prev = bytestream2_get_le32(gbc);
 998             AV_WL32(ctx->tex_data + 4 * pos, prev);
 999             pos++;
1000
1001             CHECKPOINT(4);
1002
1003             if (op)
1004                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
1005             else
1006                 prev = bytestream2_get_le32(gbc);
1007             AV_WL32(ctx->tex_data + 4 * pos, prev);
1008             pos++;
1009         }
1010     }
1011
1012     return 0;
1013 }
1014
1015 static int dxv_decompress_lzf(AVCodecContext *avctx)
1016 {
1017     DXVContext *ctx = avctx->priv_data;
1018     return ff_lzf_uncompress(&ctx->gbc, &ctx->tex_data, &ctx->tex_size);
1019 }
1020
1021 static int dxv_decompress_raw(AVCodecContext *avctx)
1022 {
1023     DXVContext *ctx = avctx->priv_data;
1024     GetByteContext *gbc = &ctx->gbc;
1025
1026     if (bytestream2_get_bytes_left(gbc) < ctx->tex_size)
1027         return AVERROR_INVALIDDATA;
1028
1029     bytestream2_get_buffer(gbc, ctx->tex_data, ctx->tex_size);
1030     return 0;
1031 }
1032
1033 static int dxv_decode(AVCodecContext *avctx, void *data,
1034                       int *got_frame, AVPacket *avpkt)
1035 {
1036     DXVContext *ctx = avctx->priv_data;
1037     ThreadFrame tframe;
1038     GetByteContext *gbc = &ctx->gbc;
1039     int (*decompress_tex)(AVCodecContext *avctx);
1040     const char *msgcomp, *msgtext;
1041     uint32_t tag;
1042     int version_major, version_minor = 0;
1043     int size = 0, old_type = 0;
1044     int ret;
1045
1046     bytestream2_init(gbc, avpkt->data, avpkt->size);
1047
1048     ctx->texture_block_h = 4;
1049     ctx->texture_block_w = 4;
1050
1051     avctx->pix_fmt = AV_PIX_FMT_RGBA;
1052     avctx->colorspace = AVCOL_SPC_RGB;
1053
1054     tag = bytestream2_get_le32(gbc);
1055     switch (tag) {
1056     case MKBETAG('D', 'X', 'T', '1'):
1057         decompress_tex = dxv_decompress_dxt1;
1058         ctx->tex_funct = ctx->texdsp.dxt1_block;
1059         ctx->tex_rat   = 8;
1060         ctx->tex_step  = 8;
1061         msgcomp = "DXTR1";
1062         msgtext = "DXT1";
1063         break;
1064     case MKBETAG('D', 'X', 'T', '5'):
1065         decompress_tex = dxv_decompress_dxt5;
1066         ctx->tex_funct = ctx->texdsp.dxt5_block;
1067         ctx->tex_rat   = 4;
1068         ctx->tex_step  = 16;
1069         msgcomp = "DXTR5";
1070         msgtext = "DXT5";
1071         break;
1072     case MKBETAG('Y', 'C', 'G', '6'):
1073         decompress_tex = dxv_decompress_ycg6;
1074         ctx->tex_funct_planar[0] = yo_block;
1075         ctx->tex_funct_planar[1] = cocg_block;
1076         ctx->tex_rat   = 8;
1077         ctx->tex_step  = 32;
1078         ctx->ctex_step = 16;
1079         msgcomp = "YOCOCG6";
1080         msgtext = "YCG6";
1081         ctx->ctex_size = avctx->coded_width * avctx->coded_height / 4;
1082         ctx->texture_block_h = 4;
1083         ctx->texture_block_w = 16;
1084         ctx->ctexture_block_h = 4;
1085         ctx->ctexture_block_w = 4;
1086         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
1087         avctx->colorspace = AVCOL_SPC_YCOCG;
1088         break;
1089     case MKBETAG('Y', 'G', '1', '0'):
1090         decompress_tex = dxv_decompress_yg10;
1091         ctx->tex_funct_planar[0] = yao_block;
1092         ctx->tex_funct_planar[1] = cocg_block;
1093         ctx->tex_rat   = 4;
1094         ctx->tex_step  = 64;
1095         ctx->ctex_step = 16;
1096         msgcomp = "YAOCOCG10";
1097         msgtext = "YG10";
1098         ctx->ctex_size = avctx->coded_width * avctx->coded_height / 4;
1099         ctx->texture_block_h = 4;
1100         ctx->texture_block_w = 16;
1101         ctx->ctexture_block_h = 4;
1102         ctx->ctexture_block_w = 4;
1103         avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
1104         avctx->colorspace = AVCOL_SPC_YCOCG;
1105         break;
1106     default:
1107         /* Old version does not have a real header, just size and type. */
1108         size = tag & 0x00FFFFFF;
1109         old_type = tag >> 24;
1110         version_major = (old_type & 0x0F) - 1;
1111
1112         if (old_type & 0x80) {
1113             msgcomp = "RAW";
1114             decompress_tex = dxv_decompress_raw;
1115         } else {
1116             msgcomp = "LZF";
1117             decompress_tex = dxv_decompress_lzf;
1118         }
1119
1120         if (old_type & 0x40) {
1121             msgtext = "DXT5";
1122
1123             ctx->tex_funct = ctx->texdsp.dxt5_block;
1124             ctx->tex_step  = 16;
1125         } else if (old_type & 0x20 || version_major == 1) {
1126             msgtext = "DXT1";
1127
1128             ctx->tex_funct = ctx->texdsp.dxt1_block;
1129             ctx->tex_step  = 8;
1130         } else {
1131             av_log(avctx, AV_LOG_ERROR, "Unsupported header (0x%08"PRIX32")\n.", tag);
1132             return AVERROR_INVALIDDATA;
1133         }
1134         ctx->tex_rat = 1;
1135         break;
1136     }
1137
1138     ctx->slice_count = av_clip(avctx->thread_count, 1,
1139                                avctx->coded_height / FFMAX(ctx->texture_block_h,
1140                                                            ctx->ctexture_block_h));
1141
1142     /* New header is 12 bytes long. */
1143     if (!old_type) {
1144         version_major = bytestream2_get_byte(gbc) - 1;
1145         version_minor = bytestream2_get_byte(gbc);
1146
1147         /* Encoder copies texture data when compression is not advantageous. */
1148         if (bytestream2_get_byte(gbc)) {
1149             msgcomp = "RAW";
1150             ctx->tex_rat = 1;
1151             decompress_tex = dxv_decompress_raw;
1152         }
1153
1154         bytestream2_skip(gbc, 1); // unknown
1155         size = bytestream2_get_le32(gbc);
1156     }
1157     av_log(avctx, AV_LOG_DEBUG,
1158            "%s compression with %s texture (version %d.%d)\n",
1159            msgcomp, msgtext, version_major, version_minor);
1160
1161     if (size != bytestream2_get_bytes_left(gbc)) {
1162         av_log(avctx, AV_LOG_ERROR,
1163                "Incomplete or invalid file (header %d, left %u).\n",
1164                size, bytestream2_get_bytes_left(gbc));
1165         return AVERROR_INVALIDDATA;
1166     }
1167
1168     ctx->tex_size = avctx->coded_width * avctx->coded_height * 4 / ctx->tex_rat;
1169     ret = av_reallocp(&ctx->tex_data, ctx->tex_size + AV_INPUT_BUFFER_PADDING_SIZE);
1170     if (ret < 0)
1171         return ret;
1172
1173     if (ctx->ctex_size) {
1174         int i;
1175
1176         ctx->op_size[0] = avctx->coded_width * avctx->coded_height / 16;
1177         ctx->op_size[1] = avctx->coded_width * avctx->coded_height / 32;
1178         ctx->op_size[2] = avctx->coded_width * avctx->coded_height / 32;
1179         ctx->op_size[3] = avctx->coded_width * avctx->coded_height / 16;
1180
1181         ret = av_reallocp(&ctx->ctex_data, ctx->ctex_size + AV_INPUT_BUFFER_PADDING_SIZE);
1182         if (ret < 0)
1183             return ret;
1184         for (i = 0; i < 4; i++) {
1185             ret = av_reallocp(&ctx->op_data[i], ctx->op_size[i]);
1186             if (ret < 0)
1187                 return ret;
1188         }
1189     }
1190
1191     /* Decompress texture out of the intermediate compression. */
1192     ret = decompress_tex(avctx);
1193     if (ret < 0)
1194         return ret;
1195
1196     tframe.f = data;
1197     ret = ff_thread_get_buffer(avctx, &tframe, 0);
1198     if (ret < 0)
1199         return ret;
1200
1201     /* Now decompress the texture with the standard functions. */
1202     avctx->execute2(avctx, decompress_texture_thread,
1203                     tframe.f, NULL, ctx->slice_count);
1204
1205     /* Frame is ready to be output. */
1206     tframe.f->pict_type = AV_PICTURE_TYPE_I;
1207     tframe.f->key_frame = 1;
1208     *got_frame = 1;
1209
1210     return avpkt->size;
1211 }
1212
1213 static int dxv_init(AVCodecContext *avctx)
1214 {
1215     DXVContext *ctx = avctx->priv_data;
1216     int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1217
1218     if (ret < 0) {
1219         av_log(avctx, AV_LOG_ERROR, "Invalid image size %dx%d.\n",
1220                avctx->width, avctx->height);
1221         return ret;
1222     }
1223
1224     /* Codec requires 16x16 alignment. */
1225     avctx->coded_width  = FFALIGN(avctx->width,  16);
1226     avctx->coded_height = FFALIGN(avctx->height, 16);
1227
1228     ff_texturedsp_init(&ctx->texdsp);
1229
1230     return 0;
1231 }
1232
1233 static int dxv_close(AVCodecContext *avctx)
1234 {
1235     DXVContext *ctx = avctx->priv_data;
1236
1237     av_freep(&ctx->tex_data);
1238     av_freep(&ctx->ctex_data);
1239     av_freep(&ctx->op_data[0]);
1240     av_freep(&ctx->op_data[1]);
1241     av_freep(&ctx->op_data[2]);
1242     av_freep(&ctx->op_data[3]);
1243
1244     return 0;
1245 }
1246
1247 AVCodec ff_dxv_decoder = {
1248     .name           = "dxv",
1249     .long_name      = NULL_IF_CONFIG_SMALL("Resolume DXV"),
1250     .type           = AVMEDIA_TYPE_VIDEO,
1251     .id             = AV_CODEC_ID_DXV,
1252     .init           = dxv_init,
1253     .decode         = dxv_decode,
1254     .close          = dxv_close,
1255     .priv_data_size = sizeof(DXVContext),
1256     .capabilities   = AV_CODEC_CAP_DR1 |
1257                       AV_CODEC_CAP_SLICE_THREADS |
1258                       AV_CODEC_CAP_FRAME_THREADS,
1259     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
1260                       FF_CODEC_CAP_INIT_CLEANUP,
1261 };