25 #define BITSTREAM_READER_LE
73 #define HISTORY_SIZE (64 * 1024)
79 unsigned reference_pos,
delta,
pos = 0;
80 uint8_t history[64 * 1024];
84 uint8_t token = bytestream2_get_byte(gb);
85 int num_literals = token >> 4;
87 if (num_literals == 15) {
88 unsigned char current;
90 current = bytestream2_get_byte(gb);
91 num_literals += current;
92 }
while (current == 255);
99 while (num_literals-- > 0) {
100 history[
pos++] = bytestream2_get_byte(gb);
111 delta = bytestream2_get_le16(gb);
114 match_length = 4 + (token & 0x0F);
115 if (match_length == 4 + 0x0F) {
119 current = bytestream2_get_byte(gb);
120 match_length += current;
121 }
while (current == 255);
125 if (
pos >= reference_pos + match_length || reference_pos >=
pos + match_length) {
126 memcpy(history +
pos, history + reference_pos, match_length);
129 while (match_length-- > 0)
130 history[
pos++] = history[reference_pos++];
133 while (match_length-- > 0) {
134 history[
pos++] = history[reference_pos++];
150 unsigned uncompressed_size)
155 int ylinesize, ulinesize, vlinesize, alinesize;
156 uint16_t *dsty, *dstu, *dstv, *dsta;
159 s->texture_size_x = bytestream2_get_le32(gb);
160 s->texture_size_y = bytestream2_get_le32(gb);
166 s->uv_offset_data_offset = bytestream2_get_le32(gb);
167 if (
s->uv_offset_data_offset >= UINT_MAX / 4)
169 s->uv_offset_data_offset *= 4;
170 if (
s->uv_offset_data_offset >= uncompressed_size)
173 s->y_control_data_offset = bytestream2_get_le32(gb);
174 if (
s->y_control_data_offset >= UINT_MAX / 4)
176 s->y_control_data_offset *= 4;
177 if (
s->y_control_data_offset >= uncompressed_size)
180 s->a_control_word_offset = bytestream2_get_le32(gb);
181 if (
s->a_control_word_offset >= UINT_MAX / 4)
183 s->a_control_word_offset *= 4;
184 if (
s->a_control_word_offset >= uncompressed_size)
187 s->uv_data_offset = bytestream2_get_le32(gb);
188 if (
s->uv_data_offset >= UINT_MAX / 4)
190 s->uv_data_offset *= 4;
191 if (
s->uv_data_offset >= uncompressed_size)
194 s->y_data_size = bytestream2_get_le32(gb);
195 if (
s->y_data_size >= UINT_MAX / 4)
198 s->a_data_offset = bytestream2_get_le32(gb);
199 if (
s->a_data_offset >= UINT_MAX / 4)
201 s->a_data_offset *= 4;
202 if (
s->a_data_offset >= uncompressed_size)
205 s->a_count_size = bytestream2_get_le32(gb);
206 if (
s->a_count_size >= UINT_MAX / 4)
208 s->a_count_size *= 4;
209 if (
s->a_count_size >= uncompressed_size)
212 s->data_end = bytestream2_get_le32(gb);
213 if (
s->data_end > uncompressed_size)
217 if (
s->data_end <=
s->y_data_size)
219 s->y_data_offset =
s->data_end -
s->y_data_size;
220 if (
s->y_data_offset <=
s->a_data_offset)
222 s->uv_count_offset =
s->y_data_offset -
s->a_data_offset;
235 dsty = (uint16_t *)p->
data[0];
236 dsta = (uint16_t *)p->
data[3];
240 for (
int y = 0; y < avctx->
height; y += 4) {
241 const unsigned row_offset = bytestream2_get_le32(&
rgb);
246 for (
int x = 0; x < avctx->
width; x += 4) {
247 unsigned item = bytestream2_get_le32(gb);
248 unsigned y_min = item & 4095;
249 unsigned y_max = (item >> 12) & 4095;
250 unsigned y_diff = y_max - y_min;
253 control[0] = (item >> 24) & 3;
254 control[1] = (item >> 26) & 3;
255 control[2] = (item >> 28) & 3;
256 control[3] = (item >> 30) & 3;
258 for (
int i = 0;
i < 4;
i++) {
259 const int nb_bits = control[
i] + 1;
260 const int div = (1 << nb_bits) - 1;
261 const int add = div - 1;
270 dsty += 4 * ylinesize;
276 if (
s->uv_count_offset ==
s->a_control_word_offset) {
277 for (
int y = 0; y < avctx->
height; y++) {
278 for (
int x = 0; x < avctx->
width; x++)
286 for (
int y = 0; y < avctx->
height; y += 16) {
287 for (
int x = 0; x < avctx->
width; x += 16) {
288 unsigned m = bytestream2_get_le32(gb);
289 unsigned offset = bytestream2_get_le32(gb);
290 unsigned alpha0, alpha1;
293 if (
offset >= UINT_MAX / 4)
300 control = bytestream2_get_le64(&dgb);
301 alpha0 = control & 0xFF;
302 alpha1 = (control >> 8) & 0xFF;
303 control = control >> 16;
305 for (
int by = 0; by < 4; by++) {
306 for (
int bx = 0; bx < 4; bx++) {
309 for (
int i = 0;
i < 4;
i++) {
310 for (
int j = 0; j < 4; j++) {
311 dsta[x + (
i + by * 4) * alinesize + bx * 4 + j] = 0;
316 for (
int i = 0;
i < 4;
i++) {
317 for (
int j = 0; j < 4; j++) {
318 dsta[x + (
i + by * 4) * alinesize + bx * 4 + j] = 4095;
323 for (
int i = 0;
i < 4;
i++) {
324 for (
int j = 0; j < 4; j++) {
325 dsta[x + (
i + by * 4) * alinesize + bx * 4 + j] = (alpha0 + (alpha1 - alpha0) * (control & 7)) << 4;
339 dsta += 16 * alinesize;
345 dstu = (uint16_t *)p->
data[1];
346 dstv = (uint16_t *)p->
data[2];
350 for (
int y = 0; y < avctx->
height; y += 16) {
351 for (
int x = 0; x < avctx->
width; x += 16) {
352 unsigned offset = bytestream2_get_le32(&
rgb) * 4;
353 int u[16][16] = { 0 }, v[16][16] = { 0 };
354 int u0,
v0, u1, v1, udif, vdif;
355 unsigned escape, is8x8, loc;
359 is8x8 = bytestream2_get_le16(&dgb);
360 escape = bytestream2_get_le16(&dgb);
362 if (escape == 0 && is8x8 == 0) {
363 u0 = bytestream2_get_byte(&dgb);
364 v0 = bytestream2_get_byte(&dgb);
365 u1 = bytestream2_get_byte(&dgb);
366 v1 = bytestream2_get_byte(&dgb);
367 loc = bytestream2_get_le32(&dgb);
368 u0 = (u0 << 4) | (u0 & 0xF);
369 v0 = (
v0 << 4) | (
v0 & 0xF);
370 u1 = (u1 << 4) | (u1 & 0xF);
371 v1 = (v1 << 4) | (v1 & 0xF);
375 for (
int i = 0;
i < 16;
i += 4) {
376 for (
int j = 0; j < 16; j += 4) {
377 for (
int ii = 0; ii < 4; ii++) {
378 for (
int jj = 0; jj < 4; jj++) {
379 u[
i + ii][j + jj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
380 v[
i + ii][j + jj] =
v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
388 for (
int i = 0;
i < 16;
i += 8) {
389 for (
int j = 0; j < 16; j += 8) {
391 u0 = bytestream2_get_byte(&dgb);
392 v0 = bytestream2_get_byte(&dgb);
393 u1 = bytestream2_get_byte(&dgb);
394 v1 = bytestream2_get_byte(&dgb);
395 loc = bytestream2_get_le32(&dgb);
396 u0 = (u0 << 4) | (u0 & 0xF);
397 v0 = (
v0 << 4) | (
v0 & 0xF);
398 u1 = (u1 << 4) | (u1 & 0xF);
399 v1 = (v1 << 4) | (v1 & 0xF);
403 for (
int ii = 0; ii < 8; ii += 2) {
404 for (
int jj = 0; jj < 8; jj += 2) {
405 for (
int iii = 0; iii < 2; iii++) {
406 for (
int jjj = 0; jjj < 2; jjj++) {
407 u[
i + ii + iii][j + jj + jjj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
408 v[
i + ii + iii][j + jj + jjj] =
v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
416 for (
int ii = 0; ii < 8; ii += 4) {
417 for (
int jj = 0; jj < 8; jj += 4) {
418 u0 = bytestream2_get_byte(&dgb);
419 v0 = bytestream2_get_byte(&dgb);
420 u1 = bytestream2_get_byte(&dgb);
421 v1 = bytestream2_get_byte(&dgb);
422 loc = bytestream2_get_le32(&dgb);
423 u0 = (u0 << 4) | (u0 & 0xF);
424 v0 = (
v0 << 4) | (
v0 & 0xF);
425 u1 = (u1 << 4) | (u1 & 0xF);
426 v1 = (v1 << 4) | (v1 & 0xF);
430 for (
int iii = 0; iii < 4; iii++) {
431 for (
int jjj = 0; jjj < 4; jjj++) {
432 u[
i + ii + iii][j + jj + jjj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
433 v[
i + ii + iii][j + jj + jjj] =
v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
447 for (
int i = 0;
i < 16;
i++) {
448 for (
int j = 0; j < 16; j++) {
449 dstu[x +
i * ulinesize + j] =
u[
i][j];
450 dstv[x +
i * vlinesize + j] = v[
i][j];
455 dstu += 16 * ulinesize;
456 dstv += 16 * vlinesize;
468 unsigned uncompressed_size;
471 if (avpkt->
size <= 40)
476 if (bytestream2_get_le32(gb) !=
MKBETAG(
'N',
'L',
'C',
'1'))
479 uncompressed_size = bytestream2_get_le32(gb);
480 s->compressed_size = bytestream2_get_le32(gb);
481 s->format = bytestream2_get_le32(gb);
486 if (
s->format == 0) {
491 if (uncompressed_size >
s->lzf_size)
495 }
else if (
s->format == 1) {
501 if (!
s->uncompressed_buffer)
507 if (
ret != uncompressed_size)
530 s->uncompressed_size = 0;