FFmpeg  4.1.5
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, i, idx;
430  int64_t size_in_bits;
431  unsigned endoffset, newoffset, offset;
432  unsigned next;
433  uint8_t *src = (uint8_t *)gb->buffer;
434 
435  ret = fill_optable(table, optable, nb_elements);
436  if (ret < 0)
437  return ret;
438 
439  size_in_bits = bytestream2_get_le32(gb);
440  endoffset = ((size_in_bits + 7) >> 3) - 4;
441  if (endoffset <= 0 || bytestream2_get_bytes_left(gb) < endoffset)
442  return AVERROR_INVALIDDATA;
443 
444  offset = endoffset;
445  next = AV_RL32(src + endoffset);
446  rshift = (((size_in_bits & 0xFF) - 1) & 7) + 15;
447  lshift = 32 - rshift;
448  idx = (next >> rshift) & 0x3FF;
449  for (i = 0; i < op_size; i++) {
450  dst[i] = optable[idx].val1;
451  val = optable[idx].val2;
452  sum = val + lshift;
453  x = (next << lshift) >> 1 >> (31 - val);
454  newoffset = offset - (sum >> 3);
455  lshift = sum & 7;
456  idx = x + optable[idx].next;
457  offset = newoffset;
458  if (offset > endoffset)
459  return AVERROR_INVALIDDATA;
460  next = AV_RL32(src + offset);
461  }
462 
463  bytestream2_skip(gb, (size_in_bits + 7 >> 3) - 4);
464 
465  return 0;
466 }
467 
468 static int dxv_decompress_opcodes(GetByteContext *gb, void *dstp, size_t op_size)
469 {
470  int pos = bytestream2_tell(gb);
471  int flag = bytestream2_peek_byte(gb);
472 
473  if ((flag & 3) == 0) {
474  bytestream2_skip(gb, 1);
475  bytestream2_get_buffer(gb, dstp, op_size);
476  } else if ((flag & 3) == 1) {
477  bytestream2_skip(gb, 1);
478  memset(dstp, bytestream2_get_byte(gb), op_size);
479  } else {
480  uint32_t table[256];
481  int ret, elements = 0;
482 
483  ret = fill_ltable(gb, table, &elements);
484  if (ret < 0)
485  return ret;
486  ret = get_opcodes(gb, table, dstp, op_size, elements);
487  if (ret < 0)
488  return ret;
489  }
490  return bytestream2_tell(gb) - pos;
491 }
492 
494  uint8_t *tex_data, int tex_size,
495  uint8_t *op_data, int *oindex,
496  int op_size,
497  uint8_t **dstp, int *statep,
498  uint8_t **tab0, uint8_t **tab1,
499  int offset)
500 {
501  uint8_t *dst = *dstp;
502  uint8_t *tptr0, *tptr1, *tptr3;
503  int oi = *oindex;
504  int state = *statep;
505  int opcode, v, vv;
506 
507  if (state <= 0) {
508  if (oi >= op_size)
509  return AVERROR_INVALIDDATA;
510  opcode = op_data[oi++];
511  if (!opcode) {
512  v = bytestream2_get_byte(gb);
513  if (v == 255) {
514  do {
515  if (bytestream2_get_bytes_left(gb) <= 0)
516  return AVERROR_INVALIDDATA;
517  opcode = bytestream2_get_le16(gb);
518  v += opcode;
519  } while (opcode == 0xFFFF);
520  }
521  AV_WL32(dst, AV_RL32(dst - (8 + offset)));
522  AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
523  state = v + 4;
524  goto done;
525  }
526 
527  switch (opcode) {
528  case 1:
529  AV_WL32(dst, AV_RL32(dst - (8 + offset)));
530  AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
531  break;
532  case 2:
533  vv = (8 + offset) * (bytestream2_get_le16(gb) + 1);
534  if (vv < 0 || vv > dst - tex_data)
535  return AVERROR_INVALIDDATA;
536  tptr0 = dst - vv;
537  v = AV_RL32(tptr0);
538  AV_WL32(dst, AV_RL32(tptr0));
539  AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
540  tab0[0x9E3779B1 * (uint16_t)v >> 24] = dst;
541  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
542  break;
543  case 3:
544  AV_WL32(dst, bytestream2_get_le32(gb));
545  AV_WL32(dst + 4, bytestream2_get_le32(gb));
546  tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
547  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
548  break;
549  case 4:
550  tptr3 = tab1[bytestream2_get_byte(gb)];
551  if (!tptr3)
552  return AVERROR_INVALIDDATA;
553  AV_WL16(dst, bytestream2_get_le16(gb));
554  AV_WL16(dst + 2, AV_RL16(tptr3));
555  dst[4] = tptr3[2];
556  AV_WL16(dst + 5, bytestream2_get_le16(gb));
557  dst[7] = bytestream2_get_byte(gb);
558  tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
559  break;
560  case 5:
561  tptr3 = tab1[bytestream2_get_byte(gb)];
562  if (!tptr3)
563  return AVERROR_INVALIDDATA;
564  AV_WL16(dst, bytestream2_get_le16(gb));
565  AV_WL16(dst + 2, bytestream2_get_le16(gb));
566  dst[4] = bytestream2_get_byte(gb);
567  AV_WL16(dst + 5, AV_RL16(tptr3));
568  dst[7] = tptr3[2];
569  tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
570  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
571  break;
572  case 6:
573  tptr0 = tab1[bytestream2_get_byte(gb)];
574  if (!tptr0)
575  return AVERROR_INVALIDDATA;
576  tptr1 = tab1[bytestream2_get_byte(gb)];
577  if (!tptr1)
578  return AVERROR_INVALIDDATA;
579  AV_WL16(dst, bytestream2_get_le16(gb));
580  AV_WL16(dst + 2, AV_RL16(tptr0));
581  dst[4] = tptr0[2];
582  AV_WL16(dst + 5, AV_RL16(tptr1));
583  dst[7] = tptr1[2];
584  tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
585  break;
586  case 7:
587  v = (8 + offset) * (bytestream2_get_le16(gb) + 1);
588  if (v < 0 || v > dst - tex_data)
589  return AVERROR_INVALIDDATA;
590  tptr0 = dst - v;
591  AV_WL16(dst, bytestream2_get_le16(gb));
592  AV_WL16(dst + 2, AV_RL16(tptr0 + 2));
593  AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
594  tab0[0x9E3779B1 * AV_RL16(dst) >> 24] = dst;
595  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
596  break;
597  case 8:
598  tptr1 = tab0[bytestream2_get_byte(gb)];
599  if (!tptr1)
600  return AVERROR_INVALIDDATA;
601  AV_WL16(dst, AV_RL16(tptr1));
602  AV_WL16(dst + 2, bytestream2_get_le16(gb));
603  AV_WL32(dst + 4, bytestream2_get_le32(gb));
604  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
605  break;
606  case 9:
607  tptr1 = tab0[bytestream2_get_byte(gb)];
608  if (!tptr1)
609  return AVERROR_INVALIDDATA;
610  tptr3 = tab1[bytestream2_get_byte(gb)];
611  if (!tptr3)
612  return AVERROR_INVALIDDATA;
613  AV_WL16(dst, AV_RL16(tptr1));
614  AV_WL16(dst + 2, AV_RL16(tptr3));
615  dst[4] = tptr3[2];
616  AV_WL16(dst + 5, bytestream2_get_le16(gb));
617  dst[7] = bytestream2_get_byte(gb);
618  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
619  break;
620  case 10:
621  tptr1 = tab0[bytestream2_get_byte(gb)];
622  if (!tptr1)
623  return AVERROR_INVALIDDATA;
624  tptr3 = tab1[bytestream2_get_byte(gb)];
625  if (!tptr3)
626  return AVERROR_INVALIDDATA;
627  AV_WL16(dst, AV_RL16(tptr1));
628  AV_WL16(dst + 2, bytestream2_get_le16(gb));
629  dst[4] = bytestream2_get_byte(gb);
630  AV_WL16(dst + 5, AV_RL16(tptr3));
631  dst[7] = tptr3[2];
632  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
633  break;
634  case 11:
635  tptr0 = tab0[bytestream2_get_byte(gb)];
636  if (!tptr0)
637  return AVERROR_INVALIDDATA;
638  tptr3 = tab1[bytestream2_get_byte(gb)];
639  if (!tptr3)
640  return AVERROR_INVALIDDATA;
641  tptr1 = tab1[bytestream2_get_byte(gb)];
642  if (!tptr1)
643  return AVERROR_INVALIDDATA;
644  AV_WL16(dst, AV_RL16(tptr0));
645  AV_WL16(dst + 2, AV_RL16(tptr3));
646  dst[4] = tptr3[2];
647  AV_WL16(dst + 5, AV_RL16(tptr1));
648  dst[7] = tptr1[2];
649  break;
650  case 12:
651  tptr1 = tab0[bytestream2_get_byte(gb)];
652  if (!tptr1)
653  return AVERROR_INVALIDDATA;
654  v = (8 + offset) * (bytestream2_get_le16(gb) + 1);
655  if (v < 0 || v > dst - tex_data)
656  return AVERROR_INVALIDDATA;
657  tptr0 = dst - v;
658  AV_WL16(dst, AV_RL16(tptr1));
659  AV_WL16(dst + 2, AV_RL16(tptr0 + 2));
660  AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
661  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
662  break;
663  case 13:
664  AV_WL16(dst, AV_RL16(dst - (8 + offset)));
665  AV_WL16(dst + 2, bytestream2_get_le16(gb));
666  AV_WL32(dst + 4, bytestream2_get_le32(gb));
667  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
668  break;
669  case 14:
670  tptr3 = tab1[bytestream2_get_byte(gb)];
671  if (!tptr3)
672  return AVERROR_INVALIDDATA;
673  AV_WL16(dst, AV_RL16(dst - (8 + offset)));
674  AV_WL16(dst + 2, AV_RL16(tptr3));
675  dst[4] = tptr3[2];
676  AV_WL16(dst + 5, bytestream2_get_le16(gb));
677  dst[7] = bytestream2_get_byte(gb);
678  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
679  break;
680  case 15:
681  tptr3 = tab1[bytestream2_get_byte(gb)];
682  if (!tptr3)
683  return AVERROR_INVALIDDATA;
684  AV_WL16(dst, AV_RL16(dst - (8 + offset)));
685  AV_WL16(dst + 2, bytestream2_get_le16(gb));
686  dst[4] = bytestream2_get_byte(gb);
687  AV_WL16(dst + 5, AV_RL16(tptr3));
688  dst[7] = tptr3[2];
689  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
690  break;
691  case 16:
692  tptr3 = tab1[bytestream2_get_byte(gb)];
693  if (!tptr3)
694  return AVERROR_INVALIDDATA;
695  tptr1 = tab1[bytestream2_get_byte(gb)];
696  if (!tptr1)
697  return AVERROR_INVALIDDATA;
698  AV_WL16(dst, AV_RL16(dst - (8 + offset)));
699  AV_WL16(dst + 2, AV_RL16(tptr3));
700  dst[4] = tptr3[2];
701  AV_WL16(dst + 5, AV_RL16(tptr1));
702  dst[7] = tptr1[2];
703  break;
704  case 17:
705  v = (8 + offset) * (bytestream2_get_le16(gb) + 1);
706  if (v < 0 || v > dst - tex_data)
707  return AVERROR_INVALIDDATA;
708  AV_WL16(dst, AV_RL16(dst - (8 + offset)));
709  AV_WL16(dst + 2, AV_RL16(&dst[-v + 2]));
710  AV_WL32(dst + 4, AV_RL32(&dst[-v + 4]));
711  tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
712  break;
713  default:
714  break;
715  }
716  } else {
717 done:
718  AV_WL32(dst, AV_RL32(dst - (8 + offset)));
719  AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
720  state--;
721  }
722  if (dst - tex_data + 8 > tex_size)
723  return AVERROR_INVALIDDATA;
724  dst += 8;
725 
726  *oindex = oi;
727  *dstp = dst;
728  *statep = state;
729 
730  return 0;
731 }
732 
734  uint8_t *tex_data, int tex_size,
735  uint8_t *op_data0, uint8_t *op_data1,
736  int max_op_size0, int max_op_size1)
737 {
738  uint8_t *dst, *tab2[256] = { 0 }, *tab0[256] = { 0 }, *tab3[256] = { 0 }, *tab1[256] = { 0 };
739  int op_offset = bytestream2_get_le32(gb);
740  unsigned op_size0 = bytestream2_get_le32(gb);
741  unsigned op_size1 = bytestream2_get_le32(gb);
742  int data_start = bytestream2_tell(gb);
743  int skip0, skip1, oi0 = 0, oi1 = 0;
744  int ret, state0 = 0, state1 = 0;
745 
746  if (op_offset < 12 || op_offset - 12 > bytestream2_get_bytes_left(gb))
747  return AVERROR_INVALIDDATA;
748 
749  dst = tex_data;
750  bytestream2_skip(gb, op_offset - 12);
751  if (op_size0 > max_op_size0)
752  return AVERROR_INVALIDDATA;
753  skip0 = dxv_decompress_opcodes(gb, op_data0, op_size0);
754  if (skip0 < 0)
755  return skip0;
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 - 12 + op_offset + skip0 + skip1, SEEK_SET);
785 
786  return 0;
787 }
788 
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  if (op_offset < 8 || op_offset - 8 > bytestream2_get_bytes_left(gb))
800  return AVERROR_INVALIDDATA;
801 
802  dst = tex_data;
803  bytestream2_skip(gb, op_offset - 8);
804  if (op_size > max_op_size)
805  return AVERROR_INVALIDDATA;
806  skip = dxv_decompress_opcodes(gb, op_data, op_size);
807  if (skip < 0)
808  return skip;
809  bytestream2_seek(gb, data_start, SEEK_SET);
810 
811  v = bytestream2_get_le32(gb);
812  AV_WL32(dst, v);
813  vv = bytestream2_get_le32(gb);
814  table0[0x9E3779B1 * (uint16_t)v >> 24] = dst;
815  AV_WL32(dst + 4, vv);
816  table1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFF) >> 24] = dst + 2;
817  dst += 8;
818 
819  while (dst < tex_data + tex_size) {
820  ret = dxv_decompress_cgo(ctx, gb, tex_data, tex_size, op_data, &oi, op_size,
821  &dst, &state, table0, table1, 0);
822  if (ret < 0)
823  return ret;
824  }
825 
826  bytestream2_seek(gb, data_start + op_offset + skip - 8, SEEK_SET);
827 
828  return 0;
829 }
830 
832 {
833  DXVContext *ctx = avctx->priv_data;
834  GetByteContext *gb = &ctx->gbc;
835  int ret;
836 
837  ret = dxv_decompress_yo(ctx, gb, ctx->tex_data, ctx->tex_size,
838  ctx->op_data[0], ctx->op_size[0]);
839  if (ret < 0)
840  return ret;
841 
842  return dxv_decompress_cocg(ctx, gb, ctx->ctex_data, ctx->ctex_size,
843  ctx->op_data[1], ctx->op_data[2],
844  ctx->op_size[1], ctx->op_size[2]);
845 }
846 
848 {
849  DXVContext *ctx = avctx->priv_data;
850  GetByteContext *gb = &ctx->gbc;
851  int ret;
852 
853  ret = dxv_decompress_cocg(ctx, gb, ctx->tex_data, ctx->tex_size,
854  ctx->op_data[0], ctx->op_data[3],
855  ctx->op_size[0], ctx->op_size[3]);
856  if (ret < 0)
857  return ret;
858 
859  return dxv_decompress_cocg(ctx, gb, ctx->ctex_data, ctx->ctex_size,
860  ctx->op_data[1], ctx->op_data[2],
861  ctx->op_size[1], ctx->op_size[2]);
862 }
863 
865 {
866  DXVContext *ctx = avctx->priv_data;
867  GetByteContext *gbc = &ctx->gbc;
868  uint32_t value, op;
869  int idx, prev, state = 0;
870  int pos = 4;
871  int run = 0;
872  int probe, check;
873 
874  /* Copy the first four elements */
875  AV_WL32(ctx->tex_data + 0, bytestream2_get_le32(gbc));
876  AV_WL32(ctx->tex_data + 4, bytestream2_get_le32(gbc));
877  AV_WL32(ctx->tex_data + 8, bytestream2_get_le32(gbc));
878  AV_WL32(ctx->tex_data + 12, bytestream2_get_le32(gbc));
879 
880  /* Process input until the whole texture has been filled */
881  while (pos + 2 <= ctx->tex_size / 4) {
882  if (run) {
883  run--;
884 
885  prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
886  AV_WL32(ctx->tex_data + 4 * pos, prev);
887  pos++;
888  prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
889  AV_WL32(ctx->tex_data + 4 * pos, prev);
890  pos++;
891  } else {
892  if (bytestream2_get_bytes_left(gbc) < 1)
893  return AVERROR_INVALIDDATA;
894  if (state == 0) {
895  value = bytestream2_get_le32(gbc);
896  state = 16;
897  }
898  op = value & 0x3;
899  value >>= 2;
900  state--;
901 
902  switch (op) {
903  case 0:
904  /* Long copy */
905  check = bytestream2_get_byte(gbc) + 1;
906  if (check == 256) {
907  do {
908  probe = bytestream2_get_le16(gbc);
909  check += probe;
910  } while (probe == 0xFFFF);
911  }
912  while (check && pos + 4 <= ctx->tex_size / 4) {
913  prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
914  AV_WL32(ctx->tex_data + 4 * pos, prev);
915  pos++;
916 
917  prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
918  AV_WL32(ctx->tex_data + 4 * pos, prev);
919  pos++;
920 
921  prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
922  AV_WL32(ctx->tex_data + 4 * pos, prev);
923  pos++;
924 
925  prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
926  AV_WL32(ctx->tex_data + 4 * pos, prev);
927  pos++;
928 
929  check--;
930  }
931 
932  /* Restart (or exit) the loop */
933  continue;
934  break;
935  case 1:
936  /* Load new run value */
937  run = bytestream2_get_byte(gbc);
938  if (run == 255) {
939  do {
940  probe = bytestream2_get_le16(gbc);
941  run += probe;
942  } while (probe == 0xFFFF);
943  }
944 
945  /* Copy two dwords from previous data */
946  prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
947  AV_WL32(ctx->tex_data + 4 * pos, prev);
948  pos++;
949 
950  prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
951  AV_WL32(ctx->tex_data + 4 * pos, prev);
952  pos++;
953  break;
954  case 2:
955  /* Copy two dwords from a previous index */
956  idx = 8 + bytestream2_get_le16(gbc);
957  if (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4)
958  return AVERROR_INVALIDDATA;
959  prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
960  AV_WL32(ctx->tex_data + 4 * pos, prev);
961  pos++;
962 
963  prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
964  AV_WL32(ctx->tex_data + 4 * pos, prev);
965  pos++;
966  break;
967  case 3:
968  /* Copy two dwords from input */
969  prev = bytestream2_get_le32(gbc);
970  AV_WL32(ctx->tex_data + 4 * pos, prev);
971  pos++;
972 
973  prev = bytestream2_get_le32(gbc);
974  AV_WL32(ctx->tex_data + 4 * pos, prev);
975  pos++;
976  break;
977  }
978  }
979 
980  CHECKPOINT(4);
981  if (pos + 2 > ctx->tex_size / 4)
982  return AVERROR_INVALIDDATA;
983 
984  /* Copy two elements from a previous offset or from the input buffer */
985  if (op) {
986  if (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4)
987  return AVERROR_INVALIDDATA;
988  prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
989  AV_WL32(ctx->tex_data + 4 * pos, prev);
990  pos++;
991 
992  prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
993  AV_WL32(ctx->tex_data + 4 * pos, prev);
994  pos++;
995  } else {
996  CHECKPOINT(4);
997 
998  if (op && (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4))
999  return AVERROR_INVALIDDATA;
1000  if (op)
1001  prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
1002  else
1003  prev = bytestream2_get_le32(gbc);
1004  AV_WL32(ctx->tex_data + 4 * pos, prev);
1005  pos++;
1006 
1007  CHECKPOINT(4);
1008 
1009  if (op)
1010  prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
1011  else
1012  prev = bytestream2_get_le32(gbc);
1013  AV_WL32(ctx->tex_data + 4 * pos, prev);
1014  pos++;
1015  }
1016  }
1017 
1018  return 0;
1019 }
1020 
1022 {
1023  DXVContext *ctx = avctx->priv_data;
1024  return ff_lzf_uncompress(&ctx->gbc, &ctx->tex_data, &ctx->tex_size);
1025 }
1026 
1028 {
1029  DXVContext *ctx = avctx->priv_data;
1030  GetByteContext *gbc = &ctx->gbc;
1031 
1032  if (bytestream2_get_bytes_left(gbc) < ctx->tex_size)
1033  return AVERROR_INVALIDDATA;
1034 
1035  bytestream2_get_buffer(gbc, ctx->tex_data, ctx->tex_size);
1036  return 0;
1037 }
1038 
1039 static int dxv_decode(AVCodecContext *avctx, void *data,
1040  int *got_frame, AVPacket *avpkt)
1041 {
1042  DXVContext *ctx = avctx->priv_data;
1043  ThreadFrame tframe;
1044  GetByteContext *gbc = &ctx->gbc;
1045  int (*decompress_tex)(AVCodecContext *avctx);
1046  const char *msgcomp, *msgtext;
1047  uint32_t tag;
1048  int version_major, version_minor = 0;
1049  int size = 0, old_type = 0;
1050  int ret;
1051 
1052  bytestream2_init(gbc, avpkt->data, avpkt->size);
1053 
1054  ctx->texture_block_h = 4;
1055  ctx->texture_block_w = 4;
1056 
1057  avctx->pix_fmt = AV_PIX_FMT_RGBA;
1058  avctx->colorspace = AVCOL_SPC_RGB;
1059 
1060  ctx->tex_funct = NULL;
1061  ctx->tex_funct_planar[0] = NULL;
1062  ctx->tex_funct_planar[1] = NULL;
1063 
1064  tag = bytestream2_get_le32(gbc);
1065  switch (tag) {
1066  case MKBETAG('D', 'X', 'T', '1'):
1067  decompress_tex = dxv_decompress_dxt1;
1068  ctx->tex_funct = ctx->texdsp.dxt1_block;
1069  ctx->tex_rat = 8;
1070  ctx->tex_step = 8;
1071  msgcomp = "DXTR1";
1072  msgtext = "DXT1";
1073  break;
1074  case MKBETAG('D', 'X', 'T', '5'):
1075  decompress_tex = dxv_decompress_dxt5;
1076  ctx->tex_funct = ctx->texdsp.dxt5_block;
1077  ctx->tex_rat = 4;
1078  ctx->tex_step = 16;
1079  msgcomp = "DXTR5";
1080  msgtext = "DXT5";
1081  break;
1082  case MKBETAG('Y', 'C', 'G', '6'):
1083  decompress_tex = dxv_decompress_ycg6;
1084  ctx->tex_funct_planar[0] = yo_block;
1085  ctx->tex_funct_planar[1] = cocg_block;
1086  ctx->tex_rat = 8;
1087  ctx->tex_step = 32;
1088  ctx->ctex_step = 16;
1089  msgcomp = "YOCOCG6";
1090  msgtext = "YCG6";
1091  ctx->ctex_size = avctx->coded_width * avctx->coded_height / 4;
1092  ctx->texture_block_h = 4;
1093  ctx->texture_block_w = 16;
1094  ctx->ctexture_block_h = 4;
1095  ctx->ctexture_block_w = 4;
1096  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
1097  avctx->colorspace = AVCOL_SPC_YCOCG;
1098  break;
1099  case MKBETAG('Y', 'G', '1', '0'):
1100  decompress_tex = dxv_decompress_yg10;
1101  ctx->tex_funct_planar[0] = yao_block;
1102  ctx->tex_funct_planar[1] = cocg_block;
1103  ctx->tex_rat = 4;
1104  ctx->tex_step = 64;
1105  ctx->ctex_step = 16;
1106  msgcomp = "YAOCOCG10";
1107  msgtext = "YG10";
1108  ctx->ctex_size = avctx->coded_width * avctx->coded_height / 4;
1109  ctx->texture_block_h = 4;
1110  ctx->texture_block_w = 16;
1111  ctx->ctexture_block_h = 4;
1112  ctx->ctexture_block_w = 4;
1113  avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
1114  avctx->colorspace = AVCOL_SPC_YCOCG;
1115  break;
1116  default:
1117  /* Old version does not have a real header, just size and type. */
1118  size = tag & 0x00FFFFFF;
1119  old_type = tag >> 24;
1120  version_major = (old_type & 0x0F) - 1;
1121 
1122  if (old_type & 0x80) {
1123  msgcomp = "RAW";
1124  decompress_tex = dxv_decompress_raw;
1125  } else {
1126  msgcomp = "LZF";
1127  decompress_tex = dxv_decompress_lzf;
1128  }
1129 
1130  if (old_type & 0x40) {
1131  msgtext = "DXT5";
1132 
1133  ctx->tex_funct = ctx->texdsp.dxt5_block;
1134  ctx->tex_step = 16;
1135  } else if (old_type & 0x20 || version_major == 1) {
1136  msgtext = "DXT1";
1137 
1138  ctx->tex_funct = ctx->texdsp.dxt1_block;
1139  ctx->tex_step = 8;
1140  } else {
1141  av_log(avctx, AV_LOG_ERROR, "Unsupported header (0x%08"PRIX32")\n.", tag);
1142  return AVERROR_INVALIDDATA;
1143  }
1144  ctx->tex_rat = 1;
1145  break;
1146  }
1147 
1148  ctx->slice_count = av_clip(avctx->thread_count, 1,
1149  avctx->coded_height / FFMAX(ctx->texture_block_h,
1150  ctx->ctexture_block_h));
1151 
1152  /* New header is 12 bytes long. */
1153  if (!old_type) {
1154  version_major = bytestream2_get_byte(gbc) - 1;
1155  version_minor = bytestream2_get_byte(gbc);
1156 
1157  /* Encoder copies texture data when compression is not advantageous. */
1158  if (bytestream2_get_byte(gbc)) {
1159  msgcomp = "RAW";
1160  ctx->tex_rat = 1;
1161  decompress_tex = dxv_decompress_raw;
1162  }
1163 
1164  bytestream2_skip(gbc, 1); // unknown
1165  size = bytestream2_get_le32(gbc);
1166  }
1167  av_log(avctx, AV_LOG_DEBUG,
1168  "%s compression with %s texture (version %d.%d)\n",
1169  msgcomp, msgtext, version_major, version_minor);
1170 
1171  if (size != bytestream2_get_bytes_left(gbc)) {
1172  av_log(avctx, AV_LOG_ERROR,
1173  "Incomplete or invalid file (header %d, left %u).\n",
1174  size, bytestream2_get_bytes_left(gbc));
1175  return AVERROR_INVALIDDATA;
1176  }
1177 
1178  ctx->tex_size = avctx->coded_width * avctx->coded_height * 4 / ctx->tex_rat;
1180  if (ret < 0)
1181  return ret;
1182 
1183  if (ctx->ctex_size) {
1184  int i;
1185 
1186  ctx->op_size[0] = avctx->coded_width * avctx->coded_height / 16;
1187  ctx->op_size[1] = avctx->coded_width * avctx->coded_height / 32;
1188  ctx->op_size[2] = avctx->coded_width * avctx->coded_height / 32;
1189  ctx->op_size[3] = avctx->coded_width * avctx->coded_height / 16;
1190 
1192  if (ret < 0)
1193  return ret;
1194  for (i = 0; i < 4; i++) {
1195  ret = av_reallocp(&ctx->op_data[i], ctx->op_size[i]);
1196  if (ret < 0)
1197  return ret;
1198  }
1199  }
1200 
1201  /* Decompress texture out of the intermediate compression. */
1202  ret = decompress_tex(avctx);
1203  if (ret < 0)
1204  return ret;
1205  {
1206  int w_block = avctx->coded_width / ctx->texture_block_w;
1207  int h_block = avctx->coded_height / ctx->texture_block_h;
1208  if (w_block * h_block * ctx->tex_step > ctx->tex_size * 8LL)
1209  return AVERROR_INVALIDDATA;
1210  }
1211 
1212  tframe.f = data;
1213  ret = ff_thread_get_buffer(avctx, &tframe, 0);
1214  if (ret < 0)
1215  return ret;
1216 
1217  /* Now decompress the texture with the standard functions. */
1218  avctx->execute2(avctx, decompress_texture_thread,
1219  tframe.f, NULL, ctx->slice_count);
1220 
1221  /* Frame is ready to be output. */
1222  tframe.f->pict_type = AV_PICTURE_TYPE_I;
1223  tframe.f->key_frame = 1;
1224  *got_frame = 1;
1225 
1226  return avpkt->size;
1227 }
1228 
1229 static int dxv_init(AVCodecContext *avctx)
1230 {
1231  DXVContext *ctx = avctx->priv_data;
1232  int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1233 
1234  if (ret < 0) {
1235  av_log(avctx, AV_LOG_ERROR, "Invalid image size %dx%d.\n",
1236  avctx->width, avctx->height);
1237  return ret;
1238  }
1239 
1240  /* Codec requires 16x16 alignment. */
1241  avctx->coded_width = FFALIGN(avctx->width, 16);
1242  avctx->coded_height = FFALIGN(avctx->height, 16);
1243 
1244  ff_texturedsp_init(&ctx->texdsp);
1245 
1246  return 0;
1247 }
1248 
1249 static int dxv_close(AVCodecContext *avctx)
1250 {
1251  DXVContext *ctx = avctx->priv_data;
1252 
1253  av_freep(&ctx->tex_data);
1254  av_freep(&ctx->ctex_data);
1255  av_freep(&ctx->op_data[0]);
1256  av_freep(&ctx->op_data[1]);
1257  av_freep(&ctx->op_data[2]);
1258  av_freep(&ctx->op_data[3]);
1259 
1260  return 0;
1261 }
1262 
1264  .name = "dxv",
1265  .long_name = NULL_IF_CONFIG_SMALL("Resolume DXV"),
1266  .type = AVMEDIA_TYPE_VIDEO,
1267  .id = AV_CODEC_ID_DXV,
1268  .init = dxv_init,
1269  .decode = dxv_decode,
1270  .close = dxv_close,
1271  .priv_data_size = sizeof(DXVContext),
1272  .capabilities = AV_CODEC_CAP_DR1 |
1275  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1277 };
#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
int size
int(* dxt5_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:51
This structure describes decoded (raw) audio or video data.
Definition: frame.h:226
uint8_t val2
Definition: dxv.c:338
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1721
int ctex_step
Definition: dxv.c:43
misc image utilities
AVFrame * f
Definition: thread.h:35
Texture block (4x4) module.
int size
Definition: avcodec.h:1446
int ctexture_block_w
Definition: dxv.c:56
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1743
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
#define AV_RL16
Definition: intreadwrite.h:42
static int dxv_decompress_ycg6(AVCodecContext *avctx)
Definition: dxv.c:831
uint8_t run
Definition: svq3.c:206
#define src
Definition: vp8dsp.c:254
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:3424
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:864
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
const char data[16]
Definition: mxf.c:91
uint8_t * data
Definition: avcodec.h:1445
const uint8_t * buffer
Definition: bytestream.h:34
uint32_t tag
Definition: movenc.c:1478
static int dxv_decompress_yg10(AVCodecContext *avctx)
Definition: dxv.c:847
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:789
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,...)
static const uint16_t table[]
Definition: prosumer.c:206
TextureDSPContext texdsp
Definition: dxv.c:36
int ff_lzf_uncompress(GetByteContext *gb, uint8_t **buf, int64_t *size)
Definition: lzf.c:40
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:258
#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
#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:1263
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:1249
const char * name
Name of the codec implementation.
Definition: avcodec.h:3431
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:1024
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
static int dxv_decompress_lzf(AVCodecContext *avctx)
Definition: dxv.c:1021
Definition: dxv.c:35
static struct @303 state
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:309
#define ff_clz
Definition: intmath.h:142
int64_t op_size[4]
Definition: dxv.c:51
int width
picture width / height.
Definition: avcodec.h:1706
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
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:468
static void decompress_indices(uint8_t *dst, const uint8_t *src)
Definition: dxv.c:66
int slice_count
Definition: dxv.c:48
#define AV_RL32
Definition: intreadwrite.h:146
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:733
int texture_block_h
Definition: dxv.c:54
if(ret< 0)
Definition: vf_mcdeint.c:279
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2785
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1028
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
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:2845
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:257
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:1533
static void yao_subblock(uint8_t *dst, uint8_t *yo_indices, ptrdiff_t stride, const uint8_t *block)
Definition: dxv.c:141
int(* dxt1_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:46
const int16_t * tab1
Definition: mace.c:144
double value
Definition: eval.c:98
int coded_height
Definition: avcodec.h:1721
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2157
static int dxv_init(AVCodecContext *avctx)
Definition: dxv.c:1229
#define AV_RL24
Definition: intreadwrite.h:78
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:240
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
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:1039
common internal api header.
#define flag(name)
Definition: cbs_av1.c:598
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:782
void * priv_data
Definition: avcodec.h:1560
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:304
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
int(* tex_funct)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: dxv.c:60
#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:493
static int extract_component(int yo0, int yo1, int code)
Definition: dxv.c:82
uint8_t * op_data[4]
Definition: dxv.c:50
This structure stores compressed data.
Definition: avcodec.h:1422
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:968
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:1027
#define check(x, y, S, v)
static uint8_t tmp[11]
Definition: aes_ctr.c:26