FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/dxtory.c
Date: 2024-11-20 23:03:26
Exec Total Coverage
Lines: 48 470 10.2%
Functions: 4 27 14.8%
Branches: 13 193 6.7%
Line Branch Exec Source
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 "codec_internal.h"
32 #include "get_bits.h"
33 #include "unary.h"
34 #include "thread.h"
35
36 2 static int64_t get_raw_size(enum AVPixelFormat fmt, int width, int height)
37 {
38
1/5
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 2 switch (fmt) {
39 ✗ case AV_PIX_FMT_RGB555LE:
40 case AV_PIX_FMT_RGB565LE:
41 ✗ return width * height * 2LL;
42 ✗ case AV_PIX_FMT_RGB24:
43 case AV_PIX_FMT_BGR24:
44 case AV_PIX_FMT_YUV444P:
45 ✗ return width * height * 3LL;
46 2 case AV_PIX_FMT_YUV420P:
47 2 return (int64_t)(width * height) + 2 * AV_CEIL_RSHIFT(width, 1) * AV_CEIL_RSHIFT(height, 1);
48 ✗ case AV_PIX_FMT_YUV410P:
49 ✗ return (int64_t)(width * height) + 2 * AV_CEIL_RSHIFT(width, 2) * AV_CEIL_RSHIFT(height, 2);
50 }
51
52 ✗ return 0;
53 }
54
55 4 static void do_vflip(AVCodecContext *avctx, AVFrame *pic, int vflip)
56 {
57
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 if (!vflip)
58 4 return;
59
60 ✗ switch (pic->format) {
61 ✗ case AV_PIX_FMT_YUV444P:
62 ✗ pic->data[1] += (avctx->height - 1) * pic->linesize[1];
63 ✗ pic->linesize[1] = -pic->linesize[1];
64 ✗ pic->data[2] += (avctx->height - 1) * pic->linesize[2];
65 ✗ pic->linesize[2] = -pic->linesize[2];
66 ✗ case AV_PIX_FMT_RGB555LE:
67 case AV_PIX_FMT_RGB565LE:
68 case AV_PIX_FMT_BGR24:
69 case AV_PIX_FMT_RGB24:
70 ✗ pic->data[0] += (avctx->height - 1) * pic->linesize[0];
71 ✗ pic->linesize[0] = -pic->linesize[0];
72 ✗ break;
73 ✗ case AV_PIX_FMT_YUV410P:
74 ✗ pic->data[0] += (avctx->height - 1) * pic->linesize[0];
75 ✗ pic->linesize[0] = -pic->linesize[0];
76 ✗ pic->data[1] += (AV_CEIL_RSHIFT(avctx->height, 2) - 1) * pic->linesize[1];
77 ✗ pic->linesize[1] = -pic->linesize[1];
78 ✗ pic->data[2] += (AV_CEIL_RSHIFT(avctx->height, 2) - 1) * pic->linesize[2];
79 ✗ pic->linesize[2] = -pic->linesize[2];
80 ✗ break;
81 ✗ case AV_PIX_FMT_YUV420P:
82 ✗ pic->data[0] += (avctx->height - 1) * pic->linesize[0];
83 ✗ pic->linesize[0] = -pic->linesize[0];
84 ✗ pic->data[1] += (AV_CEIL_RSHIFT(avctx->height, 1) - 1) * pic->linesize[1];
85 ✗ pic->linesize[1] = -pic->linesize[1];
86 ✗ pic->data[2] += (AV_CEIL_RSHIFT(avctx->height, 1) - 1) * pic->linesize[2];
87 ✗ pic->linesize[2] = -pic->linesize[2];
88 ✗ break;
89 }
90 }
91
92 ✗ static int dxtory_decode_v1_rgb(AVCodecContext *avctx, AVFrame *pic,
93 const uint8_t *src, int src_size,
94 int id, int bpp, uint32_t vflipped)
95 {
96 int h;
97 uint8_t *dst;
98 int ret;
99
100 ✗ if (src_size < get_raw_size(id, avctx->width, avctx->height)) {
101 ✗ av_log(avctx, AV_LOG_ERROR, "packet too small\n");
102 ✗ return AVERROR_INVALIDDATA;
103 }
104
105 ✗ avctx->pix_fmt = id;
106 ✗ if ((ret = ff_thread_get_buffer(avctx, pic, 0)) < 0)
107 ✗ return ret;
108
109 ✗ do_vflip(avctx, pic, vflipped);
110
111 ✗ dst = pic->data[0];
112 ✗ for (h = 0; h < avctx->height; h++) {
113 ✗ memcpy(dst, src, avctx->width * bpp);
114 ✗ src += avctx->width * bpp;
115 ✗ dst += pic->linesize[0];
116 }
117
118 ✗ do_vflip(avctx, pic, vflipped);
119
120 ✗ return 0;
121 }
122
123 ✗ static int dxtory_decode_v1_410(AVCodecContext *avctx, AVFrame *pic,
124 const uint8_t *src, int src_size,
125 uint32_t vflipped)
126 {
127 int h, w;
128 uint8_t *Y1, *Y2, *Y3, *Y4, *U, *V;
129 int height, width, hmargin, vmargin;
130 int huvborder;
131 int ret;
132
133 ✗ if (src_size < get_raw_size(AV_PIX_FMT_YUV410P, avctx->width, avctx->height)) {
134 ✗ av_log(avctx, AV_LOG_ERROR, "packet too small\n");
135 ✗ return AVERROR_INVALIDDATA;
136 }
137
138 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV410P;
139 ✗ if ((ret = ff_thread_get_buffer(avctx, pic, 0)) < 0)
140 ✗ return ret;
141
142 ✗ do_vflip(avctx, pic, vflipped);
143
144 ✗ height = avctx->height & ~3;
145 ✗ width = avctx->width & ~3;
146 ✗ hmargin = avctx->width - width;
147 ✗ vmargin = avctx->height - height;
148 ✗ huvborder = AV_CEIL_RSHIFT(avctx->width, 2) - 1;
149
150 ✗ Y1 = pic->data[0];
151 ✗ Y2 = pic->data[0] + pic->linesize[0];
152 ✗ Y3 = pic->data[0] + pic->linesize[0] * 2;
153 ✗ Y4 = pic->data[0] + pic->linesize[0] * 3;
154 ✗ U = pic->data[1];
155 ✗ V = pic->data[2];
156 ✗ for (h = 0; h < height; h += 4) {
157 ✗ for (w = 0; w < width; w += 4) {
158 ✗ AV_COPY32U(Y1 + w, src);
159 ✗ AV_COPY32U(Y2 + w, src + 4);
160 ✗ AV_COPY32U(Y3 + w, src + 8);
161 ✗ AV_COPY32U(Y4 + w, src + 12);
162 ✗ U[w >> 2] = src[16] + 0x80;
163 ✗ V[w >> 2] = src[17] + 0x80;
164 ✗ src += 18;
165 }
166 ✗ if (hmargin) {
167 ✗ for (w = 0; w < hmargin; w++) {
168 ✗ Y1[width + w] = src[w];
169 ✗ Y2[width + w] = src[w + hmargin * 1];
170 ✗ Y3[width + w] = src[w + hmargin * 2];
171 ✗ Y4[width + w] = src[w + hmargin * 3];
172 }
173 ✗ src += 4 * hmargin;
174 ✗ U[huvborder] = src[0] + 0x80;
175 ✗ V[huvborder] = src[1] + 0x80;
176 ✗ src += 2;
177 }
178 ✗ Y1 += pic->linesize[0] * 4;
179 ✗ Y2 += pic->linesize[0] * 4;
180 ✗ Y3 += pic->linesize[0] * 4;
181 ✗ Y4 += pic->linesize[0] * 4;
182 ✗ U += pic->linesize[1];
183 ✗ V += pic->linesize[2];
184 }
185
186 ✗ if (vmargin) {
187 ✗ for (w = 0; w < width; w += 4) {
188 ✗ AV_COPY32U(Y1 + w, src);
189 ✗ if (vmargin > 1)
190 ✗ AV_COPY32U(Y2 + w, src + 4);
191 ✗ if (vmargin > 2)
192 ✗ AV_COPY32U(Y3 + w, src + 8);
193 ✗ src += 4 * vmargin;
194 ✗ U[w >> 2] = src[0] + 0x80;
195 ✗ V[w >> 2] = src[1] + 0x80;
196 ✗ src += 2;
197 }
198 ✗ if (hmargin) {
199 ✗ for (w = 0; w < hmargin; w++) {
200 ✗ AV_COPY32U(Y1 + w, src);
201 ✗ if (vmargin > 1)
202 ✗ AV_COPY32U(Y2 + w, src + 4);
203 ✗ if (vmargin > 2)
204 ✗ AV_COPY32U(Y3 + w, src + 8);
205 ✗ src += 4 * vmargin;
206 }
207 ✗ U[huvborder] = src[0] + 0x80;
208 ✗ V[huvborder] = src[1] + 0x80;
209 ✗ src += 2;
210 }
211 }
212
213 ✗ do_vflip(avctx, pic, vflipped);
214
215 ✗ return 0;
216 }
217
218 2 static int dxtory_decode_v1_420(AVCodecContext *avctx, AVFrame *pic,
219 const uint8_t *src, int src_size,
220 uint32_t vflipped)
221 {
222 int h, w;
223 uint8_t *Y1, *Y2, *U, *V;
224 int height, width, hmargin, vmargin;
225 int huvborder;
226 int ret;
227
228
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if (src_size < get_raw_size(AV_PIX_FMT_YUV420P, avctx->width, avctx->height)) {
229 ✗ av_log(avctx, AV_LOG_ERROR, "packet too small\n");
230 ✗ return AVERROR_INVALIDDATA;
231 }
232
233 2 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
234
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if ((ret = ff_thread_get_buffer(avctx, pic, 0)) < 0)
235 ✗ return ret;
236
237 2 do_vflip(avctx, pic, vflipped);
238
239 2 height = avctx->height & ~1;
240 2 width = avctx->width & ~1;
241 2 hmargin = avctx->width - width;
242 2 vmargin = avctx->height - height;
243 2 huvborder = AV_CEIL_RSHIFT(avctx->width, 1) - 1;
244
245 2 Y1 = pic->data[0];
246 2 Y2 = pic->data[0] + pic->linesize[0];
247 2 U = pic->data[1];
248 2 V = pic->data[2];
249
2/2
✓ Branch 0 taken 720 times.
✓ Branch 1 taken 2 times.
 722 for (h = 0; h < height; h += 2) {
250
2/2
✓ Branch 0 taken 460800 times.
✓ Branch 1 taken 720 times.
 461520 for (w = 0; w < width; w += 2) {
251 460800 AV_COPY16(Y1 + w, src);
252 460800 AV_COPY16(Y2 + w, src + 2);
253 460800 U[w >> 1] = src[4] + 0x80;
254 460800 V[w >> 1] = src[5] + 0x80;
255 460800 src += 6;
256 }
257
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 720 times.
 720 if (hmargin) {
258 ✗ Y1[width + 1] = src[0];
259 ✗ Y2[width + 1] = src[1];
260 ✗ U[huvborder] = src[2] + 0x80;
261 ✗ V[huvborder] = src[3] + 0x80;
262 ✗ src += 4;
263 }
264 720 Y1 += pic->linesize[0] * 2;
265 720 Y2 += pic->linesize[0] * 2;
266 720 U += pic->linesize[1];
267 720 V += pic->linesize[2];
268 }
269
270
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (vmargin) {
271 ✗ for (w = 0; w < width; w += 2) {
272 ✗ AV_COPY16U(Y1 + w, src);
273 ✗ U[w >> 1] = src[0] + 0x80;
274 ✗ V[w >> 1] = src[1] + 0x80;
275 ✗ src += 4;
276 }
277 ✗ if (hmargin) {
278 ✗ Y1[w] = src[0];
279 ✗ U[huvborder] = src[1] + 0x80;
280 ✗ V[huvborder] = src[2] + 0x80;
281 ✗ src += 3;
282 }
283 }
284
285 2 do_vflip(avctx, pic, vflipped);
286
287 2 return 0;
288 }
289
290 ✗ static int dxtory_decode_v1_444(AVCodecContext *avctx, AVFrame *pic,
291 const uint8_t *src, int src_size,
292 uint32_t vflipped)
293 {
294 int h, w;
295 uint8_t *Y, *U, *V;
296 int ret;
297
298 ✗ if (src_size < get_raw_size(AV_PIX_FMT_YUV444P, avctx->width, avctx->height)) {
299 ✗ av_log(avctx, AV_LOG_ERROR, "packet too small\n");
300 ✗ return AVERROR_INVALIDDATA;
301 }
302
303 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV444P;
304 ✗ if ((ret = ff_thread_get_buffer(avctx, pic, 0)) < 0)
305 ✗ return ret;
306
307 ✗ do_vflip(avctx, pic, vflipped);
308
309 ✗ Y = pic->data[0];
310 ✗ U = pic->data[1];
311 ✗ V = pic->data[2];
312 ✗ for (h = 0; h < avctx->height; h++) {
313 ✗ for (w = 0; w < avctx->width; w++) {
314 ✗ Y[w] = *src++;
315 ✗ U[w] = *src++ ^ 0x80;
316 ✗ V[w] = *src++ ^ 0x80;
317 }
318 ✗ Y += pic->linesize[0];
319 ✗ U += pic->linesize[1];
320 ✗ V += pic->linesize[2];
321 }
322
323 ✗ do_vflip(avctx, pic, vflipped);
324
325 ✗ return 0;
326 }
327
328 static const uint8_t def_lru[8] = { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xFF };
329 static const uint8_t def_lru_555[8] = { 0x00, 0x08, 0x10, 0x18, 0x1F };
330 static const uint8_t def_lru_565[8] = { 0x00, 0x08, 0x10, 0x20, 0x30, 0x3F };
331
332 ✗ static inline uint8_t decode_sym(GetBitContext *gb, uint8_t lru[8])
333 {
334 uint8_t c, val;
335
336 ✗ c = get_unary(gb, 0, 8);
337 ✗ if (!c) {
338 ✗ val = get_bits(gb, 8);
339 ✗ memmove(lru + 1, lru, sizeof(*lru) * (8 - 1));
340 } else {
341 ✗ val = lru[c - 1];
342 ✗ memmove(lru + 1, lru, sizeof(*lru) * (c - 1));
343 }
344 ✗ lru[0] = val;
345
346 ✗ return val;
347 }
348
349 ✗ static int check_slice_size(AVCodecContext *avctx,
350 const uint8_t *src, int src_size,
351 int slice_size, int off)
352 {
353 int cur_slice_size;
354
355 ✗ if (slice_size > src_size - off) {
356 ✗ av_log(avctx, AV_LOG_ERROR,
357 "invalid slice size %d (only %d bytes left)\n",
358 slice_size, src_size - off);
359 ✗ return AVERROR_INVALIDDATA;
360 }
361 ✗ if (slice_size <= 16) {
362 ✗ av_log(avctx, AV_LOG_ERROR, "invalid slice size %d\n",
363 slice_size);
364 ✗ return AVERROR_INVALIDDATA;
365 }
366
367 ✗ cur_slice_size = AV_RL32(src + off);
368 ✗ if (cur_slice_size != slice_size - 16) {
369 ✗ av_log(avctx, AV_LOG_ERROR,
370 "Slice sizes mismatch: got %d instead of %d\n",
371 cur_slice_size, slice_size - 16);
372 }
373
374 ✗ return 0;
375 }
376
377 ✗ static int load_buffer(AVCodecContext *avctx,
378 const uint8_t *src, int src_size,
379 GetByteContext *gb,
380 int *nslices, int *off)
381 {
382 ✗ bytestream2_init(gb, src, src_size);
383 ✗ *nslices = bytestream2_get_le16(gb);
384 ✗ *off = FFALIGN(*nslices * 4 + 2, 16);
385 ✗ if (src_size < *off) {
386 ✗ av_log(avctx, AV_LOG_ERROR, "no slice data\n");
387 ✗ return AVERROR_INVALIDDATA;
388 }
389
390 ✗ if (!*nslices) {
391 ✗ avpriv_request_sample(avctx, "%d slices for %dx%d", *nslices,
392 avctx->width, avctx->height);
393 ✗ return AVERROR_PATCHWELCOME;
394 }
395
396 ✗ return 0;
397 }
398
399 ✗ static inline uint8_t decode_sym_565(GetBitContext *gb, uint8_t lru[8],
400 int bits)
401 {
402 uint8_t c, val;
403
404 ✗ c = get_unary(gb, 0, bits);
405 ✗ if (!c) {
406 ✗ val = get_bits(gb, bits);
407 ✗ memmove(lru + 1, lru, sizeof(*lru) * (6 - 1));
408 } else {
409 ✗ val = lru[c - 1];
410 ✗ memmove(lru + 1, lru, sizeof(*lru) * (c - 1));
411 }
412 ✗ lru[0] = val;
413
414 ✗ return val;
415 }
416
417 typedef int (*decode_slice_func)(GetBitContext *gb, AVFrame *frame,
418 int line, int height, uint8_t lru[3][8]);
419
420 typedef void (*setup_lru_func)(uint8_t lru[3][8]);
421
422 ✗ static int dxtory_decode_v2(AVCodecContext *avctx, AVFrame *pic,
423 const uint8_t *src, int src_size,
424 decode_slice_func decode_slice,
425 setup_lru_func setup_lru,
426 enum AVPixelFormat fmt,
427 uint32_t vflipped)
428 {
429 GetByteContext gb, gb_check;
430 GetBitContext gb2;
431 ✗ int nslices, slice, line = 0;
432 uint32_t off, slice_size;
433 uint64_t off_check;
434 uint8_t lru[3][8];
435 int ret;
436
437 ✗ ret = load_buffer(avctx, src, src_size, &gb, &nslices, &off);
438 ✗ if (ret < 0)
439 ✗ return ret;
440
441 ✗ off_check = off;
442 ✗ gb_check = gb;
443 ✗ for (slice = 0; slice < nslices; slice++) {
444 ✗ slice_size = bytestream2_get_le32(&gb_check);
445
446 ✗ if (slice_size <= 16 + (avctx->height * avctx->width / (8 * nslices)))
447 ✗ return AVERROR_INVALIDDATA;
448 ✗ off_check += slice_size;
449 }
450
451 ✗ if (off_check - avctx->discard_damaged_percentage*off_check/100 > src_size)
452 ✗ return AVERROR_INVALIDDATA;
453
454 ✗ avctx->pix_fmt = fmt;
455 ✗ if ((ret = ff_thread_get_buffer(avctx, pic, 0)) < 0)
456 ✗ return ret;
457
458 ✗ do_vflip(avctx, pic, vflipped);
459
460 ✗ for (slice = 0; slice < nslices; slice++) {
461 ✗ slice_size = bytestream2_get_le32(&gb);
462
463 ✗ setup_lru(lru);
464
465 ✗ ret = check_slice_size(avctx, src, src_size, slice_size, off);
466 ✗ if (ret < 0)
467 ✗ return ret;
468
469 ✗ if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)
470 ✗ return ret;
471
472 ✗ line += decode_slice(&gb2, pic, line, avctx->height - line, lru);
473
474 ✗ off += slice_size;
475 }
476
477 ✗ if (avctx->height - line) {
478 ✗ avpriv_request_sample(avctx, "Not enough slice data available");
479 }
480
481 ✗ do_vflip(avctx, pic, vflipped);
482
483 ✗ return 0;
484 }
485
486 av_always_inline
487 ✗ static int dx2_decode_slice_5x5(GetBitContext *gb, AVFrame *frame,
488 int line, int left, uint8_t lru[3][8],
489 int is_565)
490 {
491 int x, y;
492 int r, g, b;
493 ✗ int width = frame->width;
494 ✗ int stride = frame->linesize[0];
495 ✗ uint8_t *dst = frame->data[0] + stride * line;
496
497 ✗ for (y = 0; y < left && get_bits_left(gb) >= 3 * width; y++) {
498 ✗ for (x = 0; x < width; x++) {
499 ✗ b = decode_sym_565(gb, lru[0], 5);
500 ✗ g = decode_sym_565(gb, lru[1], is_565 ? 6 : 5);
501 ✗ r = decode_sym_565(gb, lru[2], 5);
502 ✗ dst[x * 3 + 0] = (r << 3) | (r >> 2);
503 ✗ dst[x * 3 + 1] = is_565 ? (g << 2) | (g >> 4) : (g << 3) | (g >> 2);
504 ✗ dst[x * 3 + 2] = (b << 3) | (b >> 2);
505 }
506
507 ✗ dst += stride;
508 }
509
510 ✗ return y;
511 }
512
513 ✗ static void setup_lru_555(uint8_t lru[3][8])
514 {
515 ✗ memcpy(lru[0], def_lru_555, 8 * sizeof(*def_lru));
516 ✗ memcpy(lru[1], def_lru_555, 8 * sizeof(*def_lru));
517 ✗ memcpy(lru[2], def_lru_555, 8 * sizeof(*def_lru));
518 ✗ }
519
520 ✗ static void setup_lru_565(uint8_t lru[3][8])
521 {
522 ✗ memcpy(lru[0], def_lru_555, 8 * sizeof(*def_lru));
523 ✗ memcpy(lru[1], def_lru_565, 8 * sizeof(*def_lru));
524 ✗ memcpy(lru[2], def_lru_555, 8 * sizeof(*def_lru));
525 ✗ }
526
527 ✗ static int dx2_decode_slice_555(GetBitContext *gb, AVFrame *frame,
528 int line, int left, uint8_t lru[3][8])
529 {
530 ✗ return dx2_decode_slice_5x5(gb, frame, line, left, lru, 0);
531 }
532
533 ✗ static int dx2_decode_slice_565(GetBitContext *gb, AVFrame *frame,
534 int line, int left, uint8_t lru[3][8])
535 {
536 ✗ return dx2_decode_slice_5x5(gb, frame, line, left, lru, 1);
537 }
538
539 ✗ static int dxtory_decode_v2_565(AVCodecContext *avctx, AVFrame *pic,
540 const uint8_t *src, int src_size, int is_565,
541 uint32_t vflipped)
542 {
543 ✗ enum AVPixelFormat fmt = AV_PIX_FMT_RGB24;
544 ✗ if (is_565)
545 ✗ return dxtory_decode_v2(avctx, pic, src, src_size,
546 dx2_decode_slice_565,
547 setup_lru_565,
548 fmt, vflipped);
549 else
550 ✗ return dxtory_decode_v2(avctx, pic, src, src_size,
551 dx2_decode_slice_555,
552 setup_lru_555,
553 fmt, vflipped);
554 }
555
556 ✗ static int dx2_decode_slice_rgb(GetBitContext *gb, AVFrame *frame,
557 int line, int left, uint8_t lru[3][8])
558 {
559 int x, y;
560 ✗ int width = frame->width;
561 ✗ int stride = frame->linesize[0];
562 ✗ uint8_t *dst = frame->data[0] + stride * line;
563
564 ✗ for (y = 0; y < left && get_bits_left(gb) >= 3 * width; y++) {
565 ✗ for (x = 0; x < width; x++) {
566 ✗ dst[x * 3 + 0] = decode_sym(gb, lru[0]);
567 ✗ dst[x * 3 + 1] = decode_sym(gb, lru[1]);
568 ✗ dst[x * 3 + 2] = decode_sym(gb, lru[2]);
569 }
570
571 ✗ dst += stride;
572 }
573
574 ✗ return y;
575 }
576
577 ✗ static void default_setup_lru(uint8_t lru[3][8])
578 {
579 int i;
580
581 ✗ for (i = 0; i < 3; i++)
582 ✗ memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
583 ✗ }
584
585 ✗ static int dxtory_decode_v2_rgb(AVCodecContext *avctx, AVFrame *pic,
586 const uint8_t *src, int src_size,
587 uint32_t vflipped)
588 {
589 ✗ return dxtory_decode_v2(avctx, pic, src, src_size,
590 dx2_decode_slice_rgb,
591 default_setup_lru,
592 AV_PIX_FMT_BGR24, vflipped);
593 }
594
595 ✗ static int dx2_decode_slice_410(GetBitContext *gb, AVFrame *frame,
596 int line, int left,
597 uint8_t lru[3][8])
598 {
599 int x, y, i, j;
600 ✗ int width = frame->width;
601
602 ✗ int ystride = frame->linesize[0];
603 ✗ int ustride = frame->linesize[1];
604 ✗ int vstride = frame->linesize[2];
605
606 ✗ uint8_t *Y = frame->data[0] + ystride * line;
607 ✗ uint8_t *U = frame->data[1] + (ustride >> 2) * line;
608 ✗ uint8_t *V = frame->data[2] + (vstride >> 2) * line;
609
610 int h, w, hmargin, vmargin;
611 int huvborder;
612
613 ✗ h = frame->height & ~3;
614 ✗ w = frame->width & ~3;
615 ✗ hmargin = frame->width - w;
616 ✗ vmargin = frame->height - h;
617 ✗ huvborder = AV_CEIL_RSHIFT(frame->width, 2) - 1;
618
619 ✗ for (y = 0; y < left - 3 && get_bits_left(gb) >= 18 * w / 4 + hmargin * 4 + (!!hmargin * 2); y += 4) {
620 ✗ for (x = 0; x < w; x += 4) {
621 ✗ for (j = 0; j < 4; j++)
622 ✗ for (i = 0; i < 4; i++)
623 ✗ Y[x + i + j * ystride] = decode_sym(gb, lru[0]);
624 ✗ U[x >> 2] = decode_sym(gb, lru[1]) ^ 0x80;
625 ✗ V[x >> 2] = decode_sym(gb, lru[2]) ^ 0x80;
626 }
627 ✗ if (hmargin) {
628 ✗ for (j = 0; j < 4; j++)
629 ✗ for (i = 0; i < hmargin; i++)
630 ✗ Y[x + i + j * ystride] = decode_sym(gb, lru[0]);
631 ✗ U[huvborder] = decode_sym(gb, lru[1]) ^ 0x80;
632 ✗ V[huvborder] = decode_sym(gb, lru[2]) ^ 0x80;
633 }
634
635 ✗ Y += ystride * 4;
636 ✗ U += ustride;
637 ✗ V += vstride;
638 }
639
640 ✗ if (vmargin && y + vmargin == left) {
641 ✗ for (x = 0; x < width; x += 4) {
642 ✗ for (j = 0; j < vmargin; j++)
643 ✗ for (i = 0; i < 4; i++)
644 ✗ Y[x + i + j * ystride] = decode_sym(gb, lru[0]);
645 ✗ U[x >> 2] = decode_sym(gb, lru[1]) ^ 0x80;
646 ✗ V[x >> 2] = decode_sym(gb, lru[2]) ^ 0x80;
647 }
648 ✗ if (hmargin) {
649 ✗ for (j = 0; j < vmargin; j++) {
650 ✗ for (i = 0; i < hmargin; i++)
651 ✗ Y[x + i + j * ystride] = decode_sym(gb, lru[0]);
652 }
653 ✗ U[huvborder] = decode_sym(gb, lru[1]) ^ 0x80;
654 ✗ V[huvborder] = decode_sym(gb, lru[2]) ^ 0x80;
655 }
656
657 ✗ y += vmargin;
658 }
659
660 ✗ return y;
661 }
662
663
664 ✗ static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic,
665 const uint8_t *src, int src_size,
666 uint32_t vflipped)
667 {
668 ✗ return dxtory_decode_v2(avctx, pic, src, src_size,
669 dx2_decode_slice_410,
670 default_setup_lru,
671 AV_PIX_FMT_YUV410P, vflipped);
672 }
673
674 ✗ static int dx2_decode_slice_420(GetBitContext *gb, AVFrame *frame,
675 int line, int left,
676 uint8_t lru[3][8])
677 {
678 int x, y;
679
680 ✗ int width = frame->width;
681
682 ✗ int ystride = frame->linesize[0];
683 ✗ int ustride = frame->linesize[1];
684 ✗ int vstride = frame->linesize[2];
685
686 ✗ uint8_t *Y = frame->data[0] + ystride * line;
687 ✗ uint8_t *U = frame->data[1] + (ustride >> 1) * line;
688 ✗ uint8_t *V = frame->data[2] + (vstride >> 1) * line;
689
690 int h, w, hmargin, vmargin;
691 int huvborder;
692
693 ✗ h = frame->height & ~1;
694 ✗ w = frame->width & ~1;
695 ✗ hmargin = frame->width - w;
696 ✗ vmargin = frame->height - h;
697 ✗ huvborder = AV_CEIL_RSHIFT(frame->width, 1) - 1;
698
699 ✗ for (y = 0; y < left - 1 && get_bits_left(gb) >= 3 * w + hmargin * 4; y += 2) {
700 ✗ for (x = 0; x < w; x += 2) {
701 ✗ Y[x + 0 + 0 * ystride] = decode_sym(gb, lru[0]);
702 ✗ Y[x + 1 + 0 * ystride] = decode_sym(gb, lru[0]);
703 ✗ Y[x + 0 + 1 * ystride] = decode_sym(gb, lru[0]);
704 ✗ Y[x + 1 + 1 * ystride] = decode_sym(gb, lru[0]);
705 ✗ U[x >> 1] = decode_sym(gb, lru[1]) ^ 0x80;
706 ✗ V[x >> 1] = decode_sym(gb, lru[2]) ^ 0x80;
707 }
708 ✗ if (hmargin) {
709 ✗ Y[x + 0 * ystride] = decode_sym(gb, lru[0]);
710 ✗ Y[x + 1 * ystride] = decode_sym(gb, lru[0]);
711 ✗ U[huvborder] = decode_sym(gb, lru[1]) ^ 0x80;
712 ✗ V[huvborder] = decode_sym(gb, lru[2]) ^ 0x80;
713 }
714
715 ✗ Y += ystride * 2;
716 ✗ U += ustride;
717 ✗ V += vstride;
718 }
719
720 ✗ if (vmargin) {
721 ✗ for (x = 0; x < width; x += 2) {
722 ✗ Y[x + 0] = decode_sym(gb, lru[0]);
723 ✗ U[x >> 1] = decode_sym(gb, lru[1]) ^ 0x80;
724 ✗ V[x >> 1] = decode_sym(gb, lru[2]) ^ 0x80;
725 }
726 ✗ if (hmargin) {
727 ✗ Y[x] = decode_sym(gb, lru[0]);
728 ✗ U[huvborder] = decode_sym(gb, lru[1]) ^ 0x80;
729 ✗ V[huvborder] = decode_sym(gb, lru[2]) ^ 0x80;
730 }
731 }
732
733 ✗ return y;
734 }
735
736 ✗ static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic,
737 const uint8_t *src, int src_size,
738 uint32_t vflipped)
739 {
740 ✗ return dxtory_decode_v2(avctx, pic, src, src_size,
741 dx2_decode_slice_420,
742 default_setup_lru,
743 AV_PIX_FMT_YUV420P, vflipped);
744 }
745
746 ✗ static int dx2_decode_slice_444(GetBitContext *gb, AVFrame *frame,
747 int line, int left,
748 uint8_t lru[3][8])
749 {
750 int x, y;
751
752 ✗ int width = frame->width;
753
754 ✗ int ystride = frame->linesize[0];
755 ✗ int ustride = frame->linesize[1];
756 ✗ int vstride = frame->linesize[2];
757
758 ✗ uint8_t *Y = frame->data[0] + ystride * line;
759 ✗ uint8_t *U = frame->data[1] + ustride * line;
760 ✗ uint8_t *V = frame->data[2] + vstride * line;
761
762 ✗ for (y = 0; y < left && get_bits_left(gb) >= 3 * width; y++) {
763 ✗ for (x = 0; x < width; x++) {
764 ✗ Y[x] = decode_sym(gb, lru[0]);
765 ✗ U[x] = decode_sym(gb, lru[1]) ^ 0x80;
766 ✗ V[x] = decode_sym(gb, lru[2]) ^ 0x80;
767 }
768
769 ✗ Y += ystride;
770 ✗ U += ustride;
771 ✗ V += vstride;
772 }
773
774 ✗ return y;
775 }
776
777 ✗ static int dxtory_decode_v2_444(AVCodecContext *avctx, AVFrame *pic,
778 const uint8_t *src, int src_size,
779 uint32_t vflipped)
780 {
781 ✗ return dxtory_decode_v2(avctx, pic, src, src_size,
782 dx2_decode_slice_444,
783 default_setup_lru,
784 AV_PIX_FMT_YUV444P, vflipped);
785 }
786
787 2 static int decode_frame(AVCodecContext *avctx, AVFrame *pic,
788 int *got_frame, AVPacket *avpkt)
789 {
790 2 const uint8_t *src = avpkt->data;
791 uint32_t type;
792 int vflipped, ret;
793
794
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (avpkt->size < 16) {
795 ✗ av_log(avctx, AV_LOG_ERROR, "packet too small\n");
796 ✗ return AVERROR_INVALIDDATA;
797 }
798
799 2 type = AV_RB32(src);
800 2 vflipped = !!(type & 0x20);
801
802
1/13
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
 2 switch (type) {
803 ✗ case 0x01000021:
804 case 0x01000001:
805 ✗ ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
806 AV_PIX_FMT_BGR24, 3, vflipped);
807 ✗ break;
808 ✗ case 0x01000029:
809 case 0x01000009:
810 ✗ ret = dxtory_decode_v2_rgb(avctx, pic, src + 16, avpkt->size - 16, vflipped);
811 ✗ break;
812 2 case 0x02000021:
813 case 0x02000001:
814 2 ret = dxtory_decode_v1_420(avctx, pic, src + 16, avpkt->size - 16, vflipped);
815 2 break;
816 ✗ case 0x02000029:
817 case 0x02000009:
818 ✗ ret = dxtory_decode_v2_420(avctx, pic, src + 16, avpkt->size - 16, vflipped);
819 ✗ break;
820 ✗ case 0x03000021:
821 case 0x03000001:
822 ✗ ret = dxtory_decode_v1_410(avctx, pic, src + 16, avpkt->size - 16, vflipped);
823 ✗ break;
824 ✗ case 0x03000029:
825 case 0x03000009:
826 ✗ ret = dxtory_decode_v2_410(avctx, pic, src + 16, avpkt->size - 16, vflipped);
827 ✗ break;
828 ✗ case 0x04000021:
829 case 0x04000001:
830 ✗ ret = dxtory_decode_v1_444(avctx, pic, src + 16, avpkt->size - 16, vflipped);
831 ✗ break;
832 ✗ case 0x04000029:
833 case 0x04000009:
834 ✗ ret = dxtory_decode_v2_444(avctx, pic, src + 16, avpkt->size - 16, vflipped);
835 ✗ break;
836 ✗ case 0x17000021:
837 case 0x17000001:
838 ✗ ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
839 AV_PIX_FMT_RGB565LE, 2, vflipped);
840 ✗ break;
841 ✗ case 0x17000029:
842 case 0x17000009:
843 ✗ ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 1, vflipped);
844 ✗ break;
845 ✗ case 0x18000021:
846 case 0x19000021:
847 case 0x18000001:
848 case 0x19000001:
849 ✗ ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
850 AV_PIX_FMT_RGB555LE, 2, vflipped);
851 ✗ break;
852 ✗ case 0x18000029:
853 case 0x19000029:
854 case 0x18000009:
855 case 0x19000009:
856 ✗ ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 0, vflipped);
857 ✗ break;
858 ✗ default:
859 ✗ avpriv_request_sample(avctx, "Frame header %"PRIX32, type);
860 ✗ return AVERROR_PATCHWELCOME;
861 }
862
863
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (ret)
864 ✗ return ret;
865
866 2 *got_frame = 1;
867
868 2 return avpkt->size;
869 }
870
871 const FFCodec ff_dxtory_decoder = {
872 .p.name = "dxtory",
873 CODEC_LONG_NAME("Dxtory"),
874 .p.type = AVMEDIA_TYPE_VIDEO,
875 .p.id = AV_CODEC_ID_DXTORY,
876 FF_CODEC_DECODE_CB(decode_frame),
877 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
878 };
879