FFmpeg
dxtory.c
Go to the documentation of this file.
1 /*
2  * Dxtory decoder
3  *
4  * Copyright (c) 2011 Konstantin Shishkov
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 <inttypes.h>
24 
25 #include "libavutil/common.h"
26 #include "libavutil/intreadwrite.h"
27 
28 #define BITSTREAM_READER_LE
29 #include "avcodec.h"
30 #include "bytestream.h"
31 #include "get_bits.h"
32 #include "internal.h"
33 #include "unary.h"
34 
36  const uint8_t *src, int src_size,
37  int id, int bpp)
38 {
39  int h;
40  uint8_t *dst;
41  int ret;
42 
43  if (src_size < avctx->width * avctx->height * (int64_t)bpp) {
44  av_log(avctx, AV_LOG_ERROR, "packet too small\n");
45  return AVERROR_INVALIDDATA;
46  }
47 
48  avctx->pix_fmt = id;
49  if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
50  return ret;
51 
52  dst = pic->data[0];
53  for (h = 0; h < avctx->height; h++) {
54  memcpy(dst, src, avctx->width * bpp);
55  src += avctx->width * bpp;
56  dst += pic->linesize[0];
57  }
58 
59  return 0;
60 }
61 
63  const uint8_t *src, int src_size)
64 {
65  int h, w;
66  uint8_t *Y1, *Y2, *Y3, *Y4, *U, *V;
67  int ret;
68 
69  if (src_size < FFALIGN(avctx->width, 4) * FFALIGN(avctx->height, 4) * 9LL / 8) {
70  av_log(avctx, AV_LOG_ERROR, "packet too small\n");
71  return AVERROR_INVALIDDATA;
72  }
73 
74  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
75  if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
76  return ret;
77 
78  Y1 = pic->data[0];
79  Y2 = pic->data[0] + pic->linesize[0];
80  Y3 = pic->data[0] + pic->linesize[0] * 2;
81  Y4 = pic->data[0] + pic->linesize[0] * 3;
82  U = pic->data[1];
83  V = pic->data[2];
84  for (h = 0; h < avctx->height; h += 4) {
85  for (w = 0; w < avctx->width; w += 4) {
86  AV_COPY32U(Y1 + w, src);
87  AV_COPY32U(Y2 + w, src + 4);
88  AV_COPY32U(Y3 + w, src + 8);
89  AV_COPY32U(Y4 + w, src + 12);
90  U[w >> 2] = src[16] + 0x80;
91  V[w >> 2] = src[17] + 0x80;
92  src += 18;
93  }
94  Y1 += pic->linesize[0] << 2;
95  Y2 += pic->linesize[0] << 2;
96  Y3 += pic->linesize[0] << 2;
97  Y4 += pic->linesize[0] << 2;
98  U += pic->linesize[1];
99  V += pic->linesize[2];
100  }
101 
102  return 0;
103 }
104 
106  const uint8_t *src, int src_size)
107 {
108  int h, w;
109  uint8_t *Y1, *Y2, *U, *V;
110  int ret;
111 
112  if (src_size < FFALIGN(avctx->width, 2) * FFALIGN(avctx->height, 2) * 3LL / 2) {
113  av_log(avctx, AV_LOG_ERROR, "packet too small\n");
114  return AVERROR_INVALIDDATA;
115  }
116 
117  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
118  if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
119  return ret;
120 
121  Y1 = pic->data[0];
122  Y2 = pic->data[0] + pic->linesize[0];
123  U = pic->data[1];
124  V = pic->data[2];
125  for (h = 0; h < avctx->height; h += 2) {
126  for (w = 0; w < avctx->width; w += 2) {
127  AV_COPY16(Y1 + w, src);
128  AV_COPY16(Y2 + w, src + 2);
129  U[w >> 1] = src[4] + 0x80;
130  V[w >> 1] = src[5] + 0x80;
131  src += 6;
132  }
133  Y1 += pic->linesize[0] << 1;
134  Y2 += pic->linesize[0] << 1;
135  U += pic->linesize[1];
136  V += pic->linesize[2];
137  }
138 
139  return 0;
140 }
141 
143  const uint8_t *src, int src_size)
144 {
145  int h, w;
146  uint8_t *Y, *U, *V;
147  int ret;
148 
149  if (src_size < avctx->width * avctx->height * 3LL) {
150  av_log(avctx, AV_LOG_ERROR, "packet too small\n");
151  return AVERROR_INVALIDDATA;
152  }
153 
154  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
155  if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
156  return ret;
157 
158  Y = pic->data[0];
159  U = pic->data[1];
160  V = pic->data[2];
161  for (h = 0; h < avctx->height; h++) {
162  for (w = 0; w < avctx->width; w++) {
163  Y[w] = *src++;
164  U[w] = *src++ ^ 0x80;
165  V[w] = *src++ ^ 0x80;
166  }
167  Y += pic->linesize[0];
168  U += pic->linesize[1];
169  V += pic->linesize[2];
170  }
171 
172  return 0;
173 }
174 
175 static const uint8_t def_lru[8] = { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xFF };
176 static const uint8_t def_lru_555[8] = { 0x00, 0x08, 0x10, 0x18, 0x1F };
177 static const uint8_t def_lru_565[8] = { 0x00, 0x08, 0x10, 0x20, 0x30, 0x3F };
178 
179 static inline uint8_t decode_sym(GetBitContext *gb, uint8_t lru[8])
180 {
181  uint8_t c, val;
182 
183  c = get_unary(gb, 0, 8);
184  if (!c) {
185  val = get_bits(gb, 8);
186  memmove(lru + 1, lru, sizeof(*lru) * (8 - 1));
187  } else {
188  val = lru[c - 1];
189  memmove(lru + 1, lru, sizeof(*lru) * (c - 1));
190  }
191  lru[0] = val;
192 
193  return val;
194 }
195 
197  const uint8_t *src, int src_size,
198  int slice_size, int off)
199 {
200  int cur_slice_size;
201 
202  if (slice_size > src_size - off) {
203  av_log(avctx, AV_LOG_ERROR,
204  "invalid slice size %d (only %d bytes left)\n",
205  slice_size, src_size - off);
206  return AVERROR_INVALIDDATA;
207  }
208  if (slice_size <= 16) {
209  av_log(avctx, AV_LOG_ERROR, "invalid slice size %d\n",
210  slice_size);
211  return AVERROR_INVALIDDATA;
212  }
213 
214  cur_slice_size = AV_RL32(src + off);
215  if (cur_slice_size != slice_size - 16) {
216  av_log(avctx, AV_LOG_ERROR,
217  "Slice sizes mismatch: got %d instead of %d\n",
218  cur_slice_size, slice_size - 16);
219  }
220 
221  return 0;
222 }
223 
224 static int load_buffer(AVCodecContext *avctx,
225  const uint8_t *src, int src_size,
226  GetByteContext *gb,
227  int *nslices, int *off)
228 {
229  bytestream2_init(gb, src, src_size);
230  *nslices = bytestream2_get_le16(gb);
231  *off = FFALIGN(*nslices * 4 + 2, 16);
232  if (src_size < *off) {
233  av_log(avctx, AV_LOG_ERROR, "no slice data\n");
234  return AVERROR_INVALIDDATA;
235  }
236 
237  if (!*nslices) {
238  avpriv_request_sample(avctx, "%d slices for %dx%d", *nslices,
239  avctx->width, avctx->height);
240  return AVERROR_PATCHWELCOME;
241  }
242 
243  return 0;
244 }
245 
246 static inline uint8_t decode_sym_565(GetBitContext *gb, uint8_t lru[8],
247  int bits)
248 {
249  uint8_t c, val;
250 
251  c = get_unary(gb, 0, bits);
252  if (!c) {
253  val = get_bits(gb, bits);
254  memmove(lru + 1, lru, sizeof(*lru) * (6 - 1));
255  } else {
256  val = lru[c - 1];
257  memmove(lru + 1, lru, sizeof(*lru) * (c - 1));
258  }
259  lru[0] = val;
260 
261  return val;
262 }
263 
265  int line, int height, uint8_t lru[3][8]);
266 
267 typedef void (*setup_lru_func)(uint8_t lru[3][8]);
268 
269 static int dxtory_decode_v2(AVCodecContext *avctx, AVFrame *pic,
270  const uint8_t *src, int src_size,
272  setup_lru_func setup_lru,
273  enum AVPixelFormat fmt)
274 {
275  GetByteContext gb, gb_check;
276  GetBitContext gb2;
277  int nslices, slice, line = 0;
278  uint32_t off, slice_size;
279  uint64_t off_check;
280  uint8_t lru[3][8];
281  int ret;
282 
283  ret = load_buffer(avctx, src, src_size, &gb, &nslices, &off);
284  if (ret < 0)
285  return ret;
286 
287  off_check = off;
288  gb_check = gb;
289  for (slice = 0; slice < nslices; slice++) {
290  slice_size = bytestream2_get_le32(&gb_check);
291 
292  if (slice_size <= 16 + (avctx->height * avctx->width / (8 * nslices)))
293  return AVERROR_INVALIDDATA;
294  off_check += slice_size;
295  }
296 
297  if (off_check - avctx->discard_damaged_percentage*off_check/100 > src_size)
298  return AVERROR_INVALIDDATA;
299 
300  avctx->pix_fmt = fmt;
301  if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
302  return ret;
303 
304  for (slice = 0; slice < nslices; slice++) {
305  slice_size = bytestream2_get_le32(&gb);
306 
307  setup_lru(lru);
308 
309  ret = check_slice_size(avctx, src, src_size, slice_size, off);
310  if (ret < 0)
311  return ret;
312 
313  if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)
314  return ret;
315 
316  line += decode_slice(&gb2, pic, line, avctx->height - line, lru);
317 
318  off += slice_size;
319  }
320 
321  if (avctx->height - line) {
322  avpriv_request_sample(avctx, "Not enough slice data available");
323  }
324 
325  return 0;
326 }
327 
330  int line, int left, uint8_t lru[3][8],
331  int is_565)
332 {
333  int x, y;
334  int r, g, b;
335  int width = frame->width;
336  int stride = frame->linesize[0];
337  uint8_t *dst = frame->data[0] + stride * line;
338 
339  for (y = 0; y < left && get_bits_left(gb) > 6 * width; y++) {
340  for (x = 0; x < width; x++) {
341  b = decode_sym_565(gb, lru[0], 5);
342  g = decode_sym_565(gb, lru[1], is_565 ? 6 : 5);
343  r = decode_sym_565(gb, lru[2], 5);
344  dst[x * 3 + 0] = (r << 3) | (r >> 2);
345  dst[x * 3 + 1] = is_565 ? (g << 2) | (g >> 4) : (g << 3) | (g >> 2);
346  dst[x * 3 + 2] = (b << 3) | (b >> 2);
347  }
348 
349  dst += stride;
350  }
351 
352  return y;
353 }
354 
355 static void setup_lru_555(uint8_t lru[3][8])
356 {
357  memcpy(lru[0], def_lru_555, 8 * sizeof(*def_lru));
358  memcpy(lru[1], def_lru_555, 8 * sizeof(*def_lru));
359  memcpy(lru[2], def_lru_555, 8 * sizeof(*def_lru));
360 }
361 
362 static void setup_lru_565(uint8_t lru[3][8])
363 {
364  memcpy(lru[0], def_lru_555, 8 * sizeof(*def_lru));
365  memcpy(lru[1], def_lru_565, 8 * sizeof(*def_lru));
366  memcpy(lru[2], def_lru_555, 8 * sizeof(*def_lru));
367 }
368 
370  int line, int left, uint8_t lru[3][8])
371 {
372  return dx2_decode_slice_5x5(gb, frame, line, left, lru, 0);
373 }
374 
376  int line, int left, uint8_t lru[3][8])
377 {
378  return dx2_decode_slice_5x5(gb, frame, line, left, lru, 1);
379 }
380 
382  const uint8_t *src, int src_size, int is_565)
383 {
385  if (is_565)
386  return dxtory_decode_v2(avctx, pic, src, src_size,
389  fmt);
390  else
391  return dxtory_decode_v2(avctx, pic, src, src_size,
394  fmt);
395 }
396 
398  int line, int left, uint8_t lru[3][8])
399 {
400  int x, y;
401  int width = frame->width;
402  int stride = frame->linesize[0];
403  uint8_t *dst = frame->data[0] + stride * line;
404 
405  for (y = 0; y < left && get_bits_left(gb) > 6 * width; y++) {
406  for (x = 0; x < width; x++) {
407  dst[x * 3 + 0] = decode_sym(gb, lru[0]);
408  dst[x * 3 + 1] = decode_sym(gb, lru[1]);
409  dst[x * 3 + 2] = decode_sym(gb, lru[2]);
410  }
411 
412  dst += stride;
413  }
414 
415  return y;
416 }
417 
418 static void default_setup_lru(uint8_t lru[3][8])
419 {
420  int i;
421 
422  for (i = 0; i < 3; i++)
423  memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
424 }
425 
427  const uint8_t *src, int src_size)
428 {
429  return dxtory_decode_v2(avctx, pic, src, src_size,
433 }
434 
436  int line, int left,
437  uint8_t lru[3][8])
438 {
439  int x, y, i, j;
440  int width = frame->width;
441 
442  int ystride = frame->linesize[0];
443  int ustride = frame->linesize[1];
444  int vstride = frame->linesize[2];
445 
446  uint8_t *Y = frame->data[0] + ystride * line;
447  uint8_t *U = frame->data[1] + (ustride >> 2) * line;
448  uint8_t *V = frame->data[2] + (vstride >> 2) * line;
449 
450  for (y = 0; y < left - 3 && get_bits_left(gb) > 9 * width; y += 4) {
451  for (x = 0; x < width; x += 4) {
452  for (j = 0; j < 4; j++)
453  for (i = 0; i < 4; i++)
454  Y[x + i + j * ystride] = decode_sym(gb, lru[0]);
455  U[x >> 2] = decode_sym(gb, lru[1]) ^ 0x80;
456  V[x >> 2] = decode_sym(gb, lru[2]) ^ 0x80;
457  }
458 
459  Y += ystride << 2;
460  U += ustride;
461  V += vstride;
462  }
463 
464  return y;
465 }
466 
467 
469  const uint8_t *src, int src_size)
470 {
471  return dxtory_decode_v2(avctx, pic, src, src_size,
475 }
476 
478  int line, int left,
479  uint8_t lru[3][8])
480 {
481  int x, y;
482 
483  int width = frame->width;
484 
485  int ystride = frame->linesize[0];
486  int ustride = frame->linesize[1];
487  int vstride = frame->linesize[2];
488 
489  uint8_t *Y = frame->data[0] + ystride * line;
490  uint8_t *U = frame->data[1] + (ustride >> 1) * line;
491  uint8_t *V = frame->data[2] + (vstride >> 1) * line;
492 
493 
494  for (y = 0; y < left - 1 && get_bits_left(gb) > 6 * width; y += 2) {
495  for (x = 0; x < width; x += 2) {
496  Y[x + 0 + 0 * ystride] = decode_sym(gb, lru[0]);
497  Y[x + 1 + 0 * ystride] = decode_sym(gb, lru[0]);
498  Y[x + 0 + 1 * ystride] = decode_sym(gb, lru[0]);
499  Y[x + 1 + 1 * ystride] = decode_sym(gb, lru[0]);
500  U[x >> 1] = decode_sym(gb, lru[1]) ^ 0x80;
501  V[x >> 1] = decode_sym(gb, lru[2]) ^ 0x80;
502  }
503 
504  Y += ystride << 1;
505  U += ustride;
506  V += vstride;
507  }
508 
509  return y;
510 }
511 
513  const uint8_t *src, int src_size)
514 {
515  return dxtory_decode_v2(avctx, pic, src, src_size,
519 }
520 
522  int line, int left,
523  uint8_t lru[3][8])
524 {
525  int x, y;
526 
527  int width = frame->width;
528 
529  int ystride = frame->linesize[0];
530  int ustride = frame->linesize[1];
531  int vstride = frame->linesize[2];
532 
533  uint8_t *Y = frame->data[0] + ystride * line;
534  uint8_t *U = frame->data[1] + ustride * line;
535  uint8_t *V = frame->data[2] + vstride * line;
536 
537  for (y = 0; y < left && get_bits_left(gb) > 6 * width; y++) {
538  for (x = 0; x < width; x++) {
539  Y[x] = decode_sym(gb, lru[0]);
540  U[x] = decode_sym(gb, lru[1]) ^ 0x80;
541  V[x] = decode_sym(gb, lru[2]) ^ 0x80;
542  }
543 
544  Y += ystride;
545  U += ustride;
546  V += vstride;
547  }
548 
549  return y;
550 }
551 
553  const uint8_t *src, int src_size)
554 {
555  return dxtory_decode_v2(avctx, pic, src, src_size,
559 }
560 
561 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
562  AVPacket *avpkt)
563 {
564  AVFrame *pic = data;
565  const uint8_t *src = avpkt->data;
566  int ret;
567 
568  if (avpkt->size < 16) {
569  av_log(avctx, AV_LOG_ERROR, "packet too small\n");
570  return AVERROR_INVALIDDATA;
571  }
572 
573  switch (AV_RB32(src)) {
574  case 0x01000001:
575  ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
576  AV_PIX_FMT_BGR24, 3);
577  break;
578  case 0x01000009:
579  ret = dxtory_decode_v2_rgb(avctx, pic, src + 16, avpkt->size - 16);
580  break;
581  case 0x02000001:
582  ret = dxtory_decode_v1_420(avctx, pic, src + 16, avpkt->size - 16);
583  break;
584  case 0x02000009:
585  ret = dxtory_decode_v2_420(avctx, pic, src + 16, avpkt->size - 16);
586  break;
587  case 0x03000001:
588  ret = dxtory_decode_v1_410(avctx, pic, src + 16, avpkt->size - 16);
589  break;
590  case 0x03000009:
591  ret = dxtory_decode_v2_410(avctx, pic, src + 16, avpkt->size - 16);
592  break;
593  case 0x04000001:
594  ret = dxtory_decode_v1_444(avctx, pic, src + 16, avpkt->size - 16);
595  break;
596  case 0x04000009:
597  ret = dxtory_decode_v2_444(avctx, pic, src + 16, avpkt->size - 16);
598  break;
599  case 0x17000001:
600  ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
602  break;
603  case 0x17000009:
604  ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 1);
605  break;
606  case 0x18000001:
607  case 0x19000001:
608  ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
610  break;
611  case 0x18000009:
612  case 0x19000009:
613  ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 0);
614  break;
615  default:
616  avpriv_request_sample(avctx, "Frame header %"PRIX32, AV_RB32(src));
617  return AVERROR_PATCHWELCOME;
618  }
619 
620  if (ret)
621  return ret;
622 
624  pic->key_frame = 1;
625  *got_frame = 1;
626 
627  return avpkt->size;
628 }
629 
631  .name = "dxtory",
632  .long_name = NULL_IF_CONFIG_SMALL("Dxtory"),
633  .type = AVMEDIA_TYPE_VIDEO,
634  .id = AV_CODEC_ID_DXTORY,
635  .decode = decode_frame,
636  .capabilities = AV_CODEC_CAP_DR1,
637 };
static int dxtory_decode_v2_rgb(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)
Definition: dxtory.c:426
const char const char void * val
Definition: avisynth_c.h:863
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
const char * fmt
Definition: avisynth_c.h:861
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
const char * g
Definition: vf_curves.c:115
static int decode_slice(AVCodecContext *c, void *arg)
Definition: ffv1dec.c:246
static void default_setup_lru(uint8_t lru[3][8])
Definition: dxtory.c:418
#define avpriv_request_sample(...)
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:108
int size
Definition: avcodec.h:1481
static const uint8_t def_lru_555[8]
Definition: dxtory.c:176
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3492
static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)
Definition: dxtory.c:512
static int dx2_decode_slice_565(GetBitContext *gb, AVFrame *frame, int line, int left, uint8_t lru[3][8])
Definition: dxtory.c:375
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
uint8_t
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
static int dxtory_decode_v2_444(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)
Definition: dxtory.c:552
int(* decode_slice_func)(GetBitContext *gb, AVFrame *frame, int line, int height, uint8_t lru[3][8])
Definition: dxtory.c:264
static int dxtory_decode_v1_420(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)
Definition: dxtory.c:105
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
static av_always_inline int dx2_decode_slice_5x5(GetBitContext *gb, AVFrame *frame, int line, int left, uint8_t lru[3][8], int is_565)
Definition: dxtory.c:329
static int dxtory_decode_v1_410(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)
Definition: dxtory.c:62
#define height
uint8_t * data
Definition: avcodec.h:1480
bitstream reader API header.
static int dxtory_decode_v1_444(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)
Definition: dxtory.c:142
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
static int dxtory_decode_v2(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size, decode_slice_func decode_slice, setup_lru_func setup_lru, enum AVPixelFormat fmt)
Definition: dxtory.c:269
void(* setup_lru_func)(uint8_t lru[3][8])
Definition: dxtory.c:267
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static const uint8_t def_lru[8]
Definition: dxtory.c:175
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static void setup_lru_555(uint8_t lru[3][8])
Definition: dxtory.c:355
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static int dx2_decode_slice_420(GetBitContext *gb, AVFrame *frame, int line, int left, uint8_t lru[3][8])
Definition: dxtory.c:477
const char * r
Definition: vf_curves.c:114
Definition: graph2dot.c:48
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
uint8_t bits
Definition: vp3data.h:202
#define b
Definition: input.c:41
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define Y
Definition: boxblur.h:38
#define AV_COPY16(d, s)
Definition: intreadwrite.h:597
#define width
int width
picture width / height.
Definition: avcodec.h:1741
uint8_t w
Definition: llviddspenc.c:38
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static int dx2_decode_slice_410(GetBitContext *gb, AVFrame *frame, int line, int left, uint8_t lru[3][8])
Definition: dxtory.c:435
static int dx2_decode_slice_rgb(GetBitContext *gb, AVFrame *frame, int line, int left, uint8_t lru[3][8])
Definition: dxtory.c:397
#define AV_COPY32U(d, s)
Definition: intreadwrite.h:572
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
static int dx2_decode_slice_555(GetBitContext *gb, AVFrame *frame, int line, int left, uint8_t lru[3][8])
Definition: dxtory.c:369
static uint8_t decode_sym(GetBitContext *gb, uint8_t lru[8])
Definition: dxtory.c:179
static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)
Definition: dxtory.c:468
static int load_buffer(AVCodecContext *avctx, const uint8_t *src, int src_size, GetByteContext *gb, int *nslices, int *off)
Definition: dxtory.c:224
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AVCodec ff_dxtory_decoder
Definition: dxtory.c:630
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:3375
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
static int dxtory_decode_v2_565(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size, int is_565)
Definition: dxtory.c:381
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:1568
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
static int check_slice_size(AVCodecContext *avctx, const uint8_t *src, int src_size, int slice_size, int off)
Definition: dxtory.c:196
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
static const uint8_t def_lru_565[8]
Definition: dxtory.c:177
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
int
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
Definition: swscale.txt:33
common internal api header.
common internal and external API header
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
static int dx2_decode_slice_444(GetBitContext *gb, AVFrame *frame, int line, int left, uint8_t lru[3][8])
Definition: dxtory.c:521
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
static int dxtory_decode_v1_rgb(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size, int id, int bpp)
Definition: dxtory.c:35
#define av_always_inline
Definition: attributes.h:39
#define stride
enum AVCodecID id
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1457
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
static uint8_t decode_sym_565(GetBitContext *gb, uint8_t lru[8], int bits)
Definition: dxtory.c:246
#define V
Definition: avdct.c:30
static void setup_lru_565(uint8_t lru[3][8])
Definition: dxtory.c:362
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dxtory.c:561