Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 | #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 * (int64_t)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 * 9L / 8) { | |
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) { | |
f6fa7814 DM |
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); | |
2ba45a60 DM |
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 * 3L / 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 * 3L) { | |
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 | 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 }; | |
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; | |
f6fa7814 | 413 | int nslices, slice, slice_height; |
2ba45a60 DM |
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 | ||
f6fa7814 | 427 | if (!nslices) { |
2ba45a60 DM |
428 | avpriv_request_sample(avctx, "%d slices for %dx%d", nslices, |
429 | avctx->width, avctx->height); | |
430 | return AVERROR_PATCHWELCOME; | |
431 | } | |
432 | ||
2ba45a60 DM |
433 | if ((avctx->width & 3) || (avctx->height & 3)) { |
434 | avpriv_request_sample(avctx, "Frame dimensions %dx%d", | |
435 | avctx->width, avctx->height); | |
436 | } | |
437 | ||
438 | avctx->pix_fmt = AV_PIX_FMT_YUV410P; | |
439 | if ((ret = ff_get_buffer(avctx, pic, 0)) < 0) | |
440 | return ret; | |
441 | ||
442 | Y = pic->data[0]; | |
443 | U = pic->data[1]; | |
444 | V = pic->data[2]; | |
445 | ||
446 | cur_y = 0; | |
2ba45a60 DM |
447 | for (slice = 0; slice < nslices; slice++) { |
448 | slice_size = bytestream2_get_le32(&gb); | |
f6fa7814 | 449 | next_y = ((slice + 1) * avctx->height) / nslices; |
2ba45a60 DM |
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; | |
456 | } | |
457 | if (slice_size <= 16) { | |
458 | av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size); | |
459 | return AVERROR_INVALIDDATA; | |
460 | } | |
461 | ||
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); | |
466 | } | |
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], | |
470 | pic->linesize[2]); | |
471 | ||
472 | Y += pic->linesize[0] * slice_height; | |
473 | U += pic->linesize[1] * (slice_height >> 2); | |
474 | V += pic->linesize[2] * (slice_height >> 2); | |
475 | off += slice_size; | |
476 | cur_y = next_y; | |
2ba45a60 DM |
477 | } |
478 | ||
479 | return 0; | |
480 | } | |
481 | ||
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) | |
485 | { | |
486 | int x, y, i; | |
487 | uint8_t lru[3][8]; | |
488 | ||
489 | for (i = 0; i < 3; i++) | |
490 | memcpy(lru[i], def_lru, 8 * sizeof(*def_lru)); | |
491 | ||
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; | |
500 | } | |
501 | ||
502 | Y += ystride << 1; | |
503 | U += ustride; | |
504 | V += vstride; | |
505 | } | |
506 | ||
507 | return 0; | |
508 | } | |
509 | ||
510 | static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic, | |
511 | const uint8_t *src, int src_size) | |
512 | { | |
513 | GetByteContext gb; | |
514 | GetBitContext gb2; | |
f6fa7814 | 515 | int nslices, slice, slice_height; |
2ba45a60 DM |
516 | int cur_y, next_y; |
517 | uint32_t off, slice_size; | |
518 | uint8_t *Y, *U, *V; | |
519 | int ret; | |
520 | ||
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; | |
527 | } | |
528 | ||
f6fa7814 | 529 | if (!nslices) { |
2ba45a60 DM |
530 | avpriv_request_sample(avctx, "%d slices for %dx%d", nslices, |
531 | avctx->width, avctx->height); | |
532 | return AVERROR_PATCHWELCOME; | |
533 | } | |
534 | ||
2ba45a60 DM |
535 | if ((avctx->width & 1) || (avctx->height & 1)) { |
536 | avpriv_request_sample(avctx, "Frame dimensions %dx%d", | |
537 | avctx->width, avctx->height); | |
538 | } | |
539 | ||
540 | avctx->pix_fmt = AV_PIX_FMT_YUV420P; | |
541 | if ((ret = ff_get_buffer(avctx, pic, 0)) < 0) | |
542 | return ret; | |
543 | ||
544 | Y = pic->data[0]; | |
545 | U = pic->data[1]; | |
546 | V = pic->data[2]; | |
547 | ||
548 | cur_y = 0; | |
2ba45a60 DM |
549 | for (slice = 0; slice < nslices; slice++) { |
550 | slice_size = bytestream2_get_le32(&gb); | |
f6fa7814 | 551 | next_y = ((slice + 1) * avctx->height) / nslices; |
2ba45a60 DM |
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; | |
558 | } | |
559 | if (slice_size <= 16) { | |
560 | av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size); | |
561 | return AVERROR_INVALIDDATA; | |
562 | } | |
563 | ||
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); | |
568 | } | |
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], | |
572 | pic->linesize[2]); | |
573 | ||
574 | Y += pic->linesize[0] * slice_height; | |
575 | U += pic->linesize[1] * (slice_height >> 1); | |
576 | V += pic->linesize[2] * (slice_height >> 1); | |
577 | off += slice_size; | |
578 | cur_y = next_y; | |
2ba45a60 DM |
579 | } |
580 | ||
581 | return 0; | |
582 | } | |
583 | ||
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) | |
587 | { | |
588 | int x, y, i; | |
589 | uint8_t lru[3][8]; | |
590 | ||
591 | for (i = 0; i < 3; i++) | |
592 | memcpy(lru[i], def_lru, 8 * sizeof(*def_lru)); | |
593 | ||
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; | |
599 | } | |
600 | ||
601 | Y += ystride; | |
602 | U += ustride; | |
603 | V += vstride; | |
604 | } | |
605 | ||
606 | return 0; | |
607 | } | |
608 | ||
609 | static int dxtory_decode_v2_444(AVCodecContext *avctx, AVFrame *pic, | |
610 | const uint8_t *src, int src_size) | |
611 | { | |
612 | GetByteContext gb; | |
613 | GetBitContext gb2; | |
614 | int nslices, slice, slice_height; | |
615 | uint32_t off, slice_size; | |
616 | uint8_t *Y, *U, *V; | |
617 | int ret; | |
618 | ||
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; | |
625 | } | |
626 | ||
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; | |
631 | } | |
632 | ||
633 | slice_height = avctx->height / nslices; | |
634 | ||
635 | avctx->pix_fmt = AV_PIX_FMT_YUV444P; | |
636 | if ((ret = ff_get_buffer(avctx, pic, 0)) < 0) | |
637 | return ret; | |
638 | ||
639 | Y = pic->data[0]; | |
640 | U = pic->data[1]; | |
641 | V = pic->data[2]; | |
642 | ||
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; | |
650 | } | |
651 | if (slice_size <= 16) { | |
652 | av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size); | |
653 | return AVERROR_INVALIDDATA; | |
654 | } | |
655 | ||
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); | |
660 | } | |
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], | |
664 | pic->linesize[2]); | |
665 | ||
666 | Y += pic->linesize[0] * slice_height; | |
667 | U += pic->linesize[1] * slice_height; | |
668 | V += pic->linesize[2] * slice_height; | |
669 | off += slice_size; | |
670 | } | |
671 | ||
672 | return 0; | |
673 | } | |
674 | ||
675 | static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, | |
676 | AVPacket *avpkt) | |
677 | { | |
678 | AVFrame *pic = data; | |
679 | const uint8_t *src = avpkt->data; | |
680 | int ret; | |
681 | ||
682 | if (avpkt->size < 16) { | |
683 | av_log(avctx, AV_LOG_ERROR, "packet too small\n"); | |
684 | return AVERROR_INVALIDDATA; | |
685 | } | |
686 | ||
687 | switch (AV_RB32(src)) { | |
688 | case 0x01000001: | |
689 | ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16, | |
690 | AV_PIX_FMT_BGR24, 3); | |
691 | break; | |
692 | case 0x01000009: | |
693 | ret = dxtory_decode_v2_rgb(avctx, pic, src + 16, avpkt->size - 16); | |
694 | break; | |
695 | case 0x02000001: | |
696 | ret = dxtory_decode_v1_420(avctx, pic, src + 16, avpkt->size - 16); | |
697 | break; | |
698 | case 0x02000009: | |
699 | ret = dxtory_decode_v2_420(avctx, pic, src + 16, avpkt->size - 16); | |
700 | break; | |
701 | case 0x03000001: | |
702 | ret = dxtory_decode_v1_410(avctx, pic, src + 16, avpkt->size - 16); | |
703 | break; | |
704 | case 0x03000009: | |
705 | ret = dxtory_decode_v2_410(avctx, pic, src + 16, avpkt->size - 16); | |
706 | break; | |
707 | case 0x04000001: | |
708 | ret = dxtory_decode_v1_444(avctx, pic, src + 16, avpkt->size - 16); | |
709 | break; | |
710 | case 0x04000009: | |
711 | ret = dxtory_decode_v2_444(avctx, pic, src + 16, avpkt->size - 16); | |
712 | break; | |
713 | case 0x17000001: | |
714 | ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16, | |
715 | AV_PIX_FMT_RGB565LE, 2); | |
716 | break; | |
717 | case 0x17000009: | |
718 | ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 1); | |
719 | break; | |
720 | case 0x18000001: | |
721 | case 0x19000001: | |
722 | ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16, | |
723 | AV_PIX_FMT_RGB555LE, 2); | |
724 | break; | |
725 | case 0x18000009: | |
726 | case 0x19000009: | |
727 | ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 0); | |
728 | break; | |
729 | default: | |
730 | avpriv_request_sample(avctx, "Frame header %"PRIX32, AV_RB32(src)); | |
731 | return AVERROR_PATCHWELCOME; | |
732 | } | |
733 | ||
734 | if (ret) | |
735 | return ret; | |
736 | ||
737 | pic->pict_type = AV_PICTURE_TYPE_I; | |
738 | pic->key_frame = 1; | |
739 | *got_frame = 1; | |
740 | ||
741 | return avpkt->size; | |
742 | } | |
743 | ||
744 | AVCodec ff_dxtory_decoder = { | |
745 | .name = "dxtory", | |
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, | |
751 | }; |