33 #define TOP 0x01000000
41 rc->
range = 0xFFFFFFFFU;
42 rc->
code = bytestream2_get_be32(gb);
50 for (j = 0; j < 4096; j++) {
51 if (
s->pixel_model[
comp][j].total_freq != 256) {
52 for (
i = 0;
i < 256;
i++)
53 s->pixel_model[
comp][j].freq[
i] = 1;
55 s->pixel_model[
comp][j].lookup[
i] = 16;
56 s->pixel_model[
comp][j].total_freq = 256;
61 for (j = 0; j < 6; j++) {
62 uint32_t *p =
s->run_model[j];
63 for (
i = 0;
i < 256;
i++)
68 for (j = 0; j < 6; j++) {
69 uint32_t *
op =
s->op_model[j];
70 for (
i = 0;
i < 6;
i++)
75 for (
i = 0;
i < 256;
i++) {
76 s->range_model[
i] = 1;
77 s->count_model[
i] = 1;
79 s->range_model[256] = 256;
80 s->count_model[256] = 256;
82 for (
i = 0;
i < 5;
i++) {
87 for (j = 0; j < 4; j++) {
88 for (
i = 0;
i < 16;
i++) {
89 s->sxy_model[j][
i] = 1;
91 s->sxy_model[j][16] = 16;
94 for (
i = 0;
i < 512;
i++) {
95 s->mv_model[0][
i] = 1;
96 s->mv_model[1][
i] = 1;
98 s->mv_model[0][512] = 512;
99 s->mv_model[1][512] = 512;
108 uint32_t
byte = bytestream2_get_byteu(gb);
138 t = rc->
range * (uint64_t)cumFreq / total_freq;
141 rc->
range = rc->
range * (uint64_t)(freq + cumFreq) / total_freq - (t + 1);
144 uint32_t
byte = bytestream2_get_byteu(gb);
158 *freq = total_freq * (uint64_t)(rc->
code - rc->
code1) / rc->
range;
167 uint32_t totfr = cnt[maxc];
169 uint32_t
c = 0, cumfr = 0, cnt_c = 0;
172 if ((ret =
s->get_freq(rc, totfr, &
value)) < 0)
177 if (
value >= cumfr + cnt_c)
187 if ((ret =
s->decode(gb, rc, cumfr, cnt_c, totfr)) < 0)
190 cnt[
c] = cnt_c + step;
194 for (
i = 0;
i < maxc;
i++) {
195 uint32_t nc = (cnt[
i] >> 1) + 1;
211 uint32_t totfr =
pixel->total_freq;
212 uint32_t
value, x = 0, cumfr = 0, cnt_x = 0;
213 int i, j, ret,
c, cnt_c;
215 if ((ret =
s->get_freq(rc, totfr, &
value)) < 0)
219 cnt_x =
pixel->lookup[x];
220 if (
value >= cumfr + cnt_x)
231 if (
value >= cumfr + cnt_c)
237 if (x >= 16 ||
c >= 256) {
241 if ((ret =
s->decode(gb, rc, cumfr, cnt_c, totfr)) < 0)
244 pixel->freq[
c] = cnt_c + step;
245 pixel->lookup[x] = cnt_x + step;
249 for (
i = 0;
i < 256;
i++) {
250 uint32_t nc = (
pixel->freq[
i] >> 1) + 1;
254 for (
i = 0;
i < 16;
i++) {
256 uint32_t i16_17 =
i << 4;
257 for (j = 0; j < 16; j++)
258 sum +=
pixel->freq[i16_17 + j];
262 pixel->total_freq = totfr;
264 *rval =
c &
s->cbits;
272 const int cxshift =
s->cxshift;
279 *cx1 = (*cx << 6) & 0xFC0;
285 *cx1 = (*cx << 6) & 0xFC0;
291 *cx1 = (*cx << 6) & 0xFC0;
301 int cx = 0, cx1 = 0, k = 0;
302 int run, off, y = 0, x = 0, ret;
303 uint32_t clr = 0,
r,
g,
b, backstep = linesize - avctx->
width;
304 uint32_t lx, ly, ptype;
310 while (k < avctx->
width + 1) {
321 clr = (
b << 16) + (
g << 8) +
r;
327 dst[y * linesize + x] = clr;
331 if (x >= avctx->
width) {
349 clr = (
b << 16) + (
g << 8) +
r;
360 dst, linesize, &lx, &ly,
361 backstep, off, &cx, &cx1);
370 uint32_t *dst,
int linesize,
371 uint32_t *prev,
int plinesize)
375 int ret,
temp = 0,
min,
max, x, y, cx = 0, cx1 = 0;
376 int backstep = linesize - avctx->
width;
378 if (bytestream2_get_byte(gb) == 0)
398 memset(
s->blocks, 0,
sizeof(*
s->blocks) *
s->nbcount);
410 while (min < s->nbcount && count-- > 0) {
411 s->blocks[
min++] = fill;
419 for (y = 0; y <
s->nby; y++) {
420 for (x = 0; x <
s->nbx; x++) {
421 int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
423 if (
s->blocks[y *
s->nbx + x] == 0)
426 if (((
s->blocks[y *
s->nbx + x] - 1) & 1) > 0) {
437 if (((
s->blocks[y *
s->nbx + x] - 1) & 2) > 0) {
438 int i, j, by = y * 16, bx = x * 16;
449 if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
450 by + mvy + sy1 >= avctx->
height || bx + mvx + sx1 >= avctx->
width)
453 for (
i = 0;
i < sy2 - sy1 && (by + sy1 +
i) < avctx->
height && (by + mvy + sy1 +
i) < avctx->
height;
i++) {
454 for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->
width && (bx + mvx + sx1 + j) < avctx->
width; j++) {
455 dst[(by +
i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 +
i) * plinesize + bx + sx1 + mvx + j];
459 int run, bx = x * 16 + sx1, by = y * 16 + sy1;
460 uint32_t
r,
g,
b, clr, ptype = 0;
462 for (; by < y * 16 + sy2 && by < avctx->
height;) {
471 clr = (
b << 16) + (
g << 8) +
r;
482 dst, prev, linesize, plinesize, &bx, &by,
483 backstep, sx1, sx2, &cx, &cx1);
512 type = bytestream2_peek_byte(gb);
519 ret =
decompress_i(avctx, (uint32_t *)
s->current_frame->data[0],
520 s->current_frame->linesize[0] / 4);
521 }
else if (
type == 18) {
526 ret =
decompress_i(avctx, (uint32_t *)
s->current_frame->data[0],
527 s->current_frame->linesize[0] / 4);
528 }
else if (
type == 34) {
532 s->current_frame->linesize[0] / 4);
533 }
else if (
type == 17 ||
type == 33) {
534 uint32_t clr, *dst = (uint32_t *)
s->current_frame->data[0];
543 uint16_t
value = bytestream2_get_le16(gb);
549 clr = (
r << 16) + (
g << 8) +
b;
551 clr = bytestream2_get_le24(gb);
553 for (y = 0; y < avctx->
height; y++) {
556 dst +=
s->current_frame->linesize[0] / 4;
558 }
else if (
type == 0 ||
type == 1) {
561 if (
s->version == 1 ||
s->version == 2)
562 ret =
decompress_p(avctx, (uint32_t *)
s->current_frame->data[0],
563 s->current_frame->linesize[0] / 4,
564 (uint32_t *)
s->last_frame->data[0],
565 s->last_frame->linesize[0] / 4);
568 s->current_frame->linesize[0] / 4,
569 (uint32_t *)
s->last_frame->data[0],
570 s->last_frame->linesize[0] / 4);
596 for (y = 0; y < avctx->
height; y++) {
598 if (!(((uintptr_t)dst) & 7)) {
599 uint64_t *dst64 = (uint64_t *)dst;
601 for (x = 0; x <
w; x++) {
602 dst64[x] = (dst64[x] << 3) & 0xFCFCFCFCFCFCFCFCULL;
607 for (; x < avctx->
width * 4; x++) {
608 dst[x] = dst[x] << 3;
644 s->nbx = (avctx->
width + 15) / 16;
645 s->nby = (avctx->
height + 15) / 16;
646 s->nbcount =
s->nbx *
s->nby;
653 if (!
s->last_frame || !
s->current_frame)
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
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 void bytestream2_skip(GetByteContext *g, unsigned int size)
#define FFSWAP(type, a, b)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PICTURE_TYPE_P
Predicted.
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.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
static int decompress_p3(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize)
static int decode_value(SCPRContext *s, uint32_t *cnt, uint32_t maxc, uint32_t step, uint32_t *rval)
static int decode_unit(SCPRContext *s, PixelModel *pixel, uint32_t step, uint32_t *rval)
static void init_rangecoder(RangeCoder *rc, GetByteContext *gb)
static void reinit_tables(SCPRContext *s)
static int decode0(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
static av_cold int decode_close(AVCodecContext *avctx)
static int get_freq(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
static av_cold int decode_init(AVCodecContext *avctx)
static int decompress_i(AVCodecContext *avctx, uint32_t *dst, int linesize)
static int decode(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
static int decompress_p(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static int decode_units(SCPRContext *s, uint32_t *r, uint32_t *g, uint32_t *b, int *cx, int *cx1)
static int get_freq0(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
static int decode_run_i(AVCodecContext *avctx, uint32_t ptype, int run, int *px, int *py, uint32_t clr, uint32_t *dst, int linesize, uint32_t *plx, uint32_t *ply, uint32_t backstep, int off, int *cx, int *cx1)
static int decode_run_p(AVCodecContext *avctx, uint32_t ptype, int run, int x, int y, uint32_t clr, uint32_t *dst, uint32_t *prev, int linesize, int plinesize, uint32_t *bx, uint32_t *by, uint32_t backstep, int sx1, int sx2, int *cx, int *cx1)
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
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.
#define av_malloc_array(a, b)