31 #define TOP 0x01000000
73 rc->
code = bytestream2_get_be32(gb);
80 for (comp = 0; comp < 3; comp++) {
81 for (j = 0; j < 4096; j++) {
83 for (i = 0; i < 256; i++)
85 for (i = 0; i < 16; i++)
92 for (j = 0; j < 6; j++) {
94 for (i = 0; i < 256; i++)
99 for (j = 0; j < 6; j++) {
101 for (i = 0; i < 6; i++)
106 for (i = 0; i < 256; i++) {
113 for (i = 0; i < 5; i++) {
118 for (j = 0; j < 4; j++) {
119 for (i = 0; i < 16; i++) {
125 for (i = 0; i < 512; i++) {
139 unsigned byte = bytestream2_get_byteu(gb);
169 t = rc->
range * (uint64_t)cumFreq / total_freq;
172 rc->
range = rc->
range * (uint64_t)(freq + cumFreq) / total_freq - (t + 1);
175 unsigned byte = bytestream2_get_byteu(gb);
189 *freq = total_freq * (uint64_t)(rc->
code - rc->
code1) / rc->
range;
198 unsigned totfr = cnt[maxc];
200 unsigned c = 0, cumfr = 0, cnt_c = 0;
203 if ((ret = s->
get_freq(rc, totfr, &value)) < 0)
208 if (value >= cumfr + cnt_c)
218 if ((ret = s->
decode(gb, rc, cumfr, cnt_c, totfr)) < 0)
221 cnt[
c] = cnt_c + step;
225 for (i = 0; i < maxc; i++) {
226 unsigned nc = (cnt[i] >> 1) + 1;
243 unsigned value, x = 0, cumfr = 0, cnt_x = 0;
244 int i, j, ret,
c, cnt_c;
246 if ((ret = s->
get_freq(rc, totfr, &value)) < 0)
251 if (value >= cumfr + cnt_x)
261 cnt_c = pixel->
freq[
c];
262 if (value >= cumfr + cnt_c)
268 if (x >= 16 || c >= 256) {
272 if ((ret = s->
decode(gb, rc, cumfr, cnt_c, totfr)) < 0)
275 pixel->
freq[
c] = cnt_c + step;
276 pixel->
lookup[x] = cnt_x + step;
280 for (i = 0; i < 256; i++) {
281 unsigned nc = (pixel->
freq[i] >> 1) + 1;
285 for (i = 0; i < 16; i++) {
287 unsigned i16_17 = i << 4;
288 for (j = 0; j < 16; j++)
289 sum += pixel->
freq[i16_17 + j];
295 *rval = c & s->
cbits;
303 const int cxshift = s->
cxshift;
310 *cx1 = (*cx << 6) & 0xFC0;
316 *cx1 = (*cx << 6) & 0xFC0;
322 *cx1 = (*cx << 6) & 0xFC0;
332 int cx = 0, cx1 = 0, k = 0, clr = 0;
333 int run, off, y = 0, x = 0, z, ret;
334 unsigned r,
g,
b, backstep = linesize - avctx->
width;
335 unsigned lx, ly, ptype;
341 while (k < avctx->
width + 1) {
352 clr = (b << 16) + (g << 8) +
r;
358 dst[y * linesize + x] = clr;
362 if (x >= avctx->
width) {
380 clr = (b << 16) + (g << 8) +
r;
396 dst[y * linesize + x] = clr;
400 if (x >= avctx->
width) {
411 dst[y * linesize + x] = dst[ly * linesize + lx];
415 if (x >= avctx->
width) {
420 clr = dst[ly * linesize + lx];
424 if (y < 1 || y >= avctx->
height)
427 clr = dst[y * linesize + x + off + 1];
428 dst[y * linesize + x] = clr;
432 if (x >= avctx->
width) {
442 if (y < 1 || y >= avctx->
height ||
452 r = odst[(ly * linesize + lx) * 4] +
453 odst[((y * linesize + x) + off) * 4 + 4] -
454 odst[((y * linesize + x) + off - z) * 4];
455 g = odst[(ly * linesize + lx) * 4 + 1] +
456 odst[((y * linesize + x) + off) * 4 + 5] -
457 odst[((y * linesize + x) + off - z) * 4 + 1];
458 b = odst[(ly * linesize + lx) * 4 + 2] +
459 odst[((y * linesize + x) + off) * 4 + 6] -
460 odst[((y * linesize + x) + off - z) * 4 + 2];
461 clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);
462 dst[y * linesize + x] = clr;
466 if (x >= avctx->
width) {
474 if (y < 1 || y >= avctx->
height ||
484 clr = dst[y * linesize + x + off - z];
485 dst[y * linesize + x] = clr;
489 if (x >= avctx->
width) {
498 cx1 = (clr & 0x3F00) >> 2;
499 cx = (clr & 0x3FFFFF) >> 16;
501 cx1 = (clr & 0xFC00) >> 4;
502 cx = (clr & 0xFFFFFF) >> 18;
510 uint32_t *dst,
int linesize,
511 uint32_t *prev,
int plinesize)
515 int ret,
temp,
min, max, x, y, cx = 0, cx1 = 0;
516 int backstep = linesize - avctx->
width;
518 if (bytestream2_get_byte(gb) == 0)
532 if (min > max || min >= s->
nbcount)
547 while (min < s->nbcount && count-- > 0) {
552 for (y = 0; y < s->
nby; y++) {
553 for (x = 0; x < s->
nbx; x++) {
554 int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
559 if (((s->
blocks[y * s->
nbx + x] - 1) & 1) > 0) {
570 if (((s->
blocks[y * s->
nbx + x] - 1) & 2) > 0) {
571 int i, j, by = y * 16, bx = x * 16;
582 if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
583 by + mvy + sy1 >= avctx->
height || bx + mvx + sx1 >= avctx->
width)
586 for (i = 0; i < sy2 - sy1 && (by + sy1 + i) < avctx->
height && (by + mvy + sy1 + i) < avctx->
height; i++) {
587 for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->
width && (bx + mvx + sx1 + j) < avctx->
width; j++) {
588 dst[(by + i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 + i) * plinesize + bx + sx1 + mvx + j];
592 int run, z, bx = x * 16 + sx1, by = y * 16 + sy1;
593 unsigned r,
g,
b, clr, ptype = 0;
595 for (; by < y * 16 + sy2 && by < avctx->
height;) {
604 clr = (b << 16) + (g << 8) +
r;
620 dst[by * linesize + bx] = clr;
622 if (bx >= x * 16 + sx2 || bx >= avctx->
width) {
641 clr = dst[by * linesize + bx - 1 - z];
642 dst[by * linesize + bx] = clr;
644 if (bx >= x * 16 + sx2 || bx >= avctx->
width) {
652 if (by < 1 || by >= avctx->
height)
655 clr = dst[(by - 1) * linesize + bx];
656 dst[by * linesize + bx] = clr;
658 if (bx >= x * 16 + sx2 || bx >= avctx->
width) {
669 clr = prev[by * plinesize + bx];
670 dst[by * linesize + bx] = clr;
672 if (bx >= x * 16 + sx2 || bx >= avctx->
width) {
682 if (by < 1 || by >= avctx->
height)
693 r = odst[((by - 1) * linesize + bx) * 4] +
694 odst[(by * linesize + bx - 1 - z) * 4] -
695 odst[((by - 1) * linesize + bx - 1 - z) * 4];
696 g = odst[((by - 1) * linesize + bx) * 4 + 1] +
697 odst[(by * linesize + bx - 1 - z) * 4 + 1] -
698 odst[((by - 1) * linesize + bx - 1 - z) * 4 + 1];
699 b = odst[((by - 1) * linesize + bx) * 4 + 2] +
700 odst[(by * linesize + bx - 1 - z) * 4 + 2] -
701 odst[((by - 1) * linesize + bx - 1 - z) * 4 + 2];
702 clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);
703 dst[by * linesize + bx] = clr;
705 if (bx >= x * 16 + sx2 || bx >= avctx->
width) {
713 if (by < 1 || by >= avctx->
height)
724 clr = dst[(by - 1) * linesize + bx - 1 - z];
725 dst[by * linesize + bx] = clr;
727 if (bx >= x * 16 + sx2 || bx >= avctx->
width) {
736 cx1 = (clr & 0x3F00) >> 2;
737 cx = (clr & 0x3FFFFF) >> 16;
739 cx1 = (clr & 0xFC00) >> 4;
740 cx = (clr & 0xFFFFFF) >> 18;
768 type = bytestream2_peek_byte(gb);
776 }
else if (type == 18) {
782 }
else if (type == 17) {
789 uint16_t
value = bytestream2_get_le16(gb);
793 g = (value >> 5) & 31;
794 b = (value >> 10) & 31;
795 clr = (r << 16) + (g << 8) +
b;
797 clr = bytestream2_get_le24(gb);
799 for (y = 0; y < avctx->
height; y++) {
800 for (x = 0; x < avctx->
width; x++) {
805 }
else if (type == 0 || type == 1) {
838 for (y = 0; y < avctx->
height; y++) {
840 if (!(((uintptr_t)dst) & 7)) {
841 uint64_t *dst64 = (uint64_t *)dst;
843 for (x = 0; x <
w; x++) {
844 dst64[x] = (dst64[x] << 3) & 0xFCFCFCFCFCFCFCFCULL;
849 for (; x < avctx->
width * 4; x++) {
850 dst[x] = dst[x] << 3;
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
unsigned mv_model[2][513]
static av_cold int decode_init(AVCodecContext *avctx)
int(* decode)(GetByteContext *gb, RangeCoder *rc, unsigned cumFreq, unsigned freq, unsigned total_freq)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
PixelModel pixel_model[3][4096]
static av_cold int init(AVCodecContext *avctx)
static int decode0(GetByteContext *gb, RangeCoder *rc, unsigned cumFreq, unsigned freq, unsigned total_freq)
static void reinit_tables(SCPRContext *s)
static int decode_value(SCPRContext *s, unsigned *cnt, unsigned maxc, unsigned step, unsigned *rval)
unsigned run_model[6][257]
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)
unsigned count_model[257]
static int decompress_i(AVCodecContext *avctx, uint32_t *dst, int linesize)
static int decompress_p(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
unsigned sxy_model[4][17]
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
int(* get_freq)(RangeCoder *rc, unsigned total_freq, unsigned *freq)
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_cold int decode_close(AVCodecContext *avctx)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static int decode(GetByteContext *gb, RangeCoder *rc, unsigned cumFreq, unsigned freq, unsigned total_freq)
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
const char * name
Name of the codec implementation.
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
unsigned range_model[257]
enum AVPictureType pict_type
Picture type of the frame.
int width
picture width / height.
GLsizei GLboolean const GLfloat * value
static void init_rangecoder(RangeCoder *rc, GetByteContext *gb)
static int get_freq0(RangeCoder *rc, unsigned total_freq, unsigned *freq)
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Libavcodec external API header.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
static int get_freq(RangeCoder *rc, unsigned total_freq, unsigned *freq)
common internal api header.
static int decode_unit(SCPRContext *s, PixelModel *pixel, unsigned step, unsigned *rval)
int key_frame
1 -> keyframe, 0-> not
#define av_malloc_array(a, b)
#define FFSWAP(type, a, b)
static int decode_units(SCPRContext *s, unsigned *r, unsigned *g, unsigned *b, int *cx, int *cx1)
This structure stores compressed data.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.