dds: Fix enum declaration
[ffmpeg.git] / libavcodec / dxtory.c
1 /*
2  * Dxtory decoder
3  *
4  * Copyright (c) 2011 Konstantin Shishkov
5  *
6  * This file is part of Libav.
7  *
8  * Libav 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  * Libav 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 Libav; 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 #define BITSTREAM_READER_LE
26 #include "avcodec.h"
27 #include "bytestream.h"
28 #include "get_bits.h"
29 #include "internal.h"
30 #include "unary.h"
31 #include "libavutil/common.h"
32 #include "libavutil/intreadwrite.h"
33
34 static int dxtory_decode_v1_rgb(AVCodecContext *avctx, AVFrame *pic,
35                                 const uint8_t *src, int src_size,
36                                 int id, int bpp)
37 {
38     int h;
39     uint8_t *dst;
40     int ret;
41
42     if (src_size < avctx->width * avctx->height * bpp) {
43         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
44         return AVERROR_INVALIDDATA;
45     }
46
47     avctx->pix_fmt = id;
48     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
49         return ret;
50
51     dst = pic->data[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];
56     }
57
58     return 0;
59 }
60
61 static int dxtory_decode_v1_410(AVCodecContext *avctx, AVFrame *pic,
62                                 const uint8_t *src, int src_size)
63 {
64     int h, w;
65     uint8_t *Y1, *Y2, *Y3, *Y4, *U, *V;
66     int ret;
67
68     if (src_size < avctx->width * avctx->height * 18 / 16) {
69         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
70         return AVERROR_INVALIDDATA;
71     }
72
73     avctx->pix_fmt = AV_PIX_FMT_YUV410P;
74     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
75         return ret;
76
77     Y1 = pic->data[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;
81     U  = pic->data[1];
82     V  = pic->data[2];
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;
91             src += 18;
92         }
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];
99     }
100
101     return 0;
102 }
103
104 static int dxtory_decode_v1_420(AVCodecContext *avctx, AVFrame *pic,
105                                 const uint8_t *src, int src_size)
106 {
107     int h, w;
108     uint8_t *Y1, *Y2, *U, *V;
109     int ret;
110
111     if (src_size < avctx->width * avctx->height * 3 / 2) {
112         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
113         return AVERROR_INVALIDDATA;
114     }
115
116     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
117     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
118         return ret;
119
120     Y1 = pic->data[0];
121     Y2 = pic->data[0] + pic->linesize[0];
122     U  = pic->data[1];
123     V  = pic->data[2];
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;
130             src += 6;
131         }
132         Y1 += pic->linesize[0] << 1;
133         Y2 += pic->linesize[0] << 1;
134         U  += pic->linesize[1];
135         V  += pic->linesize[2];
136     }
137
138     return 0;
139 }
140
141 static int dxtory_decode_v1_444(AVCodecContext *avctx, AVFrame *pic,
142                                 const uint8_t *src, int src_size)
143 {
144     int h, w;
145     uint8_t *Y, *U, *V;
146     int ret;
147
148     if (src_size < avctx->width * avctx->height * 3) {
149         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
150         return AVERROR_INVALIDDATA;
151     }
152
153     avctx->pix_fmt = AV_PIX_FMT_YUV444P;
154     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
155         return ret;
156
157     Y = pic->data[0];
158     U = pic->data[1];
159     V = pic->data[2];
160     for (h = 0; h < avctx->height; h++) {
161         for (w = 0; w < avctx->width; w++) {
162             Y[w] = *src++;
163             U[w] = *src++ ^ 0x80;
164             V[w] = *src++ ^ 0x80;
165         }
166         Y += pic->linesize[0];
167         U += pic->linesize[1];
168         V += pic->linesize[2];
169     }
170
171     return 0;
172 }
173
174 const uint8_t def_lru[8] = { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xFF };
175 const uint8_t def_lru_555[8] = { 0x00, 0x08, 0x10, 0x18, 0x1F };
176 const uint8_t def_lru_565[8] = { 0x00, 0x08, 0x10, 0x20, 0x30, 0x3F };
177
178 static inline uint8_t decode_sym(GetBitContext *gb, uint8_t lru[8])
179 {
180     uint8_t c, val;
181
182     c = get_unary(gb, 0, 8);
183     if (!c) {
184         val = get_bits(gb, 8);
185         memmove(lru + 1, lru, sizeof(*lru) * (8 - 1));
186     } else {
187         val = lru[c - 1];
188         memmove(lru + 1, lru, sizeof(*lru) * (c - 1));
189     }
190     lru[0] = val;
191
192     return val;
193 }
194
195 static inline uint8_t decode_sym_565(GetBitContext *gb, uint8_t lru[8],
196                                      int bits)
197 {
198     uint8_t c, val;
199
200     c = get_unary(gb, 0, bits);
201     if (!c) {
202         val = get_bits(gb, bits);
203         memmove(lru + 1, lru, sizeof(*lru) * (6 - 1));
204     } else {
205         val = lru[c - 1];
206         memmove(lru + 1, lru, sizeof(*lru) * (c - 1));
207     }
208     lru[0] = val;
209
210     return val;
211 }
212
213 static int dx2_decode_slice_565(GetBitContext *gb, int width, int height,
214                                 uint8_t *dst, int stride, int is_565)
215 {
216     int x, y;
217     int r, g, b;
218     uint8_t lru[3][8];
219
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));
223
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);
232         }
233
234         dst += stride;
235     }
236
237     return 0;
238 }
239
240 static int dxtory_decode_v2_565(AVCodecContext *avctx, AVFrame *pic,
241                                 const uint8_t *src, int src_size, int is_565)
242 {
243     GetByteContext gb;
244     GetBitContext  gb2;
245     int nslices, slice, slice_height;
246     uint32_t off, slice_size;
247     uint8_t *dst;
248     int ret;
249
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;
256     }
257
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;
262     }
263
264     slice_height = avctx->height / nslices;
265     avctx->pix_fmt = AV_PIX_FMT_RGB24;
266     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
267         return ret;
268
269     dst = pic->data[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;
277         }
278         if (slice_size <= 16) {
279             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
280             return AVERROR_INVALIDDATA;
281         }
282
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);
287         }
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);
291
292         dst += pic->linesize[0] * slice_height;
293         off += slice_size;
294     }
295
296     return 0;
297 }
298
299 static int dx2_decode_slice_rgb(GetBitContext *gb, int width, int height,
300                                 uint8_t *dst, int stride)
301 {
302     int x, y, i;
303     uint8_t lru[3][8];
304
305     for (i = 0; i < 3; i++)
306         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
307
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]);
313         }
314
315         dst += stride;
316     }
317
318     return 0;
319 }
320
321 static int dxtory_decode_v2_rgb(AVCodecContext *avctx, AVFrame *pic,
322                                 const uint8_t *src, int src_size)
323 {
324     GetByteContext gb;
325     GetBitContext  gb2;
326     int nslices, slice, slice_height;
327     uint32_t off, slice_size;
328     uint8_t *dst;
329     int ret;
330
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;
337     }
338
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;
343     }
344
345     slice_height = avctx->height / nslices;
346     avctx->pix_fmt = AV_PIX_FMT_BGR24;
347     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
348         return ret;
349
350     dst = pic->data[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;
358         }
359         if (slice_size <= 16) {
360             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n",
361                    slice_size);
362             return AVERROR_INVALIDDATA;
363         }
364
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);
369         }
370         init_get_bits(&gb2, src + off + 16, (slice_size - 16) * 8);
371         dx2_decode_slice_rgb(&gb2, avctx->width, slice_height, dst,
372                              pic->linesize[0]);
373
374         dst += pic->linesize[0] * slice_height;
375         off += slice_size;
376     }
377
378     return 0;
379 }
380
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)
384 {
385     int x, y, i, j;
386     uint8_t lru[3][8];
387
388     for (i = 0; i < 3; i++)
389         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
390
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;
398         }
399
400         Y += ystride << 2;
401         U += ustride;
402         V += vstride;
403     }
404
405     return 0;
406 }
407
408 static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic,
409                                 const uint8_t *src, int src_size)
410 {
411     GetByteContext gb;
412     GetBitContext  gb2;
413     int nslices, slice, slice_height, ref_slice_height;
414     int cur_y, next_y;
415     uint32_t off, slice_size;
416     uint8_t *Y, *U, *V;
417     int ret;
418
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;
425     }
426
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;
431     }
432
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);
437     }
438
439     avctx->pix_fmt = AV_PIX_FMT_YUV410P;
440     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
441         return ret;
442
443     Y = pic->data[0];
444     U = pic->data[1];
445     V = pic->data[2];
446
447     cur_y  = 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;
457         }
458         if (slice_size <= 16) {
459             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
460             return AVERROR_INVALIDDATA;
461         }
462
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);
467         }
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],
471                              pic->linesize[2]);
472
473         Y += pic->linesize[0] *  slice_height;
474         U += pic->linesize[1] * (slice_height >> 2);
475         V += pic->linesize[2] * (slice_height >> 2);
476         off += slice_size;
477         cur_y   = next_y;
478         next_y += ref_slice_height;
479     }
480
481     return 0;
482 }
483
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)
487 {
488     int x, y, i;
489     uint8_t lru[3][8];
490
491     for (i = 0; i < 3; i++)
492         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
493
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;
502         }
503
504         Y += ystride << 1;
505         U += ustride;
506         V += vstride;
507     }
508
509     return 0;
510 }
511
512 static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic,
513                                 const uint8_t *src, int src_size)
514 {
515     GetByteContext gb;
516     GetBitContext  gb2;
517     int nslices, slice, slice_height, ref_slice_height;
518     int cur_y, next_y;
519     uint32_t off, slice_size;
520     uint8_t *Y, *U, *V;
521     int ret;
522
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;
529     }
530
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;
535     }
536
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);
541     }
542
543     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
544     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
545         return ret;
546
547     Y = pic->data[0];
548     U = pic->data[1];
549     V = pic->data[2];
550
551     cur_y  = 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;
561         }
562         if (slice_size <= 16) {
563             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
564             return AVERROR_INVALIDDATA;
565         }
566
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);
571         }
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],
575                              pic->linesize[2]);
576
577         Y += pic->linesize[0] *  slice_height;
578         U += pic->linesize[1] * (slice_height >> 1);
579         V += pic->linesize[2] * (slice_height >> 1);
580         off += slice_size;
581         cur_y   = next_y;
582         next_y += ref_slice_height;
583     }
584
585     return 0;
586 }
587
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)
591 {
592     int x, y, i;
593     uint8_t lru[3][8];
594
595     for (i = 0; i < 3; i++)
596         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
597
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;
603         }
604
605         Y += ystride;
606         U += ustride;
607         V += vstride;
608     }
609
610     return 0;
611 }
612
613 static int dxtory_decode_v2_444(AVCodecContext *avctx, AVFrame *pic,
614                                 const uint8_t *src, int src_size)
615 {
616     GetByteContext gb;
617     GetBitContext  gb2;
618     int nslices, slice, slice_height;
619     uint32_t off, slice_size;
620     uint8_t *Y, *U, *V;
621     int ret;
622
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;
629     }
630
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;
635     }
636
637     slice_height = avctx->height / nslices;
638
639     avctx->pix_fmt = AV_PIX_FMT_YUV444P;
640     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
641         return ret;
642
643     Y = pic->data[0];
644     U = pic->data[1];
645     V = pic->data[2];
646
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;
654         }
655         if (slice_size <= 16) {
656             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
657             return AVERROR_INVALIDDATA;
658         }
659
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);
664         }
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],
668                              pic->linesize[2]);
669
670         Y += pic->linesize[0] * slice_height;
671         U += pic->linesize[1] * slice_height;
672         V += pic->linesize[2] * slice_height;
673         off += slice_size;
674     }
675
676     return 0;
677 }
678
679 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
680                         AVPacket *avpkt)
681 {
682     AVFrame *pic = data;
683     const uint8_t *src = avpkt->data;
684     int ret;
685
686     if (avpkt->size < 16) {
687         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
688         return AVERROR_INVALIDDATA;
689     }
690
691     switch (AV_RB32(src)) {
692     case 0x01000001:
693         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
694                                    AV_PIX_FMT_BGR24, 3);
695         break;
696     case 0x01000009:
697         ret = dxtory_decode_v2_rgb(avctx, pic, src + 16, avpkt->size - 16);
698         break;
699     case 0x02000001:
700         ret = dxtory_decode_v1_420(avctx, pic, src + 16, avpkt->size - 16);
701         break;
702     case 0x02000009:
703         ret = dxtory_decode_v2_420(avctx, pic, src + 16, avpkt->size - 16);
704         break;
705     case 0x03000001:
706         ret = dxtory_decode_v1_410(avctx, pic, src + 16, avpkt->size - 16);
707         break;
708     case 0x03000009:
709         ret = dxtory_decode_v2_410(avctx, pic, src + 16, avpkt->size - 16);
710         break;
711     case 0x04000001:
712         ret = dxtory_decode_v1_444(avctx, pic, src + 16, avpkt->size - 16);
713         break;
714     case 0x04000009:
715         ret = dxtory_decode_v2_444(avctx, pic, src + 16, avpkt->size - 16);
716         break;
717     case 0x17000001:
718         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
719                                    AV_PIX_FMT_RGB565LE, 2);
720         break;
721     case 0x17000009:
722         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 1);
723         break;
724     case 0x18000001:
725     case 0x19000001:
726         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
727                                    AV_PIX_FMT_RGB555LE, 2);
728         break;
729     case 0x18000009:
730     case 0x19000009:
731         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 0);
732         break;
733     default:
734         avpriv_request_sample(avctx, "Frame header %"PRIX32, AV_RB32(src));
735         return AVERROR_PATCHWELCOME;
736     }
737
738     if (ret)
739         return ret;
740
741     pic->pict_type = AV_PICTURE_TYPE_I;
742     pic->key_frame = 1;
743     *got_frame = 1;
744
745     return avpkt->size;
746 }
747
748 AVCodec ff_dxtory_decoder = {
749     .name           = "dxtory",
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,
755 };