51 #define VMD_HEADER_SIZE 0x330
52 #define PALETTE_COUNT 256
64 const unsigned char *
buf;
74 #define QUEUE_SIZE 0x1000
75 #define QUEUE_MASK 0x0FFF
77 static void lz_unpack(
const unsigned char *src,
int src_len,
78 unsigned char *dest,
int dest_len)
84 unsigned int dataleft;
85 unsigned int chainofs;
86 unsigned int chainlen;
95 dataleft = bytestream2_get_le32(&gb);
99 if (bytestream2_peek_le32(&gb) == 0x56781234) {
100 bytestream2_get_le32(&gb);
109 tag = bytestream2_get_byteu(&gb);
110 if ((tag == 0xFF) && (dataleft > 8)) {
113 for (i = 0; i < 8; i++) {
114 queue[qpos++] = *d++ = bytestream2_get_byteu(&gb);
119 for (i = 0; i < 8; i++) {
125 queue[qpos++] = *d++ = bytestream2_get_byte(&gb);
129 chainofs = bytestream2_get_byte(&gb);
130 chainofs |= ((bytestream2_peek_byte(&gb) & 0xF0) << 4);
131 chainlen = (bytestream2_get_byte(&gb) & 0x0F) + 3;
132 if (chainlen == speclen) {
133 chainlen = bytestream2_get_byte(&gb) + 0xF + 3;
135 if (d + chainlen > d_end)
137 for (j = 0; j < chainlen; j++) {
139 queue[qpos++] = *d++;
142 dataleft -= chainlen;
150 static int rle_unpack(
const unsigned char *src,
unsigned char *dest,
151 int src_count,
int src_size,
int dest_len)
155 unsigned char *dest_end = dest + dest_len;
163 *pd++ = bytestream2_get_byteu(&gb);
171 l = bytestream2_get_byteu(&gb);
181 for (i = 0; i < l; i++) {
182 *pd++ = bytestream2_get_byteu(&gb);
183 *pd++ = bytestream2_get_byteu(&gb);
188 }
while (i < src_count);
196 unsigned int *palette32;
197 unsigned char r,
g,
b;
207 int frame_x, frame_y;
212 frame_width =
AV_RL16(&s->
buf[10]) - frame_x + 1;
213 frame_height =
AV_RL16(&s->
buf[12]) - frame_y + 1;
214 if (frame_x < 0 || frame_width < 0 ||
219 if (frame_y < 0 || frame_height < 0 ||
226 (frame_x || frame_y)) {
237 (frame_x || frame_y || (frame_width != s->
avctx->
width) ||
246 if (s->
buf[15] & 0x02) {
248 palette32 = (
unsigned int *)s->
palette;
251 r = bytestream2_get_byteu(&gb) * 4;
252 g = bytestream2_get_byteu(&gb) * 4;
253 b = bytestream2_get_byteu(&gb) * 4;
254 palette32[i] = (r << 16) | (g << 8) | (
b);
257 s->
size -= (256 * 3 + 2);
264 meth = bytestream2_get_byteu(&gb);
279 len = bytestream2_get_byte(&gb);
281 len = (len & 0x7F) + 1;
290 memcpy(&dp[ofs], &pp[ofs], len + 1);
293 }
while (ofs < frame_width);
294 if (ofs > frame_width) {
316 len = bytestream2_get_byte(&gb);
318 len = (len & 0x7F) + 1;
319 if (bytestream2_get_byte(&gb) == 0xFF)
330 memcpy(&dp[ofs], &pp[ofs], len + 1);
333 }
while (ofs < frame_width);
334 if (ofs > frame_width) {
350 unsigned int *palette32;
351 int palette_index = 0;
352 unsigned char r,
g,
b;
353 unsigned char *vmd_header;
354 unsigned char *raw_palette;
365 vmd_header = (
unsigned char *)avctx->
extradata;
373 raw_palette = &vmd_header[28];
374 palette32 = (
unsigned int *)s->
palette;
376 r = raw_palette[palette_index++] * 4;
377 g = raw_palette[palette_index++] * 4;
378 b = raw_palette[palette_index++] * 4;
379 palette32[i] = (r << 16) | (g << 8) | (
b);
386 void *
data,
int *data_size,
389 const uint8_t *buf = avpkt->
data;
390 int buf_size = avpkt->
size;
438 #define BLOCK_TYPE_AUDIO 1
439 #define BLOCK_TYPE_INITIAL 2
440 #define BLOCK_TYPE_SILENCE 3
449 0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
450 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
451 0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
452 0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
453 0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
454 0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
455 0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
456 0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
457 0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
458 0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
459 0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
460 0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
461 0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
489 "block align = %d, sample rate = %d\n",
500 const uint8_t *buf_end = buf + buf_size;
502 int st = channels - 1;
505 for (ch = 0; ch < channels; ch++) {
506 predictor[ch] = (int16_t)
AV_RL16(buf);
508 *out++ = predictor[ch];
513 while (buf < buf_end) {
519 predictor[ch] = av_clip_int16(predictor[ch]);
520 *out++ = predictor[ch];
526 int *got_frame_ptr,
AVPacket *avpkt)
528 const uint8_t *buf = avpkt->
data;
529 const uint8_t *buf_end;
530 int buf_size = avpkt->
size;
532 int block_type, silent_chunks, audio_chunks;
534 uint8_t *output_samples_u8;
535 int16_t *output_samples_s16;
560 silent_chunks = av_popcount(flags);
563 }
else if (block_type == BLOCK_TYPE_SILENCE) {
578 output_samples_s16 = (int16_t *)s->
frame.
data[0];
581 if (silent_chunks > 0) {
582 int silent_size = avctx->
block_align * silent_chunks;
584 memset(output_samples_s16, 0x00, silent_size * 2);
585 output_samples_s16 += silent_size;
587 memset(output_samples_u8, 0x80, silent_size);
588 output_samples_u8 += silent_size;
593 if (audio_chunks > 0) {
594 buf_end = buf + buf_size;
601 memcpy(output_samples_u8, buf, s->
chunk_size);
static void vmd_decode(VmdVideoContext *s)
enum PixelFormat pix_fmt
Pixel format, see PIX_FMT_xxx.
struct VmdVideoContext VmdVideoContext
AV_WL32 AV_WL24 AV_WL16 AV_RB32
#define BLOCK_TYPE_SILENCE
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
AVFrame * coded_frame
the picture in the bitstream
#define AV_LOG_WARNING
Something somehow does not look correct.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
enum AVSampleFormat sample_fmt
audio sample format
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
unsigned char * unpack_buffer
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
#define BLOCK_TYPE_INITIAL
unsigned char palette[PALETTE_COUNT *4]
static int init(AVCodecParserContext *s)
static void lz_unpack(const unsigned char *src, int src_len, unsigned char *dest, int dest_len)
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static int vmdvideo_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
#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)
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
const unsigned char * buf
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
static int rle_unpack(const unsigned char *src, unsigned char *dest, int src_count, int src_size, int dest_len)
int width
picture width / height.
struct AVFrame AVFrame
Audio Video Frame.
static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
static av_always_inline int bytestream2_tell(GetByteContext *g)
AVCodec ff_vmdaudio_decoder
static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size, int channels)
int sample_rate
samples per second
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
main external API structure.
static void close(AVCodecParserContext *s)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
AVCodec ff_vmdvideo_decoder
common internal api header.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
8 bit with PIX_FMT_RGB32 palette
int channels
number of audio channels
static const uint16_t vmdaudio_table[128]
void avcodec_get_frame_defaults(AVFrame *pic)
Set the fields of the given AVFrame to default values.
#define FFSWAP(type, a, b)
struct VmdAudioContext VmdAudioContext
int nb_samples
number of audio samples (per channel) described by this frame