53 #define VMD_HEADER_SIZE 0x330
54 #define PALETTE_COUNT 256
66 const unsigned char *
buf;
76 #define QUEUE_SIZE 0x1000
77 #define QUEUE_MASK 0x0FFF
79 static void lz_unpack(
const unsigned char *src,
int src_len,
80 unsigned char *dest,
int dest_len)
86 unsigned int dataleft;
87 unsigned int chainofs;
88 unsigned int chainlen;
97 dataleft = bytestream2_get_le32(&gb);
101 if (bytestream2_peek_le32(&gb) == 0x56781234) {
102 bytestream2_get_le32(&gb);
111 tag = bytestream2_get_byteu(&gb);
112 if ((tag == 0xFF) && (dataleft > 8)) {
115 for (i = 0; i < 8; i++) {
116 queue[qpos++] = *d++ = bytestream2_get_byteu(&gb);
121 for (i = 0; i < 8; i++) {
127 queue[qpos++] = *d++ = bytestream2_get_byte(&gb);
131 chainofs = bytestream2_get_byte(&gb);
132 chainofs |= ((bytestream2_peek_byte(&gb) & 0xF0) << 4);
133 chainlen = (bytestream2_get_byte(&gb) & 0x0F) + 3;
134 if (chainlen == speclen) {
135 chainlen = bytestream2_get_byte(&gb) + 0xF + 3;
137 if (d + chainlen > d_end)
139 for (j = 0; j < chainlen; j++) {
141 queue[qpos++] = *d++;
144 dataleft -= chainlen;
152 static int rle_unpack(
const unsigned char *src,
unsigned char *dest,
153 int src_count,
int src_size,
int dest_len)
157 unsigned char *dest_end = dest + dest_len;
165 *pd++ = bytestream2_get_byteu(&gb);
173 l = bytestream2_get_byteu(&gb);
183 for (i = 0; i < l; i++) {
184 *pd++ = bytestream2_get_byteu(&gb);
185 *pd++ = bytestream2_get_byteu(&gb);
190 }
while (i < src_count);
198 unsigned int *palette32;
199 unsigned char r,
g,
b;
209 int frame_x, frame_y;
210 int frame_width, frame_height;
214 frame_width =
AV_RL16(&s->
buf[10]) - frame_x + 1;
215 frame_height =
AV_RL16(&s->
buf[12]) - frame_y + 1;
216 if (frame_x < 0 || frame_width < 0 ||
221 "Invalid horizontal range %d-%d\n",
222 frame_x, frame_width);
225 if (frame_y < 0 || frame_height < 0 ||
230 "Invalid vertical range %d-%d\n",
231 frame_x, frame_width);
236 (frame_x || frame_y)) {
247 (frame_x || frame_y || (frame_width != s->
avctx->
width) ||
256 if (s->
buf[15] & 0x02) {
258 palette32 = (
unsigned int *)s->
palette;
261 r = bytestream2_get_byteu(&gb) * 4;
262 g = bytestream2_get_byteu(&gb) * 4;
263 b = bytestream2_get_byteu(&gb) * 4;
264 palette32[i] = (r << 16) | (g << 8) | (
b);
279 meth = bytestream2_get_byteu(&gb);
291 for (i = 0; i < frame_height; i++) {
294 len = bytestream2_get_byte(&gb);
296 len = (len & 0x7F) + 1;
297 if (ofs + len > frame_width ||
306 memcpy(&dp[ofs], &pp[ofs], len + 1);
309 }
while (ofs < frame_width);
310 if (ofs > frame_width) {
312 "VMD video: offset > width (%d > %d)\n",
322 for (i = 0; i < frame_height; i++) {
330 for (i = 0; i < frame_height; i++) {
333 len = bytestream2_get_byte(&gb);
335 len = (len & 0x7F) + 1;
336 if (bytestream2_get_byte(&gb) == 0xFF)
347 memcpy(&dp[ofs], &pp[ofs], len + 1);
350 }
while (ofs < frame_width);
351 if (ofs > frame_width) {
353 "VMD video: offset > width (%d > %d)\n",
369 unsigned int *palette32;
370 int palette_index = 0;
371 unsigned char r,
g,
b;
372 unsigned char *vmd_header;
373 unsigned char *raw_palette;
384 vmd_header = (
unsigned char *)avctx->
extradata;
392 raw_palette = &vmd_header[28];
393 palette32 = (
unsigned int *)s->
palette;
395 r = raw_palette[palette_index++] * 4;
396 g = raw_palette[palette_index++] * 4;
397 b = raw_palette[palette_index++] * 4;
398 palette32[i] = (r << 16) | (g << 8) | (
b);
405 void *
data,
int *got_frame,
409 int buf_size = avpkt->
size;
457 #define BLOCK_TYPE_AUDIO 1
458 #define BLOCK_TYPE_INITIAL 2
459 #define BLOCK_TYPE_SILENCE 3
468 0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
469 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
470 0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
471 0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
472 0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
473 0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
474 0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
475 0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
476 0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
477 0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
478 0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
479 0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
480 0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
511 "block align = %d, sample rate = %d\n",
522 const uint8_t *buf_end = buf + buf_size;
524 int st = channels - 1;
527 for (ch = 0; ch < channels; ch++) {
528 predictor[ch] = (int16_t)
AV_RL16(buf);
530 *out++ = predictor[ch];
535 while (buf < buf_end) {
541 predictor[ch] = av_clip_int16(predictor[ch]);
542 *out++ = predictor[ch];
548 int *got_frame_ptr,
AVPacket *avpkt)
552 int buf_size = avpkt->
size;
554 int block_type, silent_chunks, audio_chunks;
557 int16_t *output_samples_s16;
582 silent_chunks = av_popcount(flags);
585 }
else if (block_type == BLOCK_TYPE_SILENCE) {
603 output_samples_s16 = (int16_t *)s->
frame.
data[0];
606 if (silent_chunks > 0) {
610 memset(output_samples_s16, 0x00, silent_size * 2);
611 output_samples_s16 += silent_size;
613 memset(output_samples_u8, 0x80, silent_size);
614 output_samples_u8 += silent_size;
619 if (audio_chunks > 0) {
620 buf_end = buf + (buf_size & ~(avctx->
channels > 1));
627 memcpy(output_samples_u8, buf, s->
chunk_size);
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
This structure describes decoded (raw) audio or video data.
struct VmdVideoContext VmdVideoContext
#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
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)
#define AV_CH_LAYOUT_STEREO
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)
#define FFSWAP(type, a, b)
enum AVSampleFormat sample_fmt
audio sample format
8 bit with PIX_FMT_RGB32 palette
static int vmdvideo_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
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)
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)
uint64_t channel_layout
Audio channel layout.
audio channel layout utility functions
int width
picture width / height.
static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a 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.
static int vmd_decode(VmdVideoContext *s)
main external API structure.
static void close(AVCodecParserContext *s)
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
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.
common internal and external API header
static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
#define AVERROR_INVALIDDATA
int channels
number of audio channels
static const uint16_t vmdaudio_table[128]
#define AV_CH_LAYOUT_MONO
struct VmdAudioContext VmdAudioContext
This structure stores compressed data.
int nb_samples
number of audio samples (per channel) described by this frame
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)