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);
99 while (num_literals-- > 0) {
100 history[pos++] = bytestream2_get_byte(gb);
111 delta = bytestream2_get_byte(gb);
112 delta |= (unsigned)bytestream2_get_byte(gb) << 8;
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++];
156 int ylinesize, ulinesize, vlinesize, alinesize;
157 uint16_t *dsty, *dstu, *dstv, *dsta;
213 s->
data_end = bytestream2_get_le32(gb);
214 if (s->
data_end > uncompressed_size)
233 dsty = (uint16_t *)p->
data[0];
234 dsta = (uint16_t *)p->
data[3];
238 for (
int y = 0; y < avctx->
height; y += 4) {
239 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;
263 dsty[x +
i * ylinesize + 0] = av_clip_uintp2(y_min + ((y_diff *
get_bits(&bit, nb_bits) + add) / div), 12);
264 dsty[x +
i * ylinesize + 1] = av_clip_uintp2(y_min + ((y_diff *
get_bits(&bit, nb_bits) + add) / div), 12);
265 dsty[x +
i * ylinesize + 2] = av_clip_uintp2(y_min + ((y_diff *
get_bits(&bit, nb_bits) + add) / div), 12);
266 dsty[x +
i * ylinesize + 3] = av_clip_uintp2(y_min + ((y_diff *
get_bits(&bit, nb_bits) + add) / div), 12);
270 dsty += 4 * ylinesize;
271 dsta += 4 * alinesize;
279 dstu = (uint16_t *)p->
data[1];
280 dstv = (uint16_t *)p->
data[2];
284 for (
int y = 0; y < avctx->
height; y += 16) {
285 for (
int x = 0; x < avctx->
width; x += 16) {
286 unsigned offset = bytestream2_get_le32(&rgb) * 4;
287 int u[16][16] = { 0 }, v[16][16] = { 0 };
288 int u0,
v0, u1, v1, udif, vdif;
289 unsigned escape, is8x8, loc;
293 is8x8 = bytestream2_get_le16(&dgb);
294 escape = bytestream2_get_le16(&dgb);
296 if (escape == 0 && is8x8 == 0) {
297 u0 = bytestream2_get_byte(&dgb);
298 v0 = bytestream2_get_byte(&dgb);
299 u1 = bytestream2_get_byte(&dgb);
300 v1 = bytestream2_get_byte(&dgb);
301 loc = bytestream2_get_le32(&dgb);
302 u0 = (u0 << 4) | (u0 & 0xF);
303 v0 = (v0 << 4) | (v0 & 0xF);
304 u1 = (u1 << 4) | (u1 & 0xF);
305 v1 = (v1 << 4) | (v1 & 0xF);
309 for (
int i = 0;
i < 16;
i += 4) {
310 for (
int j = 0; j < 16; j += 4) {
311 for (
int ii = 0; ii < 4; ii++) {
312 for (
int jj = 0; jj < 4; jj++) {
313 u[
i + ii][j + jj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
314 v[
i + ii][j + jj] = v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
322 for (
int i = 0;
i < 16;
i += 8) {
323 for (
int j = 0; j < 16; j += 8) {
325 u0 = bytestream2_get_byte(&dgb);
326 v0 = bytestream2_get_byte(&dgb);
327 u1 = bytestream2_get_byte(&dgb);
328 v1 = bytestream2_get_byte(&dgb);
329 loc = bytestream2_get_le32(&dgb);
330 u0 = (u0 << 4) | (u0 & 0xF);
331 v0 = (v0 << 4) | (v0 & 0xF);
332 u1 = (u1 << 4) | (u1 & 0xF);
333 v1 = (v1 << 4) | (v1 & 0xF);
337 for (
int ii = 0; ii < 8; ii += 2) {
338 for (
int jj = 0; jj < 8; jj += 2) {
339 for (
int iii = 0; iii < 2; iii++) {
340 for (
int jjj = 0; jjj < 2; jjj++) {
341 u[
i + ii + iii][j + jj + jjj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
342 v[
i + ii + iii][j + jj + jjj] = v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
350 for (
int ii = 0; ii < 8; ii += 4) {
351 for (
int jj = 0; jj < 8; jj += 4) {
352 u0 = bytestream2_get_byte(&dgb);
353 v0 = bytestream2_get_byte(&dgb);
354 u1 = bytestream2_get_byte(&dgb);
355 v1 = bytestream2_get_byte(&dgb);
356 loc = bytestream2_get_le32(&dgb);
357 u0 = (u0 << 4) | (u0 & 0xF);
358 v0 = (v0 << 4) | (v0 & 0xF);
359 u1 = (u1 << 4) | (u1 & 0xF);
360 v1 = (v1 << 4) | (v1 & 0xF);
364 for (
int iii = 0; iii < 4; iii++) {
365 for (
int jjj = 0; jjj < 4; jjj++) {
366 u[
i + ii + iii][j + jj + jjj] = u0 + ((udif * (
int)(loc & 3) + 2) / 3);
367 v[
i + ii + iii][j + jj + jjj] = v0 + ((vdif * (
int)(loc & 3) + 2) / 3);
381 for (
int i = 0;
i < 16;
i++) {
382 for (
int j = 0; j < 16; j++) {
383 dstu[x +
i * ulinesize + j] = u[
i][j];
384 dstv[x +
i * vlinesize + j] = v[
i][j];
389 dstu += 16 * ulinesize;
390 dstv += 16 * vlinesize;
397 void *
data,
int *got_frame,
408 if (avpkt->
size <= 40)
413 if (bytestream2_get_le32(gb) !=
MKBETAG(
'N',
'L',
'C',
'1'))
416 uncompressed_size = bytestream2_get_le32(gb);
418 s->
format = bytestream2_get_le32(gb);
428 if (uncompressed_size > s->
lzf_size)
432 }
else if (s->
format == 1) {
441 if (ret != uncompressed_size)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
unsigned a_control_word_offset
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
unsigned uncompressed_size
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.
static av_cold int init(AVCodecContext *avctx)
enum AVColorRange color_range
MPEG vs JPEG YUV range.
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
unsigned y_data_row_offsets
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
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...
static av_cold int decode_init(AVCodecContext *avctx)
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
AVCodec ff_notchlc_decoder
Multithreading support functions.
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
#define u(width, name, range_min, range_max)
unsigned y_control_data_offset
bitstream reader API header.
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
int ff_lzf_uncompress(GetByteContext *gb, uint8_t **buf, int64_t *size)
#define i(width, name, range_min, range_max)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
const char * name
Name of the codec implementation.
static const uint8_t offset[127][2]
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
enum AVPictureType pict_type
Picture type of the frame.
static int decode_blocks(AVCodecContext *avctx, AVFrame *p, ThreadFrame *frame, unsigned uncompressed_size)
int width
picture width / height.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p, const uint8_t *src, unsigned int size)
the normal 2^n-1 "JPEG" YUV ranges
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static av_always_inline int bytestream2_tell(GetByteContext *g)
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
static av_cold int decode_end(AVCodecContext *avctx)
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
uint8_t * uncompressed_buffer
#define AV_PIX_FMT_YUV444P12
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
IEC 61966-2-1 (sRGB or sYCC)
common internal api header.
static int lz4_decompress(AVCodecContext *avctx, GetByteContext *gb, PutByteContext *pb)
#define bit(string, value)
unsigned uv_offset_data_offset
#define MKBETAG(a, b, c, d)
int key_frame
1 -> keyframe, 0-> not
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
This structure stores compressed data.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.