52 start = bytestream2_get_le16(gb);
53 count = bytestream2_get_le16(gb);
55 if (start + count > 256)
61 for (
int i = 0;
i < count;
i++)
62 pal[start +
i] = (0xFF << 24U) | bytestream2_get_be24u(gb);
81 int index = bytestream2_get_byteu(gb);
87 dst[x+l+1] =
block[3];
120 codes = bytestream2_get_byteu(&sb);
125 index = bytestream2_get_byte(gb);
131 dst[x+l+1] =
block[3];
156 type = bytestream2_get_byte(gb);
163 for (
int y = 0; y <
h; y += 8) {
164 for (
int x = 0; x <
w; x += 8) {
165 int fill = bytestream2_get_byte(gb);
168 for (
int by = 0; by < 8; by++) {
169 memset(ddst, fill, 8);
179 int bsize = bytestream2_get_byte(gb);
186 count = bytestream2_get_be16(gb);
188 int mvx, mvy,
a,
b,
c, mx, my;
189 int bsize_w, bsize_h;
191 bsize_w = bsize_h = bsize;
194 mvx = bytestream2_get_byte(gb) * bsize;
195 mvy = bytestream2_get_byte(gb) * bsize;
196 a = bytestream2_get_byte(gb);
197 b = bytestream2_get_byte(gb);
198 c = ((
a & 0x3F) << 8) +
b;
199 mx = mvx + (
c & 0x7F) - 64;
200 my = mvy + (
c >> 7) - 64;
202 if (mvy < 0 || mvy >=
h)
205 if (mvx < 0 || mvx >=
w)
208 if (my < 0 || my >=
h)
211 if (mx < 0 || mx >=
w)
217 bsize_w =
FFMIN3(bsize_w,
w - mvx,
w - mx);
218 bsize_h =
FFMIN3(bsize_h,
h - mvy,
h - my);
220 if (mvy >= my && (mvy != my || mvx >= mx)) {
221 src += (bsize_h - 1) * l;
222 dst += (bsize_h - 1) * l;
223 for (
int by = 0; by < bsize_h; by++) {
224 memmove(dst,
src, bsize_w);
229 for (
int by = 0; by < bsize_h; by++) {
230 memmove(dst,
src, bsize_w);
244 for (
int y = 0; y <
h; y++) {
251 for (
int y = 0; y <
h; y += 2) {
252 for (
int x = 0; x <
w; x += 2) {
253 int fill = bytestream2_get_byte(gb);
256 fill = (fill << 8) | fill;
257 for (
int by = 0; by < 2; by++) {
268 size = bytestream2_get_le16(gb);
270 int x = bytestream2_get_byte(gb) * 4;
271 int y = bytestream2_get_byte(gb) * 4;
272 int count = bytestream2_get_byte(gb);
273 int fill = bytestream2_get_byte(gb);
276 for (
int i = 0;
i < count;
i++)
286 int count = bytestream2_get_byteu(gb);
287 int skip = count & 0x3F;
309 int bits = bytestream2_get_byte(gb);
311 for (
int i = 0;
i < 4;
i++) {
319 dst[
pos] =
pos ? dst[
pos - 1] : dst[-l +
w - 1];
327 dst[
pos] = bytestream2_get_byte(gb);
367 type = bytestream2_get_byte(gb);
374 for (
int y = 0; y + 12 <=
h; y += 12) {
375 for (
int x = 0; x + 12 <=
w; x += 12) {
376 int fill = bytestream2_get_be24(gb);
377 uint32_t *dstp = dst + x;
379 for (
int by = 0; by < 12; by++) {
380 for (
int bx = 0; bx < 12; bx++)
392 int bsize = bytestream2_get_byte(gb);
399 count = bytestream2_get_be16(gb);
401 int mvx, mvy,
a,
b,
c, mx, my;
402 int bsize_w, bsize_h;
404 bsize_w = bsize_h = bsize;
407 mvx = bytestream2_get_byte(gb) * bsize;
408 mvy = bytestream2_get_byte(gb) * bsize;
409 a = bytestream2_get_byte(gb);
410 b = bytestream2_get_byte(gb);
411 c = ((
a & 0x3F) << 8) +
b;
412 mx = mvx + (
c & 0x7F) - 64;
413 my = mvy + (
c >> 7) - 64;
415 if (mvy < 0 || mvy >=
h)
418 if (mvx < 0 || mvx >=
w)
421 if (my < 0 || my >=
h)
424 if (mx < 0 || mx >=
w)
427 dst = (uint32_t *)
frame->
data[0] + mvx + l * mvy;
430 bsize_w =
FFMIN3(bsize_w,
w - mvx,
w - mx);
431 bsize_h =
FFMIN3(bsize_h,
h - mvy,
h - my);
433 if (mvy >= my && (mvy != my || mvx >= mx)) {
434 src += (bsize_h - 1) * l;
435 dst += (bsize_h - 1) * l;
436 for (
int by = 0; by < bsize_h; by++) {
437 memmove(dst,
src, bsize_w * 4);
442 for (
int by = 0; by < bsize_h; by++) {
443 memmove(dst,
src, bsize_w * 4);
454 osize = ((
h + 3) / 4) * ((
w + 3) / 4) + 7;
461 for (
int x = 0; x <
w; x += 4) {
462 for (
int y = 0; y <
h; y += 4) {
465 if (
bits[di >> 3] & (1 << (di & 7))) {
466 int codes = bytestream2_get_byte(gb);
468 for (
int count = 0; count < 4; count++) {
470 size_t src_size = l * (
h - 1) + (
w - 1);
471 int nv, v,
code = codes & 3;
477 bcode = bytestream2_get_byte(gb);
479 for (
int j = 0; j < 4; j++) {
497 value = bytestream2_get_byte(gb);
502 s->mv1[nv][0], 0, src_size)];
515 for (
int j = 0; j < 4; j++) {
530 v = bytestream2_get_byte(gb);
533 s->mv0[v][0], 0, src_size)];
535 dst[0] = ((v & 0x7F) << 17) | bytestream2_get_be16(gb);
573 int count = bytestream2_get_byte(gb);
574 int pixel = bytestream2_get_byte(gb);
616 chunk = bytestream2_get_be32(gb);
618 case MKBETAG(
'P',
'A',
'L',
'8'):
624 case MKBETAG(
'M',
'A',
'D',
'1'):
630 case MKBETAG(
'A',
'V',
'C',
'F'):
636 case MKBETAG(
'A',
'L',
'C',
'D'):
642 case MKBETAG(
'R',
'L',
'E',
'F'):
648 case MKBETAG(
'R',
'L',
'E',
'D'):
692 for (
int n = 0,
i = -4;
i < 4;
i++) {
693 for (
int j = -14; j < 2; j++) {
699 for (
int n = 0,
i = -5;
i <= 1;
i += 2) {
static void flush(AVCodecContext *avctx)
static int decode_rle(AVCodecContext *avctx, AVFrame *frame)
static av_cold int decode_close(AVCodecContext *avctx)
static int decode_mad1_24(AVCodecContext *avctx, AVFrame *frame)
static av_cold int decode_init(AVCodecContext *avctx)
static int decode_avcf(AVCodecContext *avctx, AVFrame *frame)
static int decode_pal8(AVCodecContext *avctx, uint32_t *pal)
static int decode_alcd(AVCodecContext *avctx, AVFrame *frame)
static void decode_flush(AVCodecContext *avctx)
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static int decode_mad1(AVCodecContext *avctx, AVFrame *frame)
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
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 MKBETAG(a, b, c, d)
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 decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
#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.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
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.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PICTURE_TYPE_P
Predicted.
const VDPAUPixFmtMap * map
#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.
Memory handling functions.
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
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 avpriv_request_sample(...)