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_COPY32U(Y1
+ w
, src
);
86 AV_COPY32U(Y2
+ w
, src
+ 4);
87 AV_COPY32U(Y3
+ w
, src
+ 8);
88 AV_COPY32U(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
;
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
;
428 avpriv_request_sample(avctx
, "%d slices for %dx%d", nslices
,
429 avctx
->width
, avctx
->height
);
430 return AVERROR_PATCHWELCOME
;
433 if ((avctx
->width
& 3) || (avctx
->height
& 3)) {
434 avpriv_request_sample(avctx
, "Frame dimensions %dx%d",
435 avctx
->width
, avctx
->height
);
438 avctx
->pix_fmt
= AV_PIX_FMT_YUV410P
;
439 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
447 for (slice
= 0; slice
< nslices
; slice
++) {
448 slice_size
= bytestream2_get_le32(&gb
);
449 next_y
= ((slice
+ 1) * avctx
->height
) / nslices
;
450 slice_height
= (next_y
& ~3) - (cur_y
& ~3);
451 if (slice_size
> src_size
- off
) {
452 av_log(avctx
, AV_LOG_ERROR
,
453 "invalid slice size %"PRIu32
" (only %"PRIu32
" bytes left)\n",
454 slice_size
, src_size
- off
);
455 return AVERROR_INVALIDDATA
;
457 if (slice_size
<= 16) {
458 av_log(avctx
, AV_LOG_ERROR
, "invalid slice size %"PRIu32
"\n", slice_size
);
459 return AVERROR_INVALIDDATA
;
462 if (AV_RL32(src
+ off
) != slice_size
- 16) {
463 av_log(avctx
, AV_LOG_ERROR
,
464 "Slice sizes mismatch: got %"PRIu32
" instead of %"PRIu32
"\n",
465 AV_RL32(src
+ off
), slice_size
- 16);
467 init_get_bits(&gb2
, src
+ off
+ 16, (slice_size
- 16) * 8);
468 dx2_decode_slice_410(&gb2
, avctx
->width
, slice_height
, Y
, U
, V
,
469 pic
->linesize
[0], pic
->linesize
[1],
472 Y
+= pic
->linesize
[0] * slice_height
;
473 U
+= pic
->linesize
[1] * (slice_height
>> 2);
474 V
+= pic
->linesize
[2] * (slice_height
>> 2);
482 static int dx2_decode_slice_420(GetBitContext
*gb
, int width
, int height
,
483 uint8_t *Y
, uint8_t *U
, uint8_t *V
,
484 int ystride
, int ustride
, int vstride
)
489 for (i
= 0; i
< 3; i
++)
490 memcpy(lru
[i
], def_lru
, 8 * sizeof(*def_lru
));
492 for (y
= 0; y
< height
; y
+=2) {
493 for (x
= 0; x
< width
; x
+= 2) {
494 Y
[x
+ 0 + 0 * ystride
] = decode_sym(gb
, lru
[0]);
495 Y
[x
+ 1 + 0 * ystride
] = decode_sym(gb
, lru
[0]);
496 Y
[x
+ 0 + 1 * ystride
] = decode_sym(gb
, lru
[0]);
497 Y
[x
+ 1 + 1 * ystride
] = decode_sym(gb
, lru
[0]);
498 U
[x
>> 1] = decode_sym(gb
, lru
[1]) ^ 0x80;
499 V
[x
>> 1] = decode_sym(gb
, lru
[2]) ^ 0x80;
510 static int dxtory_decode_v2_420(AVCodecContext
*avctx
, AVFrame
*pic
,
511 const uint8_t *src
, int src_size
)
515 int nslices
, slice
, slice_height
;
517 uint32_t off
, slice_size
;
521 bytestream2_init(&gb
, src
, src_size
);
522 nslices
= bytestream2_get_le16(&gb
);
523 off
= FFALIGN(nslices
* 4 + 2, 16);
524 if (src_size
< off
) {
525 av_log(avctx
, AV_LOG_ERROR
, "no slice data\n");
526 return AVERROR_INVALIDDATA
;
530 avpriv_request_sample(avctx
, "%d slices for %dx%d", nslices
,
531 avctx
->width
, avctx
->height
);
532 return AVERROR_PATCHWELCOME
;
535 if ((avctx
->width
& 1) || (avctx
->height
& 1)) {
536 avpriv_request_sample(avctx
, "Frame dimensions %dx%d",
537 avctx
->width
, avctx
->height
);
540 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
541 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
549 for (slice
= 0; slice
< nslices
; slice
++) {
550 slice_size
= bytestream2_get_le32(&gb
);
551 next_y
= ((slice
+ 1) * avctx
->height
) / nslices
;
552 slice_height
= (next_y
& ~1) - (cur_y
& ~1);
553 if (slice_size
> src_size
- off
) {
554 av_log(avctx
, AV_LOG_ERROR
,
555 "invalid slice size %"PRIu32
" (only %"PRIu32
" bytes left)\n",
556 slice_size
, src_size
- off
);
557 return AVERROR_INVALIDDATA
;
559 if (slice_size
<= 16) {
560 av_log(avctx
, AV_LOG_ERROR
, "invalid slice size %"PRIu32
"\n", slice_size
);
561 return AVERROR_INVALIDDATA
;
564 if (AV_RL32(src
+ off
) != slice_size
- 16) {
565 av_log(avctx
, AV_LOG_ERROR
,
566 "Slice sizes mismatch: got %"PRIu32
" instead of %"PRIu32
"\n",
567 AV_RL32(src
+ off
), slice_size
- 16);
569 init_get_bits(&gb2
, src
+ off
+ 16, (slice_size
- 16) * 8);
570 dx2_decode_slice_420(&gb2
, avctx
->width
, slice_height
, Y
, U
, V
,
571 pic
->linesize
[0], pic
->linesize
[1],
574 Y
+= pic
->linesize
[0] * slice_height
;
575 U
+= pic
->linesize
[1] * (slice_height
>> 1);
576 V
+= pic
->linesize
[2] * (slice_height
>> 1);
584 static int dx2_decode_slice_444(GetBitContext
*gb
, int width
, int height
,
585 uint8_t *Y
, uint8_t *U
, uint8_t *V
,
586 int ystride
, int ustride
, int vstride
)
591 for (i
= 0; i
< 3; i
++)
592 memcpy(lru
[i
], def_lru
, 8 * sizeof(*def_lru
));
594 for (y
= 0; y
< height
; y
++) {
595 for (x
= 0; x
< width
; x
++) {
596 Y
[x
] = decode_sym(gb
, lru
[0]);
597 U
[x
] = decode_sym(gb
, lru
[1]) ^ 0x80;
598 V
[x
] = decode_sym(gb
, lru
[2]) ^ 0x80;
609 static int dxtory_decode_v2_444(AVCodecContext
*avctx
, AVFrame
*pic
,
610 const uint8_t *src
, int src_size
)
614 int nslices
, slice
, slice_height
;
615 uint32_t off
, slice_size
;
619 bytestream2_init(&gb
, src
, src_size
);
620 nslices
= bytestream2_get_le16(&gb
);
621 off
= FFALIGN(nslices
* 4 + 2, 16);
622 if (src_size
< off
) {
623 av_log(avctx
, AV_LOG_ERROR
, "no slice data\n");
624 return AVERROR_INVALIDDATA
;
627 if (!nslices
|| avctx
->height
% nslices
) {
628 avpriv_request_sample(avctx
, "%d slices for %dx%d", nslices
,
629 avctx
->width
, avctx
->height
);
630 return AVERROR_PATCHWELCOME
;
633 slice_height
= avctx
->height
/ nslices
;
635 avctx
->pix_fmt
= AV_PIX_FMT_YUV444P
;
636 if ((ret
= ff_get_buffer(avctx
, pic
, 0)) < 0)
643 for (slice
= 0; slice
< nslices
; slice
++) {
644 slice_size
= bytestream2_get_le32(&gb
);
645 if (slice_size
> src_size
- off
) {
646 av_log(avctx
, AV_LOG_ERROR
,
647 "invalid slice size %"PRIu32
" (only %"PRIu32
" bytes left)\n",
648 slice_size
, src_size
- off
);
649 return AVERROR_INVALIDDATA
;
651 if (slice_size
<= 16) {
652 av_log(avctx
, AV_LOG_ERROR
, "invalid slice size %"PRIu32
"\n", slice_size
);
653 return AVERROR_INVALIDDATA
;
656 if (AV_RL32(src
+ off
) != slice_size
- 16) {
657 av_log(avctx
, AV_LOG_ERROR
,
658 "Slice sizes mismatch: got %"PRIu32
" instead of %"PRIu32
"\n",
659 AV_RL32(src
+ off
), slice_size
- 16);
661 init_get_bits(&gb2
, src
+ off
+ 16, (slice_size
- 16) * 8);
662 dx2_decode_slice_444(&gb2
, avctx
->width
, slice_height
, Y
, U
, V
,
663 pic
->linesize
[0], pic
->linesize
[1],
666 Y
+= pic
->linesize
[0] * slice_height
;
667 U
+= pic
->linesize
[1] * slice_height
;
668 V
+= pic
->linesize
[2] * slice_height
;
675 static int decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
679 const uint8_t *src
= avpkt
->data
;
682 if (avpkt
->size
< 16) {
683 av_log(avctx
, AV_LOG_ERROR
, "packet too small\n");
684 return AVERROR_INVALIDDATA
;
687 switch (AV_RB32(src
)) {
689 ret
= dxtory_decode_v1_rgb(avctx
, pic
, src
+ 16, avpkt
->size
- 16,
690 AV_PIX_FMT_BGR24
, 3);
693 ret
= dxtory_decode_v2_rgb(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
696 ret
= dxtory_decode_v1_420(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
699 ret
= dxtory_decode_v2_420(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
702 ret
= dxtory_decode_v1_410(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
705 ret
= dxtory_decode_v2_410(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
708 ret
= dxtory_decode_v1_444(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
711 ret
= dxtory_decode_v2_444(avctx
, pic
, src
+ 16, avpkt
->size
- 16);
714 ret
= dxtory_decode_v1_rgb(avctx
, pic
, src
+ 16, avpkt
->size
- 16,
715 AV_PIX_FMT_RGB565LE
, 2);
718 ret
= dxtory_decode_v2_565(avctx
, pic
, src
+ 16, avpkt
->size
- 16, 1);
722 ret
= dxtory_decode_v1_rgb(avctx
, pic
, src
+ 16, avpkt
->size
- 16,
723 AV_PIX_FMT_RGB555LE
, 2);
727 ret
= dxtory_decode_v2_565(avctx
, pic
, src
+ 16, avpkt
->size
- 16, 0);
730 avpriv_request_sample(avctx
, "Frame header %"PRIX32
, AV_RB32(src
));
731 return AVERROR_PATCHWELCOME
;
737 pic
->pict_type
= AV_PICTURE_TYPE_I
;
744 AVCodec ff_dxtory_decoder
= {
746 .long_name
= NULL_IF_CONFIG_SMALL("Dxtory"),
747 .type
= AVMEDIA_TYPE_VIDEO
,
748 .id
= AV_CODEC_ID_DXTORY
,
749 .decode
= decode_frame
,
750 .capabilities
= CODEC_CAP_DR1
,