26 #define BITSTREAM_READER_LE
74 #define HISTORY_SIZE (64 * 1024)
80 unsigned reference_pos, match_length,
delta,
pos = 0;
84 uint8_t token = bytestream2_get_byte(gb);
85 unsigned 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);
102 while (num_literals-- > 0) {
103 history[
pos++] = bytestream2_get_byte(gb);
114 delta = bytestream2_get_le16(gb);
117 match_length = 4 + (token & 0x0F);
118 if (match_length == 4 + 0x0F) {
122 current = bytestream2_get_byte(gb);
123 match_length += current;
124 }
while (current == 255);
128 if (
pos >= reference_pos + match_length || reference_pos >=
pos + match_length) {
129 memcpy(history +
pos, history + reference_pos, match_length);
132 while (match_length-- > 0)
133 history[
pos++] = history[reference_pos++];
136 while (match_length-- > 0) {
137 history[
pos++] = history[reference_pos++];
153 unsigned uncompressed_size)
158 int ylinesize, ulinesize, vlinesize, alinesize;
159 uint16_t *dsty, *dstu, *dstv, *dsta;
162 s->texture_size_x = bytestream2_get_le32(gb);
163 s->texture_size_y = bytestream2_get_le32(gb);
169 s->uv_offset_data_offset = bytestream2_get_le32(gb);
170 if (
s->uv_offset_data_offset >= UINT_MAX / 4)
172 s->uv_offset_data_offset *= 4;
173 if (
s->uv_offset_data_offset >= uncompressed_size)
176 s->y_control_data_offset = bytestream2_get_le32(gb);
177 if (
s->y_control_data_offset >= UINT_MAX / 4)
179 s->y_control_data_offset *= 4;
180 if (
s->y_control_data_offset >= uncompressed_size)
183 s->a_control_word_offset = bytestream2_get_le32(gb);
184 if (
s->a_control_word_offset >= UINT_MAX / 4)
186 s->a_control_word_offset *= 4;
187 if (
s->a_control_word_offset >= uncompressed_size)
190 s->uv_data_offset = bytestream2_get_le32(gb);
191 if (
s->uv_data_offset >= UINT_MAX / 4)
193 s->uv_data_offset *= 4;
194 if (
s->uv_data_offset >= uncompressed_size)
197 s->y_data_size = bytestream2_get_le32(gb);
198 if (
s->y_data_size >= UINT_MAX / 4)
201 s->a_data_offset = bytestream2_get_le32(gb);
202 if (
s->a_data_offset >= UINT_MAX / 4)
204 s->a_data_offset *= 4;
205 if (
s->a_data_offset >= uncompressed_size)
208 s->a_count_size = bytestream2_get_le32(gb);
209 if (
s->a_count_size >= UINT_MAX / 4)
211 s->a_count_size *= 4;
212 if (
s->a_count_size >= uncompressed_size)
215 s->data_end = bytestream2_get_le32(gb);
216 if (
s->data_end > uncompressed_size)
220 if (
s->data_end <=
s->y_data_size)
222 s->y_data_offset =
s->data_end -
s->y_data_size;
223 if (
s->y_data_offset <=
s->a_data_offset)
225 s->uv_count_offset =
s->y_data_offset -
s->a_data_offset;
238 dsty = (uint16_t *)p->
data[0];
239 dsta = (uint16_t *)p->
data[3];
243 for (
int y = 0; y < avctx->
height; y += 4) {
244 const unsigned row_offset = bytestream2_get_le32(&
rgb);
251 for (
int x = 0; x < avctx->
width; x += 4) {
252 unsigned item = bytestream2_get_le32(gb);
253 unsigned y_min = item & 4095;
254 unsigned y_max = (item >> 12) & 4095;
255 unsigned y_diff = y_max - y_min;
258 control[0] = (item >> 24) & 3;
259 control[1] = (item >> 26) & 3;
260 control[2] = (item >> 28) & 3;
261 control[3] = (item >> 30) & 3;
263 for (
int i = 0;
i < 4;
i++) {
264 const int nb_bits = control[
i] + 1;
265 const int div = (1 << nb_bits) - 1;
266 const int add = div - 1;
275 dsty += 4 * ylinesize;
281 if (
s->uv_count_offset ==
s->a_control_word_offset) {
282 for (
int y = 0; y < avctx->
height; y++) {
283 for (
int x = 0; x < avctx->
width; x++)
291 for (
int y = 0; y < avctx->
height; y += 16) {
292 for (
int x = 0; x < avctx->
width; x += 16) {
293 unsigned m = bytestream2_get_le32(gb);
294 unsigned offset = bytestream2_get_le32(gb);
295 unsigned alpha0, alpha1;
298 if (
offset >= UINT_MAX / 4)
305 control = bytestream2_get_le64(&dgb);
306 alpha0 = control & 0xFF;
307 alpha1 = (control >> 8) & 0xFF;
308 control = control >> 16;
310 for (
int by = 0; by < 4; by++) {
311 for (
int bx = 0; bx < 4; bx++) {
314 for (
int i = 0;
i < 4;
i++) {
315 for (
int j = 0; j < 4; j++) {
316 dsta[x + (
i + by * 4) * alinesize + bx * 4 + j] = 0;
321 for (
int i = 0;
i < 4;
i++) {
322 for (
int j = 0; j < 4; j++) {
323 dsta[x + (
i + by * 4) * alinesize + bx * 4 + j] = 4095;
328 for (
int i = 0;
i < 4;
i++) {
329 for (
int j = 0; j < 4; j++) {
330 dsta[x + (
i + by * 4) * alinesize + bx * 4 + j] = (alpha0 + (alpha1 - alpha0) * (control & 7)) << 4;
344 dsta += 16 * alinesize;
350 dstu = (uint16_t *)p->
data[1];
351 dstv = (uint16_t *)p->
data[2];
355 for (
int y = 0; y < avctx->
height; y += 16) {
356 for (
int x = 0; x < avctx->
width; x += 16) {
357 unsigned offset = bytestream2_get_le32(&
rgb) * 4;
358 int u[16][16] = { 0 }, v[16][16] = { 0 };
359 int u0,
v0, u1, v1, udif, vdif;
360 unsigned escape, is8x8, loc;
364 is8x8 = bytestream2_get_le16(&dgb);
365 escape = bytestream2_get_le16(&dgb);
367 if (escape == 0 && is8x8 == 0) {
368 u0 = bytestream2_get_byte(&dgb);
369 v0 = bytestream2_get_byte(&dgb);
370 u1 = bytestream2_get_byte(&dgb);
371 v1 = bytestream2_get_byte(&dgb);
372 loc = bytestream2_get_le32(&dgb);
373 u0 = (u0 << 4) | (u0 & 0xF);
374 v0 = (
v0 << 4) | (
v0 & 0xF);
375 u1 = (u1 << 4) | (u1 & 0xF);
376 v1 = (v1 << 4) | (v1 & 0xF);
380 for (
int i = 0;
i < 16;
i += 4) {
381 for (
int j = 0; j < 16; j += 4) {
382 for (
int ii = 0; ii < 4; ii++) {
383 for (
int jj = 0; jj < 4; jj++) {
384 u[
i + ii][j + jj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
385 v[
i + ii][j + jj] =
v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
393 for (
int i = 0;
i < 16;
i += 8) {
394 for (
int j = 0; j < 16; j += 8) {
396 u0 = bytestream2_get_byte(&dgb);
397 v0 = bytestream2_get_byte(&dgb);
398 u1 = bytestream2_get_byte(&dgb);
399 v1 = bytestream2_get_byte(&dgb);
400 loc = bytestream2_get_le32(&dgb);
401 u0 = (u0 << 4) | (u0 & 0xF);
402 v0 = (
v0 << 4) | (
v0 & 0xF);
403 u1 = (u1 << 4) | (u1 & 0xF);
404 v1 = (v1 << 4) | (v1 & 0xF);
408 for (
int ii = 0; ii < 8; ii += 2) {
409 for (
int jj = 0; jj < 8; jj += 2) {
410 for (
int iii = 0; iii < 2; iii++) {
411 for (
int jjj = 0; jjj < 2; jjj++) {
412 u[
i + ii + iii][j + jj + jjj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
413 v[
i + ii + iii][j + jj + jjj] =
v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
421 for (
int ii = 0; ii < 8; ii += 4) {
422 for (
int jj = 0; jj < 8; jj += 4) {
423 u0 = bytestream2_get_byte(&dgb);
424 v0 = bytestream2_get_byte(&dgb);
425 u1 = bytestream2_get_byte(&dgb);
426 v1 = bytestream2_get_byte(&dgb);
427 loc = bytestream2_get_le32(&dgb);
428 u0 = (u0 << 4) | (u0 & 0xF);
429 v0 = (
v0 << 4) | (
v0 & 0xF);
430 u1 = (u1 << 4) | (u1 & 0xF);
431 v1 = (v1 << 4) | (v1 & 0xF);
435 for (
int iii = 0; iii < 4; iii++) {
436 for (
int jjj = 0; jjj < 4; jjj++) {
437 u[
i + ii + iii][j + jj + jjj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
438 v[
i + ii + iii][j + jj + jjj] =
v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
452 for (
int i = 0;
i < 16;
i++) {
453 for (
int j = 0; j < 16; j++) {
454 dstu[x +
i * ulinesize + j] =
u[
i][j];
455 dstv[x +
i * vlinesize + j] = v[
i][j];
460 dstu += 16 * ulinesize;
461 dstv += 16 * vlinesize;
468 void *
data,
int *got_frame,
475 unsigned uncompressed_size;
479 if (avpkt->
size <= 40)
484 if (bytestream2_get_le32(gb) !=
MKBETAG(
'N',
'L',
'C',
'1'))
487 uncompressed_size = bytestream2_get_le32(gb);
488 s->compressed_size = bytestream2_get_le32(gb);
489 s->format = bytestream2_get_le32(gb);
494 if (
s->format == 0) {
499 if (uncompressed_size >
s->lzf_size)
503 }
else if (
s->format == 1) {
509 if (!
s->uncompressed_buffer)
515 if (ret != uncompressed_size)
538 s->uncompressed_size = 0;
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
static av_always_inline int bytestream2_tell(GetByteContext *g)
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p, const uint8_t *src, unsigned int size)
#define u(width, name, range_min, range_max)
#define bit(string, value)
#define MKBETAG(a, b, c, d)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static float add(float src0, float src1)
bitstream reader API header.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
@ AV_PICTURE_TYPE_I
Intra.
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int ff_lzf_uncompress(GetByteContext *gb, uint8_t **buf, int64_t *size)
AVCodec ff_notchlc_decoder
static int decode_blocks(AVCodecContext *avctx, AVFrame *p, ThreadFrame *frame, unsigned uncompressed_size)
static av_cold int decode_init(AVCodecContext *avctx)
static av_cold int decode_end(AVCodecContext *avctx)
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static int lz4_decompress(AVCodecContext *avctx, GetByteContext *gb, PutByteContext *pb)
@ AVCOL_RANGE_JPEG
Full range content.
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
#define AV_PIX_FMT_YUVA444P12
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
static const SheerTable rgb[2]
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int key_frame
1 -> keyframe, 0-> not
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
uint8_t * uncompressed_buffer
unsigned uncompressed_size
unsigned y_control_data_offset
unsigned uv_offset_data_offset
unsigned y_data_row_offsets
unsigned a_control_word_offset
static const uint8_t offset[127][2]