FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dxv.c
Go to the documentation of this file.
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 {
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 */
49 
50  uint8_t *op_data[4]; // Opcodes
51  int64_t op_size[4]; // Opcodes size
52 
55 
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 
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 
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;
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 
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 
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 
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 
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 
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 
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 
1016 {
1017  DXVContext *ctx = avctx->priv_data;
1018  return ff_lzf_uncompress(&ctx->gbc, &ctx->tex_data, &ctx->tex_size);
1019 }
1020 
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;
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 
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 
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 |
1259  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1261 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define flag(name)
Definition: cbs_h2645.c:255
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint8_t val2
Definition: dxv.c:338
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1708
int ctex_step
Definition: dxv.c:43
int(* dxt1_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:46
misc image utilities
AVFrame * f
Definition: thread.h:35
Texture block (4x4) module.
int size
Definition: avcodec.h:1434
int ctexture_block_w
Definition: dxv.c:56
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1730
static int dxv_decompress_dxt1(AVCodecContext *avctx)
Definition: dxv.c:286
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
static int dxv_decompress_ycg6(AVCodecContext *avctx)
Definition: dxv.c:825
uint8_t run
Definition: svq3.c:206
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3411
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:487
static int get_opcodes(GetByteContext *gb, uint32_t *table, uint8_t *dst, int op_size, int nb_elements)
Definition: dxv.c:426
int64_t ctex_size
Definition: dxv.c:45
static int16_t block[64]
Definition: dct.c:115
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
uint8_t
uint8_t * tex_data
Definition: dxv.c:39
static int dxv_decompress_dxt5(AVCodecContext *avctx)
Definition: dxv.c:858
int(* tex_funct_planar[2])(uint8_t *plane0, ptrdiff_t stride0, uint8_t *plane1, ptrdiff_t stride1, const uint8_t *block)
Definition: dxv.c:61
int64_t tex_size
Definition: dxv.c:44
static int yao_block(uint8_t *plane0, ptrdiff_t stride0, uint8_t *plane3, ptrdiff_t stride1, const uint8_t *block)
Definition: dxv.c:174
Multithreading support functions.
#define CHECKPOINT(x)
Definition: dxv.c:256
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:253
static AVFrame * frame
int16_t next
Definition: dxv.c:336
uint8_t * data
Definition: avcodec.h:1433
const uint8_t * buffer
Definition: bytestream.h:34
uint32_t tag
Definition: movenc.c:1483
static int dxv_decompress_yg10(AVCodecContext *avctx)
Definition: dxv.c:841
static int dxv_decompress_yo(DXVContext *ctx, GetByteContext *gb, uint8_t *tex_data, int tex_size, uint8_t *op_data, int max_op_size)
Definition: dxv.c:786
ptrdiff_t size
Definition: opengl_enc.c:101
static int fill_ltable(GetByteContext *gb, uint32_t *table, int *nb_elements)
Definition: dxv.c:341
static int probe(AVProbeData *p)
Definition: act.c:36
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
TextureDSPContext texdsp
Definition: dxv.c:36
int ff_lzf_uncompress(GetByteContext *gb, uint8_t **buf, int64_t *size)
Definition: lzf.c:40
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static int decompress_texture_thread(AVCodecContext *avctx, void *arg, int slice, int thread_nb)
Definition: dxv.c:193
static const uint16_t mask[17]
Definition: lzw.c:38
BYTE * dstp
Definition: avisynth_c.h:813
uint8_t val1
Definition: dxv.c:337
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
static const struct endianess table[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
AVCodec ff_dxv_decoder
Definition: dxv.c:1247
GetByteContext gbc
Definition: dxv.c:37
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:263
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
const char * arg
Definition: jacosubdec.c:66
static int dxv_close(AVCodecContext *avctx)
Definition: dxv.c:1233
const char * name
Name of the codec implementation.
Definition: avcodec.h:3418
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:87
int(* dxt5_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:51
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define FFMAX(a, b)
Definition: common.h:94
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1018
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
static int dxv_decompress_lzf(AVCodecContext *avctx)
Definition: dxv.c:1015
Definition: dxv.c:35
static int yo_block(uint8_t *dst, ptrdiff_t stride, uint8_t *unused0, ptrdiff_t unused1, const uint8_t *block)
Definition: dxv.c:160
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:282
av_cold void ff_texturedsp_init(TextureDSPContext *c)
Definition: texturedsp.c:637
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:301
#define ff_clz
Definition: intmath.h:142
int64_t op_size[4]
Definition: dxv.c:51
int width
picture width / height.
Definition: avcodec.h:1693
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
int tex_rat
Definition: dxv.c:41
AVFormatContext * ctx
Definition: movenc.c:48
static int dxv_decompress_opcodes(GetByteContext *gb, void *dstp, size_t op_size)
Definition: dxv.c:467
static void decompress_indices(uint8_t *dst, const uint8_t *src)
Definition: dxv.c:66
int slice_count
Definition: dxv.c:48
static int dxv_decompress_cocg(DXVContext *ctx, GetByteContext *gb, uint8_t *tex_data, int tex_size, uint8_t *op_data0, uint8_t *op_data1, int max_op_size0, int max_op_size1)
Definition: dxv.c:732
int texture_block_h
Definition: dxv.c:54
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2772
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1022
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:163
Libavcodec external API header.
static int cocg_block(uint8_t *plane0, ptrdiff_t stride0, uint8_t *plane1, ptrdiff_t stride1, const uint8_t *block)
Definition: dxv.c:111
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:249
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
Definition: avcodec.h:1521
static void yao_subblock(uint8_t *dst, uint8_t *yo_indices, ptrdiff_t stride, const uint8_t *block)
Definition: dxv.c:141
const int16_t * tab1
Definition: mace.c:144
int coded_height
Definition: avcodec.h:1708
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2144
static int dxv_init(AVCodecContext *avctx)
Definition: dxv.c:1213
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
static struct @282 state
int(* tex_funct)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: dxv.c:60
int ctexture_block_h
Definition: dxv.c:57
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c:78
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
int
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
static int dxv_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dxv.c:1033
common internal api header.
if(ret< 0)
Definition: vf_mcdeint.c:279
static double c[64]
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
#define MKBETAG(a, b, c, d)
Definition: common.h:367
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:776
void * priv_data
Definition: avcodec.h:1548
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:2832
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:296
int texture_block_w
Definition: dxv.c:53
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:208
#define av_freep(p)
static int fill_optable(unsigned *table0, OpcodeTable *table1, int nb_elements)
Definition: dxv.c:385
static int dxv_decompress_cgo(DXVContext *ctx, GetByteContext *gb, uint8_t *tex_data, int tex_size, uint8_t *op_data, int *oindex, int op_size, uint8_t **dstp, int *statep, uint8_t **tab0, uint8_t **tab1, int offset)
Definition: dxv.c:492
#define stride
static int extract_component(int yo0, int yo1, int code)
Definition: dxv.c:82
uint8_t * op_data[4]
Definition: dxv.c:50
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1410
uint8_t * ctex_data
Definition: dxv.c:40
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:962
for(j=16;j >0;--j)
const int16_t * tab2
Definition: mace.c:144
int tex_step
Definition: dxv.c:42
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
static int dxv_decompress_raw(AVCodecContext *avctx)
Definition: dxv.c:1021
#define check(x, y, S, v)
static uint8_t tmp[11]
Definition: aes_ctr.c:26