4 * Copyright (c) 2011 Konstantin Shishkov
6 * This file is part of FFmpeg.
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.
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.
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
25 #define BITSTREAM_READER_LE
27 #include "bytestream.h"
31 #include "libavutil/common.h"
32 #include "libavutil/intreadwrite.h"
34 static int dxtory_decode_v1_rgb(AVCodecContext
*avctx
, AVFrame
*pic
,
35 const uint8_t *src
, int src_size
,
42 if (src_size
< avctx
->width
* avctx
->height
* (int64_t)bpp
) {
43 av_log(avctx
, AV_LOG_ERROR
, "packet too small\n");
44 return AVERROR_INVALIDDATA
;
48 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
52 for (h
= 0; h
< avctx
->height
; h
++) {
53 memcpy(dst
, src
, avctx
->width
* bpp
);
54 src
+= avctx
->width
* bpp
;
55 dst
+= pic
->linesize
[0];
61 static int dxtory_decode_v1_410(AVCodecContext
*avctx
, AVFrame
*pic
,
62 const uint8_t *src
, int src_size
)
65 uint8_t *Y1
, *Y2
, *Y3
, *Y4
, *U
, *V
;
68 if (src_size
< avctx
->width
* avctx
->height
* 9L / 8) {
69 av_log(avctx
, AV_LOG_ERROR
, "packet too small\n");
70 return AVERROR_INVALIDDATA
;
73 avctx
->pix_fmt
= AV_PIX_FMT_YUV410P
;
74 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
78 Y2
= pic
->data
[0] + pic
->linesize
[0];
79 Y3
= pic
->data
[0] + pic
->linesize
[0] * 2;
80 Y4
= pic
->data
[0] + pic
->linesize
[0] * 3;
83 for (h
= 0; h
< avctx
->height
; h
+= 4) {
84 for (w
= 0; w
< avctx
->width
; w
+= 4) {
85 AV_COPY32(Y1
+ w
, src
);
86 AV_COPY32(Y2
+ w
, src
+ 4);
87 AV_COPY32(Y3
+ w
, src
+ 8);
88 AV_COPY32(Y4
+ w
, src
+ 12);
89 U
[w
>> 2] = src
[16] + 0x80;
90 V
[w
>> 2] = src
[17] + 0x80;
93 Y1
+= pic
->linesize
[0] << 2;
94 Y2
+= pic
->linesize
[0] << 2;
95 Y3
+= pic
->linesize
[0] << 2;
96 Y4
+= pic
->linesize
[0] << 2;
97 U
+= pic
->linesize
[1];
98 V
+= pic
->linesize
[2];
104 static int dxtory_decode_v1_420(AVCodecContext
*avctx
, AVFrame
*pic
,
105 const uint8_t *src
, int src_size
)
108 uint8_t *Y1
, *Y2
, *U
, *V
;
111 if (src_size
< avctx
->width
* avctx
->height
* 3L / 2) {
112 av_log(avctx
, AV_LOG_ERROR
, "packet too small\n");
113 return AVERROR_INVALIDDATA
;
116 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
117 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
121 Y2
= pic
->data
[0] + pic
->linesize
[0];
124 for (h
= 0; h
< avctx
->height
; h
+= 2) {
125 for (w
= 0; w
< avctx
->width
; w
+= 2) {
126 AV_COPY16(Y1
+ w
, src
);
127 AV_COPY16(Y2
+ w
, src
+ 2);
128 U
[w
>> 1] = src
[4] + 0x80;
129 V
[w
>> 1] = src
[5] + 0x80;
132 Y1
+= pic
->linesize
[0] << 1;
133 Y2
+= pic
->linesize
[0] << 1;
134 U
+= pic
->linesize
[1];
135 V
+= pic
->linesize
[2];
141 static int dxtory_decode_v1_444(AVCodecContext
*avctx
, AVFrame
*pic
,
142 const uint8_t *src
, int src_size
)
148 if (src_size
< avctx
->width
* avctx
->height
* 3L) {
149 av_log(avctx
, AV_LOG_ERROR
, "packet too small\n");
150 return AVERROR_INVALIDDATA
;
153 avctx
->pix_fmt
= AV_PIX_FMT_YUV444P
;
154 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
160 for (h
= 0; h
< avctx
->height
; h
++) {
161 for (w
= 0; w
< avctx
->width
; w
++) {
163 U
[w
] = *src
++ ^ 0x80;
164 V
[w
] = *src
++ ^ 0x80;
166 Y
+= pic
->linesize
[0];
167 U
+= pic
->linesize
[1];
168 V
+= pic
->linesize
[2];
174 static const uint8_t def_lru
[8] = { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xFF };
175 static const uint8_t def_lru_555
[8] = { 0x00, 0x08, 0x10, 0x18, 0x1F };
176 static const uint8_t def_lru_565
[8] = { 0x00, 0x08, 0x10, 0x20, 0x30, 0x3F };
178 static inline uint8_t decode_sym(GetBitContext
*gb
, uint8_t lru
[8])
182 c
= get_unary(gb
, 0, 8);
184 val
= get_bits(gb
, 8);
185 memmove(lru
+ 1, lru
, sizeof(*lru
) * (8 - 1));
188 memmove(lru
+ 1, lru
, sizeof(*lru
) * (c
- 1));
195 static inline uint8_t decode_sym_565(GetBitContext
*gb
, uint8_t lru
[8],
200 c
= get_unary(gb
, 0, bits
);
202 val
= get_bits(gb
, bits
);
203 memmove(lru
+ 1, lru
, sizeof(*lru
) * (6 - 1));
206 memmove(lru
+ 1, lru
, sizeof(*lru
) * (c
- 1));
213 static int dx2_decode_slice_565(GetBitContext
*gb
, int width
, int height
,
214 uint8_t *dst
, int stride
, int is_565
)
220 memcpy(lru
[0], def_lru_555
, 8 * sizeof(*def_lru
));
221 memcpy(lru
[1], is_565
? def_lru_565
: def_lru_555
, 8 * sizeof(*def_lru
));
222 memcpy(lru
[2], def_lru_555
, 8 * sizeof(*def_lru
));
224 for (y
= 0; y
< height
; y
++) {
225 for (x
= 0; x
< width
; x
++) {
226 b
= decode_sym_565(gb
, lru
[0], 5);
227 g
= decode_sym_565(gb
, lru
[1], is_565
? 6 : 5);
228 r
= decode_sym_565(gb
, lru
[2], 5);
229 dst
[x
* 3 + 0] = (r
<< 3) | (r
>> 2);
230 dst
[x
* 3 + 1] = is_565
? (g
<< 2) | (g
>> 4) : (g
<< 3) | (g
>> 2);
231 dst
[x
* 3 + 2] = (b
<< 3) | (b
>> 2);
240 static int dxtory_decode_v2_565(AVCodecContext
*avctx
, AVFrame
*pic
,
241 const uint8_t *src
, int src_size
, int is_565
)
245 int nslices
, slice
, slice_height
;
246 uint32_t off
, slice_size
;
250 bytestream2_init(&gb
, src
, src_size
);
251 nslices
= bytestream2_get_le16(&gb
);
252 off
= FFALIGN(nslices
* 4 + 2, 16);
253 if (src_size
< off
) {
254 av_log(avctx
, AV_LOG_ERROR
, "no slice data\n");
255 return AVERROR_INVALIDDATA
;
258 if (!nslices
|| avctx
->height
% nslices
) {
259 avpriv_request_sample(avctx
, "%d slices for %dx%d", nslices
,
260 avctx
->width
, avctx
->height
);
261 return AVERROR_PATCHWELCOME
;
264 slice_height
= avctx
->height
/ nslices
;
265 avctx
->pix_fmt
= AV_PIX_FMT_RGB24
;
266 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
270 for (slice
= 0; slice
< nslices
; slice
++) {
271 slice_size
= bytestream2_get_le32(&gb
);
272 if (slice_size
> src_size
- off
) {
273 av_log(avctx
, AV_LOG_ERROR
,
274 "invalid slice size %"PRIu32
" (only %"PRIu32
" bytes left)\n",
275 slice_size
, src_size
- off
);
276 return AVERROR_INVALIDDATA
;
278 if (slice_size
<= 16) {
279 av_log(avctx
, AV_LOG_ERROR
, "invalid slice size %"PRIu32
"\n", slice_size
);
280 return AVERROR_INVALIDDATA
;
283 if (AV_RL32(src
+ off
) != slice_size
- 16) {
284 av_log(avctx
, AV_LOG_ERROR
,
285 "Slice sizes mismatch: got %"PRIu32
" instead of %"PRIu32
"\n",
286 AV_RL32(src
+ off
), slice_size
- 16);
288 init_get_bits(&gb2
, src
+ off
+ 16, (slice_size
- 16) * 8);
289 dx2_decode_slice_565(&gb2
, avctx
->width
, slice_height
, dst
,
290 pic
->linesize
[0], is_565
);
292 dst
+= pic
->linesize
[0] * slice_height
;
299 static int dx2_decode_slice_rgb(GetBitContext
*gb
, int width
, int height
,
300 uint8_t *dst
, int stride
)
305 for (i
= 0; i
< 3; i
++)
306 memcpy(lru
[i
], def_lru
, 8 * sizeof(*def_lru
));
308 for (y
= 0; y
< height
; y
++) {
309 for (x
= 0; x
< width
; x
++) {
310 dst
[x
* 3 + 0] = decode_sym(gb
, lru
[0]);
311 dst
[x
* 3 + 1] = decode_sym(gb
, lru
[1]);
312 dst
[x
* 3 + 2] = decode_sym(gb
, lru
[2]);
321 static int dxtory_decode_v2_rgb(AVCodecContext
*avctx
, AVFrame
*pic
,
322 const uint8_t *src
, int src_size
)
326 int nslices
, slice
, slice_height
;
327 uint32_t off
, slice_size
;
331 bytestream2_init(&gb
, src
, src_size
);
332 nslices
= bytestream2_get_le16(&gb
);
333 off
= FFALIGN(nslices
* 4 + 2, 16);
334 if (src_size
< off
) {
335 av_log(avctx
, AV_LOG_ERROR
, "no slice data\n");
336 return AVERROR_INVALIDDATA
;
339 if (!nslices
|| avctx
->height
% nslices
) {
340 avpriv_request_sample(avctx
, "%d slices for %dx%d", nslices
,
341 avctx
->width
, avctx
->height
);
342 return AVERROR_PATCHWELCOME
;
345 slice_height
= avctx
->height
/ nslices
;
346 avctx
->pix_fmt
= AV_PIX_FMT_BGR24
;
347 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
351 for (slice
= 0; slice
< nslices
; slice
++) {
352 slice_size
= bytestream2_get_le32(&gb
);
353 if (slice_size
> src_size
- off
) {
354 av_log(avctx
, AV_LOG_ERROR
,
355 "invalid slice size %"PRIu32
" (only %"PRIu32
" bytes left)\n",
356 slice_size
, src_size
- off
);
357 return AVERROR_INVALIDDATA
;
359 if (slice_size
<= 16) {
360 av_log(avctx
, AV_LOG_ERROR
, "invalid slice size %"PRIu32
"\n",
362 return AVERROR_INVALIDDATA
;
365 if (AV_RL32(src
+ off
) != slice_size
- 16) {
366 av_log(avctx
, AV_LOG_ERROR
,
367 "Slice sizes mismatch: got %"PRIu32
" instead of %"PRIu32
"\n",
368 AV_RL32(src
+ off
), slice_size
- 16);
370 init_get_bits(&gb2
, src
+ off
+ 16, (slice_size
- 16) * 8);
371 dx2_decode_slice_rgb(&gb2
, avctx
->width
, slice_height
, dst
,
374 dst
+= pic
->linesize
[0] * slice_height
;
381 static int dx2_decode_slice_410(GetBitContext
*gb
, int width
, int height
,
382 uint8_t *Y
, uint8_t *U
, uint8_t *V
,
383 int ystride
, int ustride
, int vstride
)
388 for (i
= 0; i
< 3; i
++)
389 memcpy(lru
[i
], def_lru
, 8 * sizeof(*def_lru
));
391 for (y
= 0; y
< height
; y
+= 4) {
392 for (x
= 0; x
< width
; x
+= 4) {
393 for (j
= 0; j
< 4; j
++)
394 for (i
= 0; i
< 4; i
++)
395 Y
[x
+ i
+ j
* ystride
] = decode_sym(gb
, lru
[0]);
396 U
[x
>> 2] = decode_sym(gb
, lru
[1]) ^ 0x80;
397 V
[x
>> 2] = decode_sym(gb
, lru
[2]) ^ 0x80;
408 static int dxtory_decode_v2_410(AVCodecContext
*avctx
, AVFrame
*pic
,
409 const uint8_t *src
, int src_size
)
413 int nslices
, slice
, slice_height
, ref_slice_height
;
415 uint32_t off
, slice_size
;
419 bytestream2_init(&gb
, src
, src_size
);
420 nslices
= bytestream2_get_le16(&gb
);
421 off
= FFALIGN(nslices
* 4 + 2, 16);
422 if (src_size
< off
) {
423 av_log(avctx
, AV_LOG_ERROR
, "no slice data\n");
424 return AVERROR_INVALIDDATA
;
427 if (!nslices
|| avctx
->height
% nslices
) {
428 avpriv_request_sample(avctx
, "%d slices for %dx%d", nslices
,
429 avctx
->width
, avctx
->height
);
430 return AVERROR_PATCHWELCOME
;
433 ref_slice_height
= avctx
->height
/ nslices
;
434 if ((avctx
->width
& 3) || (avctx
->height
& 3)) {
435 avpriv_request_sample(avctx
, "Frame dimensions %dx%d",
436 avctx
->width
, avctx
->height
);
439 avctx
->pix_fmt
= AV_PIX_FMT_YUV410P
;
440 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
448 next_y
= ref_slice_height
;
449 for (slice
= 0; slice
< nslices
; slice
++) {
450 slice_size
= bytestream2_get_le32(&gb
);
451 slice_height
= (next_y
& ~3) - (cur_y
& ~3);
452 if (slice_size
> src_size
- off
) {
453 av_log(avctx
, AV_LOG_ERROR
,
454 "invalid slice size %"PRIu32
" (only %"PRIu32
" bytes left)\n",
455 slice_size
, src_size
- off
);
456 return AVERROR_INVALIDDATA
;
458 if (slice_size
<= 16) {
459 av_log(avctx
, AV_LOG_ERROR
, "invalid slice size %"PRIu32
"\n", slice_size
);
460 return AVERROR_INVALIDDATA
;
463 if (AV_RL32(src
+ off
) != slice_size
- 16) {
464 av_log(avctx
, AV_LOG_ERROR
,
465 "Slice sizes mismatch: got %"PRIu32
" instead of %"PRIu32
"\n",
466 AV_RL32(src
+ off
), slice_size
- 16);
468 init_get_bits(&gb2
, src
+ off
+ 16, (slice_size
- 16) * 8);
469 dx2_decode_slice_410(&gb2
, avctx
->width
, slice_height
, Y
, U
, V
,
470 pic
->linesize
[0], pic
->linesize
[1],
473 Y
+= pic
->linesize
[0] * slice_height
;
474 U
+= pic
->linesize
[1] * (slice_height
>> 2);
475 V
+= pic
->linesize
[2] * (slice_height
>> 2);
478 next_y
+= ref_slice_height
;
484 static int dx2_decode_slice_420(GetBitContext
*gb
, int width
, int height
,
485 uint8_t *Y
, uint8_t *U
, uint8_t *V
,
486 int ystride
, int ustride
, int vstride
)
491 for (i
= 0; i
< 3; i
++)
492 memcpy(lru
[i
], def_lru
, 8 * sizeof(*def_lru
));
494 for (y
= 0; y
< height
; 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;
512 static int dxtory_decode_v2_420(AVCodecContext
*avctx
, AVFrame
*pic
,
513 const uint8_t *src
, int src_size
)
517 int nslices
, slice
, slice_height
, ref_slice_height
;
519 uint32_t off
, slice_size
;
523 bytestream2_init(&gb
, src
, src_size
);
524 nslices
= bytestream2_get_le16(&gb
);
525 off
= FFALIGN(nslices
* 4 + 2, 16);
526 if (src_size
< off
) {
527 av_log(avctx
, AV_LOG_ERROR
, "no slice data\n");
528 return AVERROR_INVALIDDATA
;
531 if (!nslices
|| avctx
->height
% nslices
) {
532 avpriv_request_sample(avctx
, "%d slices for %dx%d", nslices
,
533 avctx
->width
, avctx
->height
);
534 return AVERROR_PATCHWELCOME
;
537 ref_slice_height
= avctx
->height
/ nslices
;
538 if ((avctx
->width
& 1) || (avctx
->height
& 1)) {
539 avpriv_request_sample(avctx
, "Frame dimensions %dx%d",
540 avctx
->width
, avctx
->height
);
543 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
544 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
552 next_y
= ref_slice_height
;
553 for (slice
= 0; slice
< nslices
; slice
++) {
554 slice_size
= bytestream2_get_le32(&gb
);
555 slice_height
= (next_y
& ~1) - (cur_y
& ~1);
556 if (slice_size
> src_size
- off
) {
557 av_log(avctx
, AV_LOG_ERROR
,
558 "invalid slice size %"PRIu32
" (only %"PRIu32
" bytes left)\n",
559 slice_size
, src_size
- off
);
560 return AVERROR_INVALIDDATA
;
562 if (slice_size
<= 16) {
563 av_log(avctx
, AV_LOG_ERROR
, "invalid slice size %"PRIu32
"\n", slice_size
);
564 return AVERROR_INVALIDDATA
;
567 if (AV_RL32(src
+ off
) != slice_size
- 16) {
568 av_log(avctx
, AV_LOG_ERROR
,
569 "Slice sizes mismatch: got %"PRIu32
" instead of %"PRIu32
"\n",
570 AV_RL32(src
+ off
), slice_size
- 16);
572 init_get_bits(&gb2
, src
+ off
+ 16, (slice_size
- 16) * 8);
573 dx2_decode_slice_420(&gb2
, avctx
->width
, slice_height
, Y
, U
, V
,
574 pic
->linesize
[0], pic
->linesize
[1],
577 Y
+= pic
->linesize
[0] * slice_height
;
578 U
+= pic
->linesize
[1] * (slice_height
>> 1);
579 V
+= pic
->linesize
[2] * (slice_height
>> 1);
582 next_y
+= ref_slice_height
;
588 static int dx2_decode_slice_444(GetBitContext
*gb
, int width
, int height
,
589 uint8_t *Y
, uint8_t *U
, uint8_t *V
,
590 int ystride
, int ustride
, int vstride
)
595 for (i
= 0; i
< 3; i
++)
596 memcpy(lru
[i
], def_lru
, 8 * sizeof(*def_lru
));
598 for (y
= 0; y
< height
; y
++) {
599 for (x
= 0; x
< width
; x
++) {
600 Y
[x
] = decode_sym(gb
, lru
[0]);
601 U
[x
] = decode_sym(gb
, lru
[1]) ^ 0x80;
602 V
[x
] = decode_sym(gb
, lru
[2]) ^ 0x80;
613 static int dxtory_decode_v2_444(AVCodecContext
*avctx
, AVFrame
*pic
,
614 const uint8_t *src
, int src_size
)
618 int nslices
, slice
, slice_height
;
619 uint32_t off
, slice_size
;
623 bytestream2_init(&gb
, src
, src_size
);
624 nslices
= bytestream2_get_le16(&gb
);
625 off
= FFALIGN(nslices
* 4 + 2, 16);
626 if (src_size
< off
) {
627 av_log(avctx
, AV_LOG_ERROR
, "no slice data\n");
628 return AVERROR_INVALIDDATA
;
631 if (!nslices
|| avctx
->height
% nslices
) {
632 avpriv_request_sample(avctx
, "%d slices for %dx%d", nslices
,
633 avctx
->width
, avctx
->height
);
634 return AVERROR_PATCHWELCOME
;
637 slice_height
= avctx
->height
/ nslices
;
639 avctx
->pix_fmt
= AV_PIX_FMT_YUV444P
;
640 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
647 for (slice
= 0; slice
< nslices
; slice
++) {
648 slice_size
= bytestream2_get_le32(&gb
);
649 if (slice_size
> src_size
- off
) {
650 av_log(avctx
, AV_LOG_ERROR
,
651 "invalid slice size %"PRIu32
" (only %"PRIu32
" bytes left)\n",
652 slice_size
, src_size
- off
);
653 return AVERROR_INVALIDDATA
;
655 if (slice_size
<= 16) {
656 av_log(avctx
, AV_LOG_ERROR
, "invalid slice size %"PRIu32
"\n", slice_size
);
657 return AVERROR_INVALIDDATA
;
660 if (AV_RL32(src
+ off
) != slice_size
- 16) {
661 av_log(avctx
, AV_LOG_ERROR
,
662 "Slice sizes mismatch: got %"PRIu32
" instead of %"PRIu32
"\n",
663 AV_RL32(src
+ off
), slice_size
- 16);
665 init_get_bits(&gb2
, src
+ off
+ 16, (slice_size
- 16) * 8);
666 dx2_decode_slice_444(&gb2
, avctx
->width
, slice_height
, Y
, U
, V
,
667 pic
->linesize
[0], pic
->linesize
[1],
670 Y
+= pic
->linesize
[0] * slice_height
;
671 U
+= pic
->linesize
[1] * slice_height
;
672 V
+= pic
->linesize
[2] * slice_height
;
679 static int decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
683 const uint8_t *src
= avpkt
->data
;
686 if (avpkt
->size
< 16) {
687 av_log(avctx
, AV_LOG_ERROR
, "packet too small\n");
688 return AVERROR_INVALIDDATA
;
691 switch (AV_RB32(src
)) {
693 ret
= dxtory_decode_v1_rgb(avctx
, pic
, src
+ 16, avpkt
->size
- 16,
694 AV_PIX_FMT_BGR24
, 3);
697 ret
= dxtory_decode_v2_rgb(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
700 ret
= dxtory_decode_v1_420(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
703 ret
= dxtory_decode_v2_420(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
706 ret
= dxtory_decode_v1_410(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
709 ret
= dxtory_decode_v2_410(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
712 ret
= dxtory_decode_v1_444(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
715 ret
= dxtory_decode_v2_444(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
718 ret
= dxtory_decode_v1_rgb(avctx
, pic
, src
+ 16, avpkt
->size
- 16,
719 AV_PIX_FMT_RGB565LE
, 2);
722 ret
= dxtory_decode_v2_565(avctx
, pic
, src
+ 16, avpkt
->size
- 16, 1);
726 ret
= dxtory_decode_v1_rgb(avctx
, pic
, src
+ 16, avpkt
->size
- 16,
727 AV_PIX_FMT_RGB555LE
, 2);
731 ret
= dxtory_decode_v2_565(avctx
, pic
, src
+ 16, avpkt
->size
- 16, 0);
734 avpriv_request_sample(avctx
, "Frame header %"PRIX32
, AV_RB32(src
));
735 return AVERROR_PATCHWELCOME
;
741 pic
->pict_type
= AV_PICTURE_TYPE_I
;
748 AVCodec ff_dxtory_decoder
= {
750 .long_name
= NULL_IF_CONFIG_SMALL("Dxtory"),
751 .type
= AVMEDIA_TYPE_VIDEO
,
752 .id
= AV_CODEC_ID_DXTORY
,
753 .decode
= decode_frame
,
754 .capabilities
= CODEC_CAP_DR1
,