25 #define BITSTREAM_READER_LE
74 #define HISTORY_SIZE (64 * 1024)
80 unsigned reference_pos,
delta,
pos = 0;
81 uint8_t history[64 * 1024];
85 uint8_t token = bytestream2_get_byte(gb);
86 int num_literals = token >> 4;
88 if (num_literals == 15) {
89 unsigned char current;
91 current = bytestream2_get_byte(gb);
92 num_literals += current;
93 }
while (current == 255);
100 while (num_literals-- > 0) {
101 history[
pos++] = bytestream2_get_byte(gb);
112 delta = bytestream2_get_le16(gb);
115 match_length = 4 + (token & 0x0F);
116 if (match_length == 4 + 0x0F) {
120 current = bytestream2_get_byte(gb);
121 match_length += current;
122 }
while (current == 255);
126 if (
pos >= reference_pos + match_length || reference_pos >=
pos + match_length) {
127 memcpy(history +
pos, history + reference_pos, match_length);
130 while (match_length-- > 0)
131 history[
pos++] = history[reference_pos++];
134 while (match_length-- > 0) {
135 history[
pos++] = history[reference_pos++];
151 unsigned uncompressed_size)
156 int ylinesize, ulinesize, vlinesize, alinesize;
157 uint16_t *dsty, *dstu, *dstv, *dsta;
160 s->texture_size_x = bytestream2_get_le32(gb);
161 s->texture_size_y = bytestream2_get_le32(gb);
167 s->uv_offset_data_offset = bytestream2_get_le32(gb);
168 if (
s->uv_offset_data_offset >= UINT_MAX / 4)
170 s->uv_offset_data_offset *= 4;
171 if (
s->uv_offset_data_offset >= uncompressed_size)
174 s->y_control_data_offset = bytestream2_get_le32(gb);
175 if (
s->y_control_data_offset >= UINT_MAX / 4)
177 s->y_control_data_offset *= 4;
178 if (
s->y_control_data_offset >= uncompressed_size)
181 s->a_control_word_offset = bytestream2_get_le32(gb);
182 if (
s->a_control_word_offset >= UINT_MAX / 4)
184 s->a_control_word_offset *= 4;
185 if (
s->a_control_word_offset >= uncompressed_size)
188 s->uv_data_offset = bytestream2_get_le32(gb);
189 if (
s->uv_data_offset >= UINT_MAX / 4)
191 s->uv_data_offset *= 4;
192 if (
s->uv_data_offset >= uncompressed_size)
195 s->y_data_size = bytestream2_get_le32(gb);
196 if (
s->y_data_size >= UINT_MAX / 4)
199 s->a_data_offset = bytestream2_get_le32(gb);
200 if (
s->a_data_offset >= UINT_MAX / 4)
202 s->a_data_offset *= 4;
203 if (
s->a_data_offset >= uncompressed_size)
206 s->a_count_size = bytestream2_get_le32(gb);
207 if (
s->a_count_size >= UINT_MAX / 4)
209 s->a_count_size *= 4;
210 if (
s->a_count_size >= uncompressed_size)
213 s->data_end = bytestream2_get_le32(gb);
214 if (
s->data_end > uncompressed_size)
218 if (
s->data_end <=
s->y_data_size)
220 s->y_data_offset =
s->data_end -
s->y_data_size;
221 if (
s->y_data_offset <=
s->a_data_offset)
223 s->uv_count_offset =
s->y_data_offset -
s->a_data_offset;
236 dsty = (uint16_t *)p->
data[0];
237 dsta = (uint16_t *)p->
data[3];
241 for (
int y = 0; y < avctx->
height; y += 4) {
242 const unsigned row_offset = bytestream2_get_le32(&
rgb);
249 for (
int x = 0; x < avctx->
width; x += 4) {
250 unsigned item = bytestream2_get_le32(gb);
251 unsigned y_min = item & 4095;
252 unsigned y_max = (item >> 12) & 4095;
253 unsigned y_diff = y_max - y_min;
256 control[0] = (item >> 24) & 3;
257 control[1] = (item >> 26) & 3;
258 control[2] = (item >> 28) & 3;
259 control[3] = (item >> 30) & 3;
261 for (
int i = 0;
i < 4;
i++) {
262 const int nb_bits = control[
i] + 1;
263 const int div = (1 << nb_bits) - 1;
264 const int add = div - 1;
273 dsty += 4 * ylinesize;
279 if (
s->uv_count_offset ==
s->a_control_word_offset) {
280 for (
int y = 0; y < avctx->
height; y++) {
281 for (
int x = 0; x < avctx->
width; x++)
289 for (
int y = 0; y < avctx->
height; y += 16) {
290 for (
int x = 0; x < avctx->
width; x += 16) {
291 unsigned m = bytestream2_get_le32(gb);
292 unsigned offset = bytestream2_get_le32(gb);
293 unsigned alpha0, alpha1;
296 if (
offset >= UINT_MAX / 4)
303 control = bytestream2_get_le64(&dgb);
304 alpha0 = control & 0xFF;
305 alpha1 = (control >> 8) & 0xFF;
306 control = control >> 16;
308 for (
int by = 0; by < 4; by++) {
309 for (
int bx = 0; bx < 4; bx++) {
312 for (
int i = 0;
i < 4;
i++) {
313 for (
int j = 0; j < 4; j++) {
314 dsta[x + (
i + by * 4) * alinesize + bx * 4 + j] = 0;
319 for (
int i = 0;
i < 4;
i++) {
320 for (
int j = 0; j < 4; j++) {
321 dsta[x + (
i + by * 4) * alinesize + bx * 4 + j] = 4095;
326 for (
int i = 0;
i < 4;
i++) {
327 for (
int j = 0; j < 4; j++) {
328 dsta[x + (
i + by * 4) * alinesize + bx * 4 + j] = (alpha0 + (alpha1 - alpha0) * (control & 7)) << 4;
342 dsta += 16 * alinesize;
348 dstu = (uint16_t *)p->
data[1];
349 dstv = (uint16_t *)p->
data[2];
353 for (
int y = 0; y < avctx->
height; y += 16) {
354 for (
int x = 0; x < avctx->
width; x += 16) {
355 unsigned offset = bytestream2_get_le32(&
rgb) * 4;
356 int u[16][16] = { 0 }, v[16][16] = { 0 };
357 int u0, v0, u1, v1, udif, vdif;
358 unsigned escape, is8x8, loc;
362 is8x8 = bytestream2_get_le16(&dgb);
363 escape = bytestream2_get_le16(&dgb);
365 if (escape == 0 && is8x8 == 0) {
366 u0 = bytestream2_get_byte(&dgb);
367 v0 = bytestream2_get_byte(&dgb);
368 u1 = bytestream2_get_byte(&dgb);
369 v1 = bytestream2_get_byte(&dgb);
370 loc = bytestream2_get_le32(&dgb);
371 u0 = (u0 << 4) | (u0 & 0xF);
372 v0 = (v0 << 4) | (v0 & 0xF);
373 u1 = (u1 << 4) | (u1 & 0xF);
374 v1 = (v1 << 4) | (v1 & 0xF);
378 for (
int i = 0;
i < 16;
i += 4) {
379 for (
int j = 0; j < 16; j += 4) {
380 for (
int ii = 0; ii < 4; ii++) {
381 for (
int jj = 0; jj < 4; jj++) {
382 u[
i + ii][j + jj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
383 v[
i + ii][j + jj] = v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
391 for (
int i = 0;
i < 16;
i += 8) {
392 for (
int j = 0; j < 16; j += 8) {
394 u0 = bytestream2_get_byte(&dgb);
395 v0 = bytestream2_get_byte(&dgb);
396 u1 = bytestream2_get_byte(&dgb);
397 v1 = bytestream2_get_byte(&dgb);
398 loc = bytestream2_get_le32(&dgb);
399 u0 = (u0 << 4) | (u0 & 0xF);
400 v0 = (v0 << 4) | (v0 & 0xF);
401 u1 = (u1 << 4) | (u1 & 0xF);
402 v1 = (v1 << 4) | (v1 & 0xF);
406 for (
int ii = 0; ii < 8; ii += 2) {
407 for (
int jj = 0; jj < 8; jj += 2) {
408 for (
int iii = 0; iii < 2; iii++) {
409 for (
int jjj = 0; jjj < 2; jjj++) {
410 u[
i + ii + iii][j + jj + jjj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
411 v[
i + ii + iii][j + jj + jjj] = v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
419 for (
int ii = 0; ii < 8; ii += 4) {
420 for (
int jj = 0; jj < 8; jj += 4) {
421 u0 = bytestream2_get_byte(&dgb);
422 v0 = bytestream2_get_byte(&dgb);
423 u1 = bytestream2_get_byte(&dgb);
424 v1 = bytestream2_get_byte(&dgb);
425 loc = bytestream2_get_le32(&dgb);
426 u0 = (u0 << 4) | (u0 & 0xF);
427 v0 = (v0 << 4) | (v0 & 0xF);
428 u1 = (u1 << 4) | (u1 & 0xF);
429 v1 = (v1 << 4) | (v1 & 0xF);
433 for (
int iii = 0; iii < 4; iii++) {
434 for (
int jjj = 0; jjj < 4; jjj++) {
435 u[
i + ii + iii][j + jj + jjj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
436 v[
i + ii + iii][j + jj + jjj] = v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
450 for (
int i = 0;
i < 16;
i++) {
451 for (
int j = 0; j < 16; j++) {
452 dstu[x +
i * ulinesize + j] =
u[
i][j];
453 dstv[x +
i * vlinesize + j] = v[
i][j];
458 dstu += 16 * ulinesize;
459 dstv += 16 * vlinesize;
471 unsigned uncompressed_size;
474 if (avpkt->
size <= 40)
479 if (bytestream2_get_le32(gb) !=
MKBETAG(
'N',
'L',
'C',
'1'))
482 uncompressed_size = bytestream2_get_le32(gb);
483 s->compressed_size = bytestream2_get_le32(gb);
484 s->format = bytestream2_get_le32(gb);
489 if (
s->format == 0) {
494 if (uncompressed_size >
s->lzf_size)
498 }
else if (
s->format == 1) {
504 if (!
s->uncompressed_buffer)
510 if (
ret != uncompressed_size)
530 s->uncompressed_size = 0;