00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00042 #include <stdio.h>
00043 #include <stdlib.h>
00044 #include <string.h>
00045
00046 #include "libavutil/channel_layout.h"
00047 #include "libavutil/common.h"
00048 #include "libavutil/intreadwrite.h"
00049 #include "avcodec.h"
00050 #include "internal.h"
00051
00052 #define VMD_HEADER_SIZE 0x330
00053 #define PALETTE_COUNT 256
00054
00055
00056
00057
00058
00059 typedef struct VmdVideoContext {
00060
00061 AVCodecContext *avctx;
00062 AVFrame frame;
00063 AVFrame prev_frame;
00064
00065 const unsigned char *buf;
00066 int size;
00067
00068 unsigned char palette[PALETTE_COUNT * 4];
00069 unsigned char *unpack_buffer;
00070 int unpack_buffer_size;
00071
00072 int x_off, y_off;
00073 } VmdVideoContext;
00074
00075 #define QUEUE_SIZE 0x1000
00076 #define QUEUE_MASK 0x0FFF
00077
00078 static void lz_unpack(const unsigned char *src, int src_len,
00079 unsigned char *dest, int dest_len)
00080 {
00081 const unsigned char *s;
00082 const unsigned char *s_end;
00083 unsigned char *d;
00084 unsigned char *d_end;
00085 unsigned char queue[QUEUE_SIZE];
00086 unsigned int qpos;
00087 unsigned int dataleft;
00088 unsigned int chainofs;
00089 unsigned int chainlen;
00090 unsigned int speclen;
00091 unsigned char tag;
00092 unsigned int i, j;
00093
00094 s = src;
00095 s_end = src + src_len;
00096 d = dest;
00097 d_end = d + dest_len;
00098
00099 if (s_end - s < 8)
00100 return;
00101 dataleft = AV_RL32(s);
00102 s += 4;
00103 memset(queue, 0x20, QUEUE_SIZE);
00104 if (AV_RL32(s) == 0x56781234) {
00105 s += 4;
00106 qpos = 0x111;
00107 speclen = 0xF + 3;
00108 } else {
00109 qpos = 0xFEE;
00110 speclen = 100;
00111 }
00112
00113 while (s_end - s > 0 && dataleft > 0) {
00114 tag = *s++;
00115 if ((tag == 0xFF) && (dataleft > 8)) {
00116 if (d_end - d < 8 || s_end - s < 8)
00117 return;
00118 for (i = 0; i < 8; i++) {
00119 queue[qpos++] = *d++ = *s++;
00120 qpos &= QUEUE_MASK;
00121 }
00122 dataleft -= 8;
00123 } else {
00124 for (i = 0; i < 8; i++) {
00125 if (dataleft == 0)
00126 break;
00127 if (tag & 0x01) {
00128 if (d_end - d < 1 || s_end - s < 1)
00129 return;
00130 queue[qpos++] = *d++ = *s++;
00131 qpos &= QUEUE_MASK;
00132 dataleft--;
00133 } else {
00134 if (s_end - s < 2)
00135 return;
00136 chainofs = *s++;
00137 chainofs |= ((*s & 0xF0) << 4);
00138 chainlen = (*s++ & 0x0F) + 3;
00139 if (chainlen == speclen) {
00140 if (s_end - s < 1)
00141 return;
00142 chainlen = *s++ + 0xF + 3;
00143 }
00144 if (d_end - d < chainlen)
00145 return;
00146 for (j = 0; j < chainlen; j++) {
00147 *d = queue[chainofs++ & QUEUE_MASK];
00148 queue[qpos++] = *d++;
00149 qpos &= QUEUE_MASK;
00150 }
00151 dataleft -= chainlen;
00152 }
00153 tag >>= 1;
00154 }
00155 }
00156 }
00157 }
00158
00159 static int rle_unpack(const unsigned char *src, int src_len, int src_count,
00160 unsigned char *dest, int dest_len)
00161 {
00162 const unsigned char *ps;
00163 const unsigned char *ps_end;
00164 unsigned char *pd;
00165 int i, l;
00166 unsigned char *dest_end = dest + dest_len;
00167
00168 ps = src;
00169 ps_end = src + src_len;
00170 pd = dest;
00171 if (src_count & 1) {
00172 if (ps_end - ps < 1)
00173 return 0;
00174 *pd++ = *ps++;
00175 }
00176
00177 src_count >>= 1;
00178 i = 0;
00179 do {
00180 if (ps_end - ps < 1)
00181 break;
00182 l = *ps++;
00183 if (l & 0x80) {
00184 l = (l & 0x7F) * 2;
00185 if (dest_end - pd < l || ps_end - ps < l)
00186 return ps - src;
00187 memcpy(pd, ps, l);
00188 ps += l;
00189 pd += l;
00190 } else {
00191 if (dest_end - pd < i || ps_end - ps < 2)
00192 return ps - src;
00193 for (i = 0; i < l; i++) {
00194 *pd++ = ps[0];
00195 *pd++ = ps[1];
00196 }
00197 ps += 2;
00198 }
00199 i += l;
00200 } while (i < src_count);
00201
00202 return ps - src;
00203 }
00204
00205 static void vmd_decode(VmdVideoContext *s)
00206 {
00207 int i;
00208 unsigned int *palette32;
00209 unsigned char r, g, b;
00210
00211
00212 const unsigned char *p = s->buf + 16;
00213 const unsigned char *p_end = s->buf + s->size;
00214
00215 const unsigned char *pb;
00216 const unsigned char *pb_end;
00217 unsigned char meth;
00218 unsigned char *dp;
00219 unsigned char *pp;
00220 unsigned char len;
00221 int ofs;
00222
00223 int frame_x, frame_y;
00224 int frame_width, frame_height;
00225
00226 frame_x = AV_RL16(&s->buf[6]);
00227 frame_y = AV_RL16(&s->buf[8]);
00228 frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;
00229 frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;
00230 if (frame_x < 0 || frame_width < 0 ||
00231 frame_x >= s->avctx->width ||
00232 frame_width > s->avctx->width ||
00233 frame_x + frame_width > s->avctx->width)
00234 return;
00235 if (frame_y < 0 || frame_height < 0 ||
00236 frame_y >= s->avctx->height ||
00237 frame_height > s->avctx->height ||
00238 frame_y + frame_height > s->avctx->height)
00239 return;
00240
00241 if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&
00242 (frame_x || frame_y)) {
00243
00244 s->x_off = frame_x;
00245 s->y_off = frame_y;
00246 }
00247 frame_x -= s->x_off;
00248 frame_y -= s->y_off;
00249
00250
00251
00252 if (s->prev_frame.data[0] &&
00253 (frame_x || frame_y || (frame_width != s->avctx->width) ||
00254 (frame_height != s->avctx->height))) {
00255
00256 memcpy(s->frame.data[0], s->prev_frame.data[0],
00257 s->avctx->height * s->frame.linesize[0]);
00258 }
00259
00260
00261 if (s->buf[15] & 0x02) {
00262 if (p_end - p < 2 + 3 * PALETTE_COUNT)
00263 return;
00264 p += 2;
00265 palette32 = (unsigned int *)s->palette;
00266 for (i = 0; i < PALETTE_COUNT; i++) {
00267 r = *p++ * 4;
00268 g = *p++ * 4;
00269 b = *p++ * 4;
00270 palette32[i] = 0xFFU << 24 | r << 16 | g << 8 | b;
00271 palette32[i] |= palette32[i] >> 6 & 0x30303;
00272 }
00273 }
00274 if (p < p_end) {
00275
00276 pb = p;
00277 pb_end = p_end;
00278 meth = *pb++;
00279 if (meth & 0x80) {
00280 lz_unpack(pb, p_end - pb, s->unpack_buffer, s->unpack_buffer_size);
00281 meth &= 0x7F;
00282 pb = s->unpack_buffer;
00283 pb_end = s->unpack_buffer + s->unpack_buffer_size;
00284 }
00285
00286 dp = &s->frame.data[0][frame_y * s->frame.linesize[0] + frame_x];
00287 pp = &s->prev_frame.data[0][frame_y * s->prev_frame.linesize[0] + frame_x];
00288 switch (meth) {
00289 case 1:
00290 for (i = 0; i < frame_height; i++) {
00291 ofs = 0;
00292 do {
00293 if (pb_end - pb < 1)
00294 return;
00295 len = *pb++;
00296 if (len & 0x80) {
00297 len = (len & 0x7F) + 1;
00298 if (ofs + len > frame_width || pb_end - pb < len)
00299 return;
00300 memcpy(&dp[ofs], pb, len);
00301 pb += len;
00302 ofs += len;
00303 } else {
00304
00305 if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
00306 return;
00307 memcpy(&dp[ofs], &pp[ofs], len + 1);
00308 ofs += len + 1;
00309 }
00310 } while (ofs < frame_width);
00311 if (ofs > frame_width) {
00312 av_log(s->avctx, AV_LOG_ERROR, "offset > width (%d > %d)\n",
00313 ofs, frame_width);
00314 break;
00315 }
00316 dp += s->frame.linesize[0];
00317 pp += s->prev_frame.linesize[0];
00318 }
00319 break;
00320
00321 case 2:
00322 for (i = 0; i < frame_height; i++) {
00323 if (pb_end -pb < frame_width)
00324 return;
00325 memcpy(dp, pb, frame_width);
00326 pb += frame_width;
00327 dp += s->frame.linesize[0];
00328 pp += s->prev_frame.linesize[0];
00329 }
00330 break;
00331
00332 case 3:
00333 for (i = 0; i < frame_height; i++) {
00334 ofs = 0;
00335 do {
00336 if (pb_end - pb < 1)
00337 return;
00338 len = *pb++;
00339 if (len & 0x80) {
00340 len = (len & 0x7F) + 1;
00341 if (pb_end - pb < 1)
00342 return;
00343 if (*pb++ == 0xFF)
00344 len = rle_unpack(pb, pb_end - pb, len, &dp[ofs], frame_width - ofs);
00345 else {
00346 if (pb_end - pb < len)
00347 return;
00348 memcpy(&dp[ofs], pb, len);
00349 }
00350 pb += len;
00351 ofs += len;
00352 } else {
00353
00354 if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
00355 return;
00356 memcpy(&dp[ofs], &pp[ofs], len + 1);
00357 ofs += len + 1;
00358 }
00359 } while (ofs < frame_width);
00360 if (ofs > frame_width) {
00361 av_log(s->avctx, AV_LOG_ERROR, "offset > width (%d > %d)\n",
00362 ofs, frame_width);
00363 }
00364 dp += s->frame.linesize[0];
00365 pp += s->prev_frame.linesize[0];
00366 }
00367 break;
00368 }
00369 }
00370 }
00371
00372 static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
00373 {
00374 VmdVideoContext *s = avctx->priv_data;
00375 int i;
00376 unsigned int *palette32;
00377 int palette_index = 0;
00378 unsigned char r, g, b;
00379 unsigned char *vmd_header;
00380 unsigned char *raw_palette;
00381
00382 s->avctx = avctx;
00383 avctx->pix_fmt = AV_PIX_FMT_PAL8;
00384
00385
00386 if (s->avctx->extradata_size != VMD_HEADER_SIZE) {
00387 av_log(s->avctx, AV_LOG_ERROR, "expected extradata size of %d\n",
00388 VMD_HEADER_SIZE);
00389 return -1;
00390 }
00391 vmd_header = (unsigned char *)avctx->extradata;
00392
00393 s->unpack_buffer_size = AV_RL32(&vmd_header[800]);
00394 s->unpack_buffer = av_malloc(s->unpack_buffer_size);
00395 if (!s->unpack_buffer)
00396 return -1;
00397
00398
00399 raw_palette = &vmd_header[28];
00400 palette32 = (unsigned int *)s->palette;
00401 for (i = 0; i < PALETTE_COUNT; i++) {
00402 r = raw_palette[palette_index++] * 4;
00403 g = raw_palette[palette_index++] * 4;
00404 b = raw_palette[palette_index++] * 4;
00405 palette32[i] = (r << 16) | (g << 8) | (b);
00406 }
00407
00408 avcodec_get_frame_defaults(&s->frame);
00409 avcodec_get_frame_defaults(&s->prev_frame);
00410
00411 return 0;
00412 }
00413
00414 static int vmdvideo_decode_frame(AVCodecContext *avctx,
00415 void *data, int *got_frame,
00416 AVPacket *avpkt)
00417 {
00418 const uint8_t *buf = avpkt->data;
00419 int buf_size = avpkt->size;
00420 VmdVideoContext *s = avctx->priv_data;
00421
00422 s->buf = buf;
00423 s->size = buf_size;
00424
00425 if (buf_size < 16)
00426 return buf_size;
00427
00428 s->frame.reference = 3;
00429 if (ff_get_buffer(avctx, &s->frame)) {
00430 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00431 return -1;
00432 }
00433
00434 vmd_decode(s);
00435
00436
00437 memcpy(s->frame.data[1], s->palette, PALETTE_COUNT * 4);
00438
00439
00440 FFSWAP(AVFrame, s->frame, s->prev_frame);
00441 if (s->frame.data[0])
00442 avctx->release_buffer(avctx, &s->frame);
00443
00444 *got_frame = 1;
00445 *(AVFrame*)data = s->prev_frame;
00446
00447
00448 return buf_size;
00449 }
00450
00451 static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
00452 {
00453 VmdVideoContext *s = avctx->priv_data;
00454
00455 if (s->prev_frame.data[0])
00456 avctx->release_buffer(avctx, &s->prev_frame);
00457 av_free(s->unpack_buffer);
00458
00459 return 0;
00460 }
00461
00462
00463
00464
00465
00466
00467 #define BLOCK_TYPE_AUDIO 1
00468 #define BLOCK_TYPE_INITIAL 2
00469 #define BLOCK_TYPE_SILENCE 3
00470
00471 typedef struct VmdAudioContext {
00472 AVFrame frame;
00473 int out_bps;
00474 int chunk_size;
00475 } VmdAudioContext;
00476
00477 static const uint16_t vmdaudio_table[128] = {
00478 0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
00479 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
00480 0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
00481 0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
00482 0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
00483 0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
00484 0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
00485 0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
00486 0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
00487 0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
00488 0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
00489 0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
00490 0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
00491 };
00492
00493 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
00494 {
00495 VmdAudioContext *s = avctx->priv_data;
00496
00497 if (avctx->channels < 1 || avctx->channels > 2) {
00498 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
00499 return AVERROR(EINVAL);
00500 }
00501 if (avctx->block_align < 1 || avctx->block_align % avctx->channels) {
00502 av_log(avctx, AV_LOG_ERROR, "invalid block align\n");
00503 return AVERROR(EINVAL);
00504 }
00505
00506 avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
00507 AV_CH_LAYOUT_STEREO;
00508
00509 if (avctx->bits_per_coded_sample == 16)
00510 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00511 else
00512 avctx->sample_fmt = AV_SAMPLE_FMT_U8;
00513 s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
00514
00515 s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
00516
00517 avcodec_get_frame_defaults(&s->frame);
00518 avctx->coded_frame = &s->frame;
00519
00520 av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
00521 "block align = %d, sample rate = %d\n",
00522 avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
00523 avctx->sample_rate);
00524
00525 return 0;
00526 }
00527
00528 static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size,
00529 int channels)
00530 {
00531 int ch;
00532 const uint8_t *buf_end = buf + buf_size;
00533 int predictor[2];
00534 int st = channels - 1;
00535
00536
00537 for (ch = 0; ch < channels; ch++) {
00538 predictor[ch] = (int16_t)AV_RL16(buf);
00539 buf += 2;
00540 *out++ = predictor[ch];
00541 }
00542
00543
00544 ch = 0;
00545 while (buf < buf_end) {
00546 uint8_t b = *buf++;
00547 if (b & 0x80)
00548 predictor[ch] -= vmdaudio_table[b & 0x7F];
00549 else
00550 predictor[ch] += vmdaudio_table[b];
00551 predictor[ch] = av_clip_int16(predictor[ch]);
00552 *out++ = predictor[ch];
00553 ch ^= st;
00554 }
00555 }
00556
00557 static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
00558 int *got_frame_ptr, AVPacket *avpkt)
00559 {
00560 const uint8_t *buf = avpkt->data;
00561 const uint8_t *buf_end;
00562 int buf_size = avpkt->size;
00563 VmdAudioContext *s = avctx->priv_data;
00564 int block_type, silent_chunks, audio_chunks;
00565 int ret;
00566 uint8_t *output_samples_u8;
00567 int16_t *output_samples_s16;
00568
00569 if (buf_size < 16) {
00570 av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
00571 *got_frame_ptr = 0;
00572 return buf_size;
00573 }
00574
00575 block_type = buf[6];
00576 if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
00577 av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
00578 return AVERROR(EINVAL);
00579 }
00580 buf += 16;
00581 buf_size -= 16;
00582
00583
00584 silent_chunks = 0;
00585 if (block_type == BLOCK_TYPE_INITIAL) {
00586 uint32_t flags;
00587 if (buf_size < 4) {
00588 av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
00589 return AVERROR(EINVAL);
00590 }
00591 flags = AV_RB32(buf);
00592 silent_chunks = av_popcount(flags);
00593 buf += 4;
00594 buf_size -= 4;
00595 } else if (block_type == BLOCK_TYPE_SILENCE) {
00596 silent_chunks = 1;
00597 buf_size = 0;
00598 }
00599
00600
00601 audio_chunks = buf_size / s->chunk_size;
00602
00603
00604 s->frame.nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) / avctx->channels;
00605 if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
00606 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00607 return ret;
00608 }
00609 output_samples_u8 = s->frame.data[0];
00610 output_samples_s16 = (int16_t *)s->frame.data[0];
00611
00612
00613 if (silent_chunks > 0) {
00614 int silent_size = avctx->block_align * silent_chunks;
00615 if (s->out_bps == 2) {
00616 memset(output_samples_s16, 0x00, silent_size * 2);
00617 output_samples_s16 += silent_size;
00618 } else {
00619 memset(output_samples_u8, 0x80, silent_size);
00620 output_samples_u8 += silent_size;
00621 }
00622 }
00623
00624
00625 if (audio_chunks > 0) {
00626 buf_end = buf + buf_size;
00627 while ( buf_end - buf >= s->chunk_size) {
00628 if (s->out_bps == 2) {
00629 decode_audio_s16(output_samples_s16, buf, s->chunk_size,
00630 avctx->channels);
00631 output_samples_s16 += avctx->block_align;
00632 } else {
00633 memcpy(output_samples_u8, buf, s->chunk_size);
00634 output_samples_u8 += avctx->block_align;
00635 }
00636 buf += s->chunk_size;
00637 }
00638 }
00639
00640 *got_frame_ptr = 1;
00641 *(AVFrame *)data = s->frame;
00642
00643 return avpkt->size;
00644 }
00645
00646
00647
00648
00649
00650
00651 AVCodec ff_vmdvideo_decoder = {
00652 .name = "vmdvideo",
00653 .type = AVMEDIA_TYPE_VIDEO,
00654 .id = AV_CODEC_ID_VMDVIDEO,
00655 .priv_data_size = sizeof(VmdVideoContext),
00656 .init = vmdvideo_decode_init,
00657 .close = vmdvideo_decode_end,
00658 .decode = vmdvideo_decode_frame,
00659 .capabilities = CODEC_CAP_DR1,
00660 .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
00661 };
00662
00663 AVCodec ff_vmdaudio_decoder = {
00664 .name = "vmdaudio",
00665 .type = AVMEDIA_TYPE_AUDIO,
00666 .id = AV_CODEC_ID_VMDAUDIO,
00667 .priv_data_size = sizeof(VmdAudioContext),
00668 .init = vmdaudio_decode_init,
00669 .decode = vmdaudio_decode_frame,
00670 .capabilities = CODEC_CAP_DR1,
00671 .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),
00672 };