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             if (bytestream2_get_bytes_left(gbc) < 4)                          \
 260                 return AVERROR_INVALIDDATA;                                   \
 261             value = bytestream2_get_le32(gbc);                                \
 262             state = 16;                                                       \
 263         }                                                                     \
 264         op = value & 0x3;                                                     \
 265         value >>= 2;                                                          \
 266         state--;                                                              \
 267         switch (op) {                                                         \
 268         case 1:                                                               \
 269             idx = x;                                                          \
 270             break;                                                            \
 271         case 2:                                                               \
 272             idx = (bytestream2_get_byte(gbc) + 2) * x;                        \
 273             if (idx > pos) {                                                  \
 274                 av_log(avctx, AV_LOG_ERROR, "idx %d > %d\n", idx, pos);       \
 275                 return AVERROR_INVALIDDATA;                                   \
 276             }                                                                 \
 277             break;                                                            \
 278         case 3:                                                               \
 279             idx = (bytestream2_get_le16(gbc) + 0x102) * x;                    \
 280             if (idx > pos) {                                                  \
 281                 av_log(avctx, AV_LOG_ERROR, "idx %d > %d\n", idx, pos);       \
 282                 return AVERROR_INVALIDDATA;                                   \
 283             }                                                                 \
 284             break;                                                            \
 285         }                                                                     \
 286     } while(0)
 287
 288 static int dxv_decompress_dxt1(AVCodecContext *avctx)
 289 {
 290     DXVContext *ctx = avctx->priv_data;
 291     GetByteContext *gbc = &ctx->gbc;
 292     uint32_t value, prev, op;
 293     int idx = 0, state = 0;
 294     int pos = 2;
 295
 296     /* Copy the first two elements */
 297     AV_WL32(ctx->tex_data, bytestream2_get_le32(gbc));
 298     AV_WL32(ctx->tex_data + 4, bytestream2_get_le32(gbc));
 299
 300     /* Process input until the whole texture has been filled */
 301     while (pos + 2 <= ctx->tex_size / 4) {
 302         CHECKPOINT(2);
 303
 304         /* Copy two elements from a previous offset or from the input buffer */
 305         if (op) {
 306             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 307             AV_WL32(ctx->tex_data + 4 * pos, prev);
 308             pos++;
 309
 310             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 311             AV_WL32(ctx->tex_data + 4 * pos, prev);
 312             pos++;
 313         } else {
 314             CHECKPOINT(2);
 315
 316             if (op)
 317                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 318             else
 319                 prev = bytestream2_get_le32(gbc);
 320             AV_WL32(ctx->tex_data + 4 * pos, prev);
 321             pos++;
 322
 323             CHECKPOINT(2);
 324
 325             if (op)
 326                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 327             else
 328                 prev = bytestream2_get_le32(gbc);
 329             AV_WL32(ctx->tex_data + 4 * pos, prev);
 330             pos++;
 331         }
 332     }
 333
 334     return 0;
 335 }
 336
 337 typedef struct OpcodeTable {
 338     int16_t next;
 339     uint8_t val1;
 340     uint8_t val2;
 341 } OpcodeTable;
 342
 343 static int fill_ltable(GetByteContext *gb, uint32_t *table, int *nb_elements)
 344 {
 345     unsigned half = 512, bits = 1023, left = 1024, input, mask;
 346     int value, counter = 0, rshift = 10, lshift = 30;
 347
 348     mask = bytestream2_get_le32(gb) >> 2;
 349     while (left) {
 350         if (counter >= 256)
 351             return AVERROR_INVALIDDATA;
 352         value = bits & mask;
 353         left -= bits & mask;
 354         mask >>= rshift;
 355         lshift -= rshift;
 356         table[counter++] = value;
 357         if (lshift < 16) {
 358             if (bytestream2_get_bytes_left(gb) <= 0)
 359                 return AVERROR_INVALIDDATA;
 360
 361             input = bytestream2_get_le16(gb);
 362             mask += input << lshift;
 363             lshift += 16;
 364         }
 365         if (left < half) {
 366             half >>= 1;
 367             bits >>= 1;
 368             rshift--;
 369         }
 370     }
 371
 372     for (; !table[counter - 1]; counter--)
 373         if (counter <= 0)
 374             return AVERROR_INVALIDDATA;
 375
 376     *nb_elements = counter;
 377
 378     if (counter < 256)
 379         memset(&table[counter], 0, 4 * (256 - counter));
 380
 381     if (lshift >= 16)
 382         bytestream2_seek(gb, -2, SEEK_CUR);
 383
 384     return 0;
 385 }
 386
 387 static int fill_optable(unsigned *table0, OpcodeTable *table1, int nb_elements)
 388 {
 389     unsigned table2[256] = { 0 };
 390     unsigned x = 0;
 391     int val0, val1, i, j = 2, k = 0;
 392
 393     table2[0] = table0[0];
 394     for (i = 0; i < nb_elements - 1; i++, table2[i] = val0) {
 395         val0 = table0[i + 1] + table2[i];
 396     }
 397
 398     if (!table2[0]) {
 399         do {
 400             k++;
 401         } while (!table2[k]);
 402     }
 403
 404     j = 2;
 405     for (i = 1024; i > 0; i--) {
 406         for (table1[x].val1 = k; k < 256 && j > table2[k]; k++);
 407         x = (x - 383) & 0x3FF;
 408         j++;
 409     }
 410
 411     if (nb_elements > 0)
 412         memcpy(&table2[0], table0, 4 * nb_elements);
 413
 414     for (i = 0; i < 1024; i++) {
 415         val0 = table1[i].val1;
 416         val1 = table2[val0];
 417         table2[val0]++;
 418         x = 31 - ff_clz(val1);
 419         if (x > 10)
 420             return AVERROR_INVALIDDATA;
 421         table1[i].val2 = 10 - x;
 422         table1[i].next = (val1 << table1[i].val2) - 1024;
 423     }
 424
 425     return 0;
 426 }
 427
 428 static int get_opcodes(GetByteContext *gb, uint32_t *table, uint8_t *dst, int op_size, int nb_elements)
 429 {
 430     OpcodeTable optable[1024];
 431     int sum, x, val, lshift, rshift, ret, i, idx;
 432     int64_t size_in_bits;
 433     unsigned endoffset, newoffset, offset;
 434     unsigned next;
 435     uint8_t *src = (uint8_t *)gb->buffer;
 436
 437     ret = fill_optable(table, optable, nb_elements);
 438     if (ret < 0)
 439         return ret;
 440
 441     size_in_bits = bytestream2_get_le32(gb);
 442     endoffset = ((size_in_bits + 7) >> 3) - 4;
 443     if (endoffset <= 0 || bytestream2_get_bytes_left(gb) < endoffset)
 444         return AVERROR_INVALIDDATA;
 445
 446     offset = endoffset;
 447     next = AV_RL32(src + endoffset);
 448     rshift = (((size_in_bits & 0xFF) - 1) & 7) + 15;
 449     lshift = 32 - rshift;
 450     idx = (next >> rshift) & 0x3FF;
 451     for (i = 0; i < op_size; i++) {
 452         dst[i] = optable[idx].val1;
 453         val = optable[idx].val2;
 454         sum = val + lshift;
 455         x = (next << lshift) >> 1 >> (31 - val);
 456         newoffset = offset - (sum >> 3);
 457         lshift = sum & 7;
 458         idx = x + optable[idx].next;
 459         offset = newoffset;
 460         if (offset > endoffset)
 461             return AVERROR_INVALIDDATA;
 462         next = AV_RL32(src + offset);
 463     }
 464
 465     bytestream2_skip(gb, (size_in_bits + 7 >> 3) - 4);
 466
 467     return 0;
 468 }
 469
 470 static int dxv_decompress_opcodes(GetByteContext *gb, void *dstp, size_t op_size)
 471 {
 472     int pos = bytestream2_tell(gb);
 473     int flag = bytestream2_peek_byte(gb);
 474
 475     if ((flag & 3) == 0) {
 476         bytestream2_skip(gb, 1);
 477         bytestream2_get_buffer(gb, dstp, op_size);
 478     } else if ((flag & 3) == 1) {
 479         bytestream2_skip(gb, 1);
 480         memset(dstp, bytestream2_get_byte(gb), op_size);
 481     } else {
 482         uint32_t table[256];
 483         int ret, elements = 0;
 484
 485         ret = fill_ltable(gb, table, &elements);
 486         if (ret < 0)
 487             return ret;
 488         ret = get_opcodes(gb, table, dstp, op_size, elements);
 489         if (ret < 0)
 490             return ret;
 491     }
 492     return bytestream2_tell(gb) - pos;
 493 }
 494
 495 static int dxv_decompress_cgo(DXVContext *ctx, GetByteContext *gb,
 496                               uint8_t *tex_data, int tex_size,
 497                               uint8_t *op_data, int *oindex,
 498                               int op_size,
 499                               uint8_t **dstp, int *statep,
 500                               uint8_t **tab0, uint8_t **tab1,
 501                               int offset)
 502 {
 503     uint8_t *dst = *dstp;
 504     uint8_t *tptr0, *tptr1, *tptr3;
 505     int oi = *oindex;
 506     int state = *statep;
 507     int opcode, v, vv;
 508
 509     if (state <= 0) {
 510         if (oi >= op_size)
 511             return AVERROR_INVALIDDATA;
 512         opcode = op_data[oi++];
 513         if (!opcode) {
 514             v = bytestream2_get_byte(gb);
 515             if (v == 255) {
 516                 do {
 517                     if (bytestream2_get_bytes_left(gb) <= 0)
 518                         return AVERROR_INVALIDDATA;
 519                     opcode = bytestream2_get_le16(gb);
 520                     v += opcode;
 521                 } while (opcode == 0xFFFF);
 522             }
 523             AV_WL32(dst, AV_RL32(dst - (8 + offset)));
 524             AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
 525             state = v + 4;
 526             goto done;
 527         }
 528
 529         switch (opcode) {
 530         case 1:
 531             AV_WL32(dst, AV_RL32(dst - (8 + offset)));
 532             AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
 533             break;
 534         case 2:
 535             vv = (8 + offset) * (bytestream2_get_le16(gb) + 1);
 536             if (vv < 0 || vv > dst - tex_data)
 537                 return AVERROR_INVALIDDATA;
 538             tptr0 = dst - vv;
 539             v = AV_RL32(tptr0);
 540             AV_WL32(dst, AV_RL32(tptr0));
 541             AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
 542             tab0[0x9E3779B1 * (uint16_t)v >> 24] = dst;
 543             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 544             break;
 545         case 3:
 546             AV_WL32(dst, bytestream2_get_le32(gb));
 547             AV_WL32(dst + 4, bytestream2_get_le32(gb));
 548             tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 549             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 550             break;
 551         case 4:
 552             tptr3 = tab1[bytestream2_get_byte(gb)];
 553             if (!tptr3)
 554                 return AVERROR_INVALIDDATA;
 555             AV_WL16(dst, bytestream2_get_le16(gb));
 556             AV_WL16(dst + 2, AV_RL16(tptr3));
 557             dst[4] = tptr3[2];
 558             AV_WL16(dst + 5, bytestream2_get_le16(gb));
 559             dst[7] = bytestream2_get_byte(gb);
 560             tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 561             break;
 562         case 5:
 563             tptr3 = tab1[bytestream2_get_byte(gb)];
 564             if (!tptr3)
 565                 return AVERROR_INVALIDDATA;
 566             AV_WL16(dst, bytestream2_get_le16(gb));
 567             AV_WL16(dst + 2, bytestream2_get_le16(gb));
 568             dst[4] = bytestream2_get_byte(gb);
 569             AV_WL16(dst + 5, AV_RL16(tptr3));
 570             dst[7] = tptr3[2];
 571             tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 572             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 573             break;
 574         case 6:
 575             tptr0 = tab1[bytestream2_get_byte(gb)];
 576             if (!tptr0)
 577                 return AVERROR_INVALIDDATA;
 578             tptr1 = tab1[bytestream2_get_byte(gb)];
 579             if (!tptr1)
 580                 return AVERROR_INVALIDDATA;
 581             AV_WL16(dst, bytestream2_get_le16(gb));
 582             AV_WL16(dst + 2, AV_RL16(tptr0));
 583             dst[4] = tptr0[2];
 584             AV_WL16(dst + 5, AV_RL16(tptr1));
 585             dst[7] = tptr1[2];
 586             tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 587             break;
 588         case 7:
 589             v = (8 + offset) * (bytestream2_get_le16(gb) + 1);
 590             if (v < 0 || v > dst - tex_data)
 591                 return AVERROR_INVALIDDATA;
 592             tptr0 = dst - v;
 593             AV_WL16(dst, bytestream2_get_le16(gb));
 594             AV_WL16(dst + 2, AV_RL16(tptr0 + 2));
 595             AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
 596             tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 597             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 598             break;
 599         case 8:
 600             tptr1 = tab0[bytestream2_get_byte(gb)];
 601             if (!tptr1)
 602                 return AVERROR_INVALIDDATA;
 603             AV_WL16(dst, AV_RL16(tptr1));
 604             AV_WL16(dst + 2, bytestream2_get_le16(gb));
 605             AV_WL32(dst + 4, bytestream2_get_le32(gb));
 606             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 607             break;
 608         case 9:
 609             tptr1 = tab0[bytestream2_get_byte(gb)];
 610             if (!tptr1)
 611                 return AVERROR_INVALIDDATA;
 612             tptr3 = tab1[bytestream2_get_byte(gb)];
 613             if (!tptr3)
 614                 return AVERROR_INVALIDDATA;
 615             AV_WL16(dst, AV_RL16(tptr1));
 616             AV_WL16(dst + 2, AV_RL16(tptr3));
 617             dst[4] = tptr3[2];
 618             AV_WL16(dst + 5, bytestream2_get_le16(gb));
 619             dst[7] = bytestream2_get_byte(gb);
 620             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 621             break;
 622         case 10:
 623             tptr1 = tab0[bytestream2_get_byte(gb)];
 624             if (!tptr1)
 625                 return AVERROR_INVALIDDATA;
 626             tptr3 = tab1[bytestream2_get_byte(gb)];
 627             if (!tptr3)
 628                 return AVERROR_INVALIDDATA;
 629             AV_WL16(dst, AV_RL16(tptr1));
 630             AV_WL16(dst + 2, bytestream2_get_le16(gb));
 631             dst[4] = bytestream2_get_byte(gb);
 632             AV_WL16(dst + 5, AV_RL16(tptr3));
 633             dst[7] = tptr3[2];
 634             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 635             break;
 636         case 11:
 637             tptr0 = tab0[bytestream2_get_byte(gb)];
 638             if (!tptr0)
 639                 return AVERROR_INVALIDDATA;
 640             tptr3 = tab1[bytestream2_get_byte(gb)];
 641             if (!tptr3)
 642                 return AVERROR_INVALIDDATA;
 643             tptr1 = tab1[bytestream2_get_byte(gb)];
 644             if (!tptr1)
 645                 return AVERROR_INVALIDDATA;
 646             AV_WL16(dst, AV_RL16(tptr0));
 647             AV_WL16(dst + 2, AV_RL16(tptr3));
 648             dst[4] = tptr3[2];
 649             AV_WL16(dst + 5, AV_RL16(tptr1));
 650             dst[7] = tptr1[2];
 651             break;
 652         case 12:
 653             tptr1 = tab0[bytestream2_get_byte(gb)];
 654             if (!tptr1)
 655                 return AVERROR_INVALIDDATA;
 656             v = (8 + offset) * (bytestream2_get_le16(gb) + 1);
 657             if (v < 0 || v > dst - tex_data)
 658                 return AVERROR_INVALIDDATA;
 659             tptr0 = dst - v;
 660             AV_WL16(dst, AV_RL16(tptr1));
 661             AV_WL16(dst + 2, AV_RL16(tptr0 + 2));
 662             AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
 663             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 664             break;
 665         case 13:
 666             AV_WL16(dst, AV_RL16(dst - (8 + offset)));
 667             AV_WL16(dst + 2, bytestream2_get_le16(gb));
 668             AV_WL32(dst + 4, bytestream2_get_le32(gb));
 669             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 670             break;
 671         case 14:
 672             tptr3 = tab1[bytestream2_get_byte(gb)];
 673             if (!tptr3)
 674                 return AVERROR_INVALIDDATA;
 675             AV_WL16(dst, AV_RL16(dst - (8 + offset)));
 676             AV_WL16(dst + 2, AV_RL16(tptr3));
 677             dst[4] = tptr3[2];
 678             AV_WL16(dst + 5, bytestream2_get_le16(gb));
 679             dst[7] = bytestream2_get_byte(gb);
 680             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 681             break;
 682         case 15:
 683             tptr3 = tab1[bytestream2_get_byte(gb)];
 684             if (!tptr3)
 685                 return AVERROR_INVALIDDATA;
 686             AV_WL16(dst, AV_RL16(dst - (8 + offset)));
 687             AV_WL16(dst + 2, bytestream2_get_le16(gb));
 688             dst[4] = bytestream2_get_byte(gb);
 689             AV_WL16(dst + 5, AV_RL16(tptr3));
 690             dst[7] = tptr3[2];
 691             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 692             break;
 693         case 16:
 694             tptr3 = tab1[bytestream2_get_byte(gb)];
 695             if (!tptr3)
 696                 return AVERROR_INVALIDDATA;
 697             tptr1 = tab1[bytestream2_get_byte(gb)];
 698             if (!tptr1)
 699                 return AVERROR_INVALIDDATA;
 700             AV_WL16(dst, AV_RL16(dst - (8 + offset)));
 701             AV_WL16(dst + 2, AV_RL16(tptr3));
 702             dst[4] = tptr3[2];
 703             AV_WL16(dst + 5, AV_RL16(tptr1));
 704             dst[7] = tptr1[2];
 705             break;
 706         case 17:
 707             v = (8 + offset) * (bytestream2_get_le16(gb) + 1);
 708             if (v < 0 || v > dst - tex_data)
 709                 return AVERROR_INVALIDDATA;
 710             AV_WL16(dst, AV_RL16(dst - (8 + offset)));
 711             AV_WL16(dst + 2, AV_RL16(&dst[-v + 2]));
 712             AV_WL32(dst + 4, AV_RL32(&dst[-v + 4]));
 713             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
 714             break;
 715         default:
 716             break;
 717         }
 718     } else {
 719 done:
 720         AV_WL32(dst, AV_RL32(dst - (8 + offset)));
 721         AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
 722         state--;
 723     }
 724     if (dst - tex_data + 8 > tex_size)
 725         return AVERROR_INVALIDDATA;
 726     dst += 8;
 727
 728     *oindex = oi;
 729     *dstp = dst;
 730     *statep = state;
 731
 732     return 0;
 733 }
 734
 735 static int dxv_decompress_cocg(DXVContext *ctx, GetByteContext *gb,
 736                                uint8_t *tex_data, int tex_size,
 737                                uint8_t *op_data0, uint8_t *op_data1,
 738                                int max_op_size0, int max_op_size1)
 739 {
 740     uint8_t *dst, *tab2[256] = { 0 }, *tab0[256] = { 0 }, *tab3[256] = { 0 }, *tab1[256] = { 0 };
 741     int op_offset = bytestream2_get_le32(gb);
 742     unsigned op_size0 = bytestream2_get_le32(gb);
 743     unsigned op_size1 = bytestream2_get_le32(gb);
 744     int data_start = bytestream2_tell(gb);
 745     int skip0, skip1, oi0 = 0, oi1 = 0;
 746     int ret, state0 = 0, state1 = 0;
 747
 748     dst = tex_data;
 749     bytestream2_skip(gb, op_offset - 12);
 750     if (op_size0 > max_op_size0)
 751         return AVERROR_INVALIDDATA;
 752     skip0 = dxv_decompress_opcodes(gb, op_data0, op_size0);
 753     if (skip0 < 0)
 754         return skip0;
 755     bytestream2_seek(gb, data_start + op_offset + skip0 - 12, SEEK_SET);
 756     if (op_size1 > max_op_size1)
 757         return AVERROR_INVALIDDATA;
 758     skip1 = dxv_decompress_opcodes(gb, op_data1, op_size1);
 759     if (skip1 < 0)
 760         return skip1;
 761     bytestream2_seek(gb, data_start, SEEK_SET);
 762
 763     AV_WL32(dst, bytestream2_get_le32(gb));
 764     AV_WL32(dst + 4, bytestream2_get_le32(gb));
 765     AV_WL32(dst + 8, bytestream2_get_le32(gb));
 766     AV_WL32(dst + 12, bytestream2_get_le32(gb));
 767
 768     tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
 769     tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFF) >> 24] = dst + 2;
 770     tab2[0x9E3779B1 * AV_RL16(dst + 8) >> 24] = dst + 8;
 771     tab3[0x9E3779B1 * (AV_RL32(dst + 10) & 0xFFFFFF) >> 24] = dst + 10;
 772     dst += 16;
 773     while (dst + 10 < tex_data + tex_size) {
 774         ret = dxv_decompress_cgo(ctx, gb, tex_data, tex_size, op_data0, &oi0, op_size0,
 775                                  &dst, &state0, tab0, tab1, 8);
 776         if (ret < 0)
 777             return ret;
 778         ret = dxv_decompress_cgo(ctx, gb, tex_data, tex_size, op_data1, &oi1, op_size1,
 779                                  &dst, &state1, tab2, tab3, 8);
 780         if (ret < 0)
 781             return ret;
 782     }
 783
 784     bytestream2_seek(gb, data_start + op_offset + skip0 + skip1 - 12, SEEK_SET);
 785
 786     return 0;
 787 }
 788
 789 static int dxv_decompress_yo(DXVContext *ctx, GetByteContext *gb,
 790                              uint8_t *tex_data, int tex_size,
 791                              uint8_t *op_data, int max_op_size)
 792 {
 793     int op_offset = bytestream2_get_le32(gb);
 794     unsigned op_size = bytestream2_get_le32(gb);
 795     int data_start = bytestream2_tell(gb);
 796     uint8_t *dst, *table0[256] = { 0 }, *table1[256] = { 0 };
 797     int ret, state = 0, skip, oi = 0, v, vv;
 798
 799     dst = tex_data;
 800     bytestream2_skip(gb, op_offset - 8);
 801     if (op_size > max_op_size)
 802         return AVERROR_INVALIDDATA;
 803     skip = dxv_decompress_opcodes(gb, op_data, op_size);
 804     if (skip < 0)
 805         return skip;
 806     bytestream2_seek(gb, data_start, SEEK_SET);
 807
 808     v = bytestream2_get_le32(gb);
 809     AV_WL32(dst, v);
 810     vv = bytestream2_get_le32(gb);
 811     table0[0x9E3779B1 * (uint16_t)v >> 24] = dst;
 812     AV_WL32(dst + 4, vv);
 813     table1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFF) >> 24] = dst + 2;
 814     dst += 8;
 815
 816     while (dst < tex_data + tex_size) {
 817         ret = dxv_decompress_cgo(ctx, gb, tex_data, tex_size, op_data, &oi, op_size,
 818                                  &dst, &state, table0, table1, 0);
 819         if (ret < 0)
 820             return ret;
 821     }
 822
 823     bytestream2_seek(gb, data_start + op_offset + skip - 8, SEEK_SET);
 824
 825     return 0;
 826 }
 827
 828 static int dxv_decompress_ycg6(AVCodecContext *avctx)
 829 {
 830     DXVContext *ctx = avctx->priv_data;
 831     GetByteContext *gb = &ctx->gbc;
 832     int ret;
 833
 834     ret = dxv_decompress_yo(ctx, gb, ctx->tex_data, ctx->tex_size,
 835                             ctx->op_data[0], ctx->op_size[0]);
 836     if (ret < 0)
 837         return ret;
 838
 839     return dxv_decompress_cocg(ctx, gb, ctx->ctex_data, ctx->ctex_size,
 840                                ctx->op_data[1], ctx->op_data[2],
 841                                ctx->op_size[1], ctx->op_size[2]);
 842 }
 843
 844 static int dxv_decompress_yg10(AVCodecContext *avctx)
 845 {
 846     DXVContext *ctx = avctx->priv_data;
 847     GetByteContext *gb = &ctx->gbc;
 848     int ret;
 849
 850     ret = dxv_decompress_cocg(ctx, gb, ctx->tex_data, ctx->tex_size,
 851                               ctx->op_data[0], ctx->op_data[3],
 852                               ctx->op_size[0], ctx->op_size[3]);
 853     if (ret < 0)
 854         return ret;
 855
 856     return dxv_decompress_cocg(ctx, gb, ctx->ctex_data, ctx->ctex_size,
 857                                ctx->op_data[1], ctx->op_data[2],
 858                                ctx->op_size[1], ctx->op_size[2]);
 859 }
 860
 861 static int dxv_decompress_dxt5(AVCodecContext *avctx)
 862 {
 863     DXVContext *ctx = avctx->priv_data;
 864     GetByteContext *gbc = &ctx->gbc;
 865     uint32_t value, op;
 866     int idx, prev, state = 0;
 867     int pos = 4;
 868     int run = 0;
 869     int probe, check;
 870
 871     /* Copy the first four elements */
 872     AV_WL32(ctx->tex_data +  0, bytestream2_get_le32(gbc));
 873     AV_WL32(ctx->tex_data +  4, bytestream2_get_le32(gbc));
 874     AV_WL32(ctx->tex_data +  8, bytestream2_get_le32(gbc));
 875     AV_WL32(ctx->tex_data + 12, bytestream2_get_le32(gbc));
 876
 877     /* Process input until the whole texture has been filled */
 878     while (pos + 2 <= ctx->tex_size / 4) {
 879         if (run) {
 880             run--;
 881
 882             prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 883             AV_WL32(ctx->tex_data + 4 * pos, prev);
 884             pos++;
 885             prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 886             AV_WL32(ctx->tex_data + 4 * pos, prev);
 887             pos++;
 888         } else {
 889             if (bytestream2_get_bytes_left(gbc) < 1)
 890                 return AVERROR_INVALIDDATA;
 891             if (state == 0) {
 892                 value = bytestream2_get_le32(gbc);
 893                 state = 16;
 894             }
 895             op = value & 0x3;
 896             value >>= 2;
 897             state--;
 898
 899             switch (op) {
 900             case 0:
 901                 /* Long copy */
 902                 check = bytestream2_get_byte(gbc) + 1;
 903                 if (check == 256) {
 904                     do {
 905                         probe = bytestream2_get_le16(gbc);
 906                         check += probe;
 907                     } while (probe == 0xFFFF);
 908                 }
 909                 while (check && pos + 4 <= ctx->tex_size / 4) {
 910                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 911                     AV_WL32(ctx->tex_data + 4 * pos, prev);
 912                     pos++;
 913
 914                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 915                     AV_WL32(ctx->tex_data + 4 * pos, prev);
 916                     pos++;
 917
 918                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 919                     AV_WL32(ctx->tex_data + 4 * pos, prev);
 920                     pos++;
 921
 922                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 923                     AV_WL32(ctx->tex_data + 4 * pos, prev);
 924                     pos++;
 925
 926                     check--;
 927                 }
 928
 929                 /* Restart (or exit) the loop */
 930                 continue;
 931                 break;
 932             case 1:
 933                 /* Load new run value */
 934                 run = bytestream2_get_byte(gbc);
 935                 if (run == 255) {
 936                     do {
 937                         probe = bytestream2_get_le16(gbc);
 938                         run += probe;
 939                     } while (probe == 0xFFFF);
 940                 }
 941
 942                 /* Copy two dwords from previous data */
 943                 prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 944                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 945                 pos++;
 946
 947                 prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
 948                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 949                 pos++;
 950                 break;
 951             case 2:
 952                 /* Copy two dwords from a previous index */
 953                 idx = 8 + bytestream2_get_le16(gbc);
 954                 if (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4)
 955                     return AVERROR_INVALIDDATA;
 956                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 957                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 958                 pos++;
 959
 960                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 961                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 962                 pos++;
 963                 break;
 964             case 3:
 965                 /* Copy two dwords from input */
 966                 prev = bytestream2_get_le32(gbc);
 967                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 968                 pos++;
 969
 970                 prev = bytestream2_get_le32(gbc);
 971                 AV_WL32(ctx->tex_data + 4 * pos, prev);
 972                 pos++;
 973                 break;
 974             }
 975         }
 976
 977         CHECKPOINT(4);
 978         if (pos + 2 > ctx->tex_size / 4)
 979             return AVERROR_INVALIDDATA;
 980
 981         /* Copy two elements from a previous offset or from the input buffer */
 982         if (op) {
 983             if (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4)
 984                 return AVERROR_INVALIDDATA;
 985             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 986             AV_WL32(ctx->tex_data + 4 * pos, prev);
 987             pos++;
 988
 989             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 990             AV_WL32(ctx->tex_data + 4 * pos, prev);
 991             pos++;
 992         } else {
 993             CHECKPOINT(4);
 994
 995             if (op && (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4))
 996                 return AVERROR_INVALIDDATA;
 997             if (op)
 998                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
 999             else
1000                 prev = bytestream2_get_le32(gbc);
1001             AV_WL32(ctx->tex_data + 4 * pos, prev);
1002             pos++;
1003
1004             CHECKPOINT(4);
1005
1006             if (op)
1007                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
1008             else
1009                 prev = bytestream2_get_le32(gbc);
1010             AV_WL32(ctx->tex_data + 4 * pos, prev);
1011             pos++;
1012         }
1013     }
1014
1015     return 0;
1016 }
1017
1018 static int dxv_decompress_lzf(AVCodecContext *avctx)
1019 {
1020     DXVContext *ctx = avctx->priv_data;
1021     return ff_lzf_uncompress(&ctx->gbc, &ctx->tex_data, &ctx->tex_size);
1022 }
1023
1024 static int dxv_decompress_raw(AVCodecContext *avctx)
1025 {
1026     DXVContext *ctx = avctx->priv_data;
1027     GetByteContext *gbc = &ctx->gbc;
1028
1029     if (bytestream2_get_bytes_left(gbc) < ctx->tex_size)
1030         return AVERROR_INVALIDDATA;
1031
1032     bytestream2_get_buffer(gbc, ctx->tex_data, ctx->tex_size);
1033     return 0;
1034 }
1035
1036 static int dxv_decode(AVCodecContext *avctx, void *data,
1037                       int *got_frame, AVPacket *avpkt)
1038 {
1039     DXVContext *ctx = avctx->priv_data;
1040     ThreadFrame tframe;
1041     GetByteContext *gbc = &ctx->gbc;
1042     int (*decompress_tex)(AVCodecContext *avctx);
1043     const char *msgcomp, *msgtext;
1044     uint32_t tag;
1045     int version_major, version_minor = 0;
1046     int size = 0, old_type = 0;
1047     int ret;
1048
1049     bytestream2_init(gbc, avpkt->data, avpkt->size);
1050
1051     ctx->texture_block_h = 4;
1052     ctx->texture_block_w = 4;
1053
1054     avctx->pix_fmt = AV_PIX_FMT_RGBA;
1055     avctx->colorspace = AVCOL_SPC_RGB;
1056
1057     tag = bytestream2_get_le32(gbc);
1058     switch (tag) {
1059     case MKBETAG('D', 'X', 'T', '1'):
1060         decompress_tex = dxv_decompress_dxt1;
1061         ctx->tex_funct = ctx->texdsp.dxt1_block;
1062         ctx->tex_rat   = 8;
1063         ctx->tex_step  = 8;
1064         msgcomp = "DXTR1";
1065         msgtext = "DXT1";
1066         break;
1067     case MKBETAG('D', 'X', 'T', '5'):
1068         decompress_tex = dxv_decompress_dxt5;
1069         ctx->tex_funct = ctx->texdsp.dxt5_block;
1070         ctx->tex_rat   = 4;
1071         ctx->tex_step  = 16;
1072         msgcomp = "DXTR5";
1073         msgtext = "DXT5";
1074         break;
1075     case MKBETAG('Y', 'C', 'G', '6'):
1076         decompress_tex = dxv_decompress_ycg6;
1077         ctx->tex_funct_planar[0] = yo_block;
1078         ctx->tex_funct_planar[1] = cocg_block;
1079         ctx->tex_rat   = 8;
1080         ctx->tex_step  = 32;
1081         ctx->ctex_step = 16;
1082         msgcomp = "YOCOCG6";
1083         msgtext = "YCG6";
1084         ctx->ctex_size = avctx->coded_width * avctx->coded_height / 4;
1085         ctx->texture_block_h = 4;
1086         ctx->texture_block_w = 16;
1087         ctx->ctexture_block_h = 4;
1088         ctx->ctexture_block_w = 4;
1089         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
1090         avctx->colorspace = AVCOL_SPC_YCOCG;
1091         break;
1092     case MKBETAG('Y', 'G', '1', '0'):
1093         decompress_tex = dxv_decompress_yg10;
1094         ctx->tex_funct_planar[0] = yao_block;
1095         ctx->tex_funct_planar[1] = cocg_block;
1096         ctx->tex_rat   = 4;
1097         ctx->tex_step  = 64;
1098         ctx->ctex_step = 16;
1099         msgcomp = "YAOCOCG10";
1100         msgtext = "YG10";
1101         ctx->ctex_size = avctx->coded_width * avctx->coded_height / 4;
1102         ctx->texture_block_h = 4;
1103         ctx->texture_block_w = 16;
1104         ctx->ctexture_block_h = 4;
1105         ctx->ctexture_block_w = 4;
1106         avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
1107         avctx->colorspace = AVCOL_SPC_YCOCG;
1108         break;
1109     default:
1110         /* Old version does not have a real header, just size and type. */
1111         size = tag & 0x00FFFFFF;
1112         old_type = tag >> 24;
1113         version_major = (old_type & 0x0F) - 1;
1114
1115         if (old_type & 0x80) {
1116             msgcomp = "RAW";
1117             decompress_tex = dxv_decompress_raw;
1118         } else {
1119             msgcomp = "LZF";
1120             decompress_tex = dxv_decompress_lzf;
1121         }
1122
1123         if (old_type & 0x40) {
1124             msgtext = "DXT5";
1125
1126             ctx->tex_funct = ctx->texdsp.dxt5_block;
1127             ctx->tex_step  = 16;
1128         } else if (old_type & 0x20 || version_major == 1) {
1129             msgtext = "DXT1";
1130
1131             ctx->tex_funct = ctx->texdsp.dxt1_block;
1132             ctx->tex_step  = 8;
1133         } else {
1134             av_log(avctx, AV_LOG_ERROR, "Unsupported header (0x%08"PRIX32")\n.", tag);
1135             return AVERROR_INVALIDDATA;
1136         }
1137         ctx->tex_rat = 1;
1138         break;
1139     }
1140
1141     ctx->slice_count = av_clip(avctx->thread_count, 1,
1142                                avctx->coded_height / FFMAX(ctx->texture_block_h,
1143                                                            ctx->ctexture_block_h));
1144
1145     /* New header is 12 bytes long. */
1146     if (!old_type) {
1147         version_major = bytestream2_get_byte(gbc) - 1;
1148         version_minor = bytestream2_get_byte(gbc);
1149
1150         /* Encoder copies texture data when compression is not advantageous. */
1151         if (bytestream2_get_byte(gbc)) {
1152             msgcomp = "RAW";
1153             ctx->tex_rat = 1;
1154             decompress_tex = dxv_decompress_raw;
1155         }
1156
1157         bytestream2_skip(gbc, 1); // unknown
1158         size = bytestream2_get_le32(gbc);
1159     }
1160     av_log(avctx, AV_LOG_DEBUG,
1161            "%s compression with %s texture (version %d.%d)\n",
1162            msgcomp, msgtext, version_major, version_minor);
1163
1164     if (size != bytestream2_get_bytes_left(gbc)) {
1165         av_log(avctx, AV_LOG_ERROR,
1166                "Incomplete or invalid file (header %d, left %u).\n",
1167                size, bytestream2_get_bytes_left(gbc));
1168         return AVERROR_INVALIDDATA;
1169     }
1170
1171     ctx->tex_size = avctx->coded_width * avctx->coded_height * 4 / ctx->tex_rat;
1172     ret = av_reallocp(&ctx->tex_data, ctx->tex_size + AV_INPUT_BUFFER_PADDING_SIZE);
1173     if (ret < 0)
1174         return ret;
1175
1176     if (ctx->ctex_size) {
1177         int i;
1178
1179         ctx->op_size[0] = avctx->coded_width * avctx->coded_height / 16;
1180         ctx->op_size[1] = avctx->coded_width * avctx->coded_height / 32;
1181         ctx->op_size[2] = avctx->coded_width * avctx->coded_height / 32;
1182         ctx->op_size[3] = avctx->coded_width * avctx->coded_height / 16;
1183
1184         ret = av_reallocp(&ctx->ctex_data, ctx->ctex_size + AV_INPUT_BUFFER_PADDING_SIZE);
1185         if (ret < 0)
1186             return ret;
1187         for (i = 0; i < 4; i++) {
1188             ret = av_reallocp(&ctx->op_data[i], ctx->op_size[i]);
1189             if (ret < 0)
1190                 return ret;
1191         }
1192     }
1193
1194     /* Decompress texture out of the intermediate compression. */
1195     ret = decompress_tex(avctx);
1196     if (ret < 0)
1197         return ret;
1198     {
1199         int w_block = avctx->coded_width / ctx->texture_block_w;
1200         int h_block = avctx->coded_height / ctx->texture_block_h;
1201         if (w_block * h_block * ctx->tex_step > ctx->tex_size * 8LL)
1202             return AVERROR_INVALIDDATA;
1203     }
1204
1205     tframe.f = data;
1206     ret = ff_thread_get_buffer(avctx, &tframe, 0);
1207     if (ret < 0)
1208         return ret;
1209
1210     /* Now decompress the texture with the standard functions. */
1211     avctx->execute2(avctx, decompress_texture_thread,
1212                     tframe.f, NULL, ctx->slice_count);
1213
1214     /* Frame is ready to be output. */
1215     tframe.f->pict_type = AV_PICTURE_TYPE_I;
1216     tframe.f->key_frame = 1;
1217     *got_frame = 1;
1218
1219     return avpkt->size;
1220 }
1221
1222 static int dxv_init(AVCodecContext *avctx)
1223 {
1224     DXVContext *ctx = avctx->priv_data;
1225     int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1226
1227     if (ret < 0) {
1228         av_log(avctx, AV_LOG_ERROR, "Invalid image size %dx%d.\n",
1229                avctx->width, avctx->height);
1230         return ret;
1231     }
1232
1233     /* Codec requires 16x16 alignment. */
1234     avctx->coded_width  = FFALIGN(avctx->width,  16);
1235     avctx->coded_height = FFALIGN(avctx->height, 16);
1236
1237     ff_texturedsp_init(&ctx->texdsp);
1238
1239     return 0;
1240 }
1241
1242 static int dxv_close(AVCodecContext *avctx)
1243 {
1244     DXVContext *ctx = avctx->priv_data;
1245
1246     av_freep(&ctx->tex_data);
1247     av_freep(&ctx->ctex_data);
1248     av_freep(&ctx->op_data[0]);
1249     av_freep(&ctx->op_data[1]);
1250     av_freep(&ctx->op_data[2]);
1251     av_freep(&ctx->op_data[3]);
1252
1253     return 0;
1254 }
1255
1256 AVCodec ff_dxv_decoder = {
1257     .name           = "dxv",
1258     .long_name      = NULL_IF_CONFIG_SMALL("Resolume DXV"),
1259     .type           = AVMEDIA_TYPE_VIDEO,
1260     .id             = AV_CODEC_ID_DXV,
1261     .init           = dxv_init,
1262     .decode         = dxv_decode,
1263     .close          = dxv_close,
1264     .priv_data_size = sizeof(DXVContext),
1265     .capabilities   = AV_CODEC_CAP_DR1 |
1266                       AV_CODEC_CAP_SLICE_THREADS |
1267                       AV_CODEC_CAP_FRAME_THREADS,
1268     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
1269                       FF_CODEC_CAP_INIT_CLEANUP,
1270 };