falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3075 Commits
32 Branches
2.1GB
Tree: aab34ca0c5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'aab34ca0c5'
${ noResults }
FFmpeg/libavcodec/vmdav.c

552 lines
15KB
Raw Blame History 

  1. /*

  2.  * Sierra VMD Audio & Video Decoders

  3.  * Copyright (C) 2004 the ffmpeg project

  4.  *

  5.  * This library is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU Lesser General Public

  7.  * License as published by the Free Software Foundation; either

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  13.  * Lesser General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU Lesser General Public

  16.  * License along with this library; if not, write to the Free Software

  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  18.  *

  19.  */

  20. 

  21. /**

  22.  * @file vmdvideo.c

  23.  * Sierra VMD audio & video decoders

  24.  * by Vladimir "VAG" Gneushev (vagsoft at mail.ru)

  25.  *

  26.  * The video decoder outputs PAL8 colorspace data. The decoder expects

  27.  * a 0x330-byte VMD file header to be transmitted via extradata during

  28.  * codec initialization. Each encoded frame that is sent to this decoder

  29.  * is expected to be prepended with the appropriate 16-byte frame 

  30.  * information record from the VMD file.

  31.  *

  32.  * The audio decoder, like the video decoder, expects each encoded data

  33.  * chunk to be prepended with the approriate 16-byte frame information

  34.  * record from the VMD file. It does not require the 0x330-byte VMD file

  35.  * header, but it does need the audio setup parameters passed in through

  36.  * normal libavcodec API means.

  37.  */

  38. 

  39. #include <stdio.h>

  40. #include <stdlib.h>

  41. #include <string.h>

  42. #include <unistd.h>

  43. 

  44. #include "common.h"

  45. #include "avcodec.h"

  46. #include "dsputil.h"

  47. 

  48. #define printf(...) {} //(f)printf() usage is forbidden in libavcodec, use av_log

  49. #define fprintf(...) {} 

  50. 

  51. #define VMD_HEADER_SIZE 0x330

  52. #define PALETTE_COUNT 256

  53. 

  54. #define LE_16(x)  ((((uint8_t*)(x))[1] << 8) | ((uint8_t*)(x))[0])

  55. #define LE_32(x)  ((((uint8_t*)(x))[3] << 24) | \

  56.                    (((uint8_t*)(x))[2] << 16) | \

  57.                    (((uint8_t*)(x))[1] << 8) | \

  58.                     ((uint8_t*)(x))[0])

  59. 

  60. /*

  61.  * Video Decoder

  62.  */

  63. 

  64. typedef struct VmdVideoContext {

  65. 

  66.     AVCodecContext *avctx;

  67.     DSPContext dsp;

  68.     AVFrame frame;

  69.     AVFrame prev_frame;

  70. 

  71.     unsigned char *buf;

  72.     int size;

  73. 

  74.     unsigned char palette[PALETTE_COUNT * 4];

  75.     unsigned char *unpack_buffer;

  76. 

  77. } VmdVideoContext;

  78. 

  79. #define QUEUE_SIZE 0x1000

  80. #define QUEUE_MASK 0x0FFF

  81. 

  82. static void lz_unpack(unsigned char *src, unsigned char *dest)

  83. {

  84.     unsigned char *s;

  85.     unsigned char *d;

  86.     unsigned char queue[QUEUE_SIZE];

  87.     unsigned int qpos;

  88.     unsigned int dataleft;

  89.     unsigned int chainofs;

  90.     unsigned int chainlen;

  91.     unsigned int speclen;

  92.     unsigned char tag;

  93.     unsigned int i, j;

  94. 

  95.     s = src;

  96.     d = dest;

  97.     dataleft = LE_32(s);

  98.     s += 4;

  99.     memset(queue, QUEUE_SIZE, 0x20);

  100.     if (LE_32(s) == 0x56781234) {

  101.         s += 4;

  102.         qpos = 0x111;

  103.         speclen = 0xF + 3;

  104.     } else {

  105.         qpos = 0xFEE;

  106.         speclen = 100;  /* no speclen */

  107.     }

  108. 

  109.     while (dataleft > 0) {

  110.         tag = *s++;

  111.         if ((tag == 0xFF) && (dataleft > 8)) {

  112.             for (i = 0; i < 8; i++) {

  113.                 queue[qpos++] = *d++ = *s++;

  114.                 qpos &= QUEUE_MASK;

  115.             }

  116.             dataleft -= 8;

  117.         } else {

  118.             for (i = 0; i < 8; i++) {

  119.                 if (dataleft == 0)

  120.                     break;

  121.                 if (tag & 0x01) {

  122.                     queue[qpos++] = *d++ = *s++;

  123.                     qpos &= QUEUE_MASK;

  124.                     dataleft--;

  125.                 } else {

  126.                     chainofs = *s++;

  127.                     chainofs |= ((*s & 0xF0) << 4);

  128.                     chainlen = (*s++ & 0x0F) + 3;

  129.                     if (chainlen == speclen)

  130.                         chainlen = *s++ + 0xF + 3;

  131.                     for (j = 0; j < chainlen; j++) {

  132.                         *d = queue[chainofs++ & QUEUE_MASK];

  133.                         queue[qpos++] = *d++;

  134.                         qpos &= QUEUE_MASK;

  135.                     }

  136.                     dataleft -= chainlen;

  137.                 }

  138.                 tag >>= 1;

  139.             }

  140.         }

  141.     }

  142. }

  143. 

  144. static int rle_unpack(unsigned char *src, unsigned char *dest, int len)

  145. {

  146.     unsigned char *ps;

  147.     unsigned char *pd;

  148.     int i, l;

  149. 

  150.     ps = src;

  151.     pd = dest;

  152.     if (len & 1)

  153.         *pd++ = *ps++;

  154. 

  155.     len >>= 1;

  156.     i = 0;

  157.     do {

  158.         l = *ps++;

  159.         if (l & 0x80) {

  160.             l = (l & 0x7F) * 2;

  161.             memcpy(pd, ps, l);

  162.             ps += l;

  163.             pd += l;

  164.         } else {

  165.             for (i = 0; i < l; i++) {

  166.                 *pd++ = ps[0];

  167.                 *pd++ = ps[1];

  168.             }

  169.             ps += 2;

  170.         }

  171.         i += l;

  172.     } while (i < len);

  173. 

  174.     return (ps - src);

  175. }

  176. 

  177. static void vmd_decode(VmdVideoContext *s)

  178. {

  179.     int i;

  180.     unsigned int *palette32;

  181.     unsigned char r, g, b;

  182. 

  183.     /* point to the start of the encoded data */

  184.     unsigned char *p = s->buf + 16;

  185. 

  186.     unsigned char *pb;

  187.     unsigned char meth;

  188.     unsigned char *dp;   /* pointer to current frame */

  189.     unsigned char *pp;   /* pointer to previous frame */

  190.     unsigned char len;

  191.     int ofs;

  192. 

  193.     int frame_x, frame_y;

  194.     int frame_width, frame_height;

  195. 

  196.     frame_x = LE_16(&s->buf[6]);

  197.     frame_y = LE_16(&s->buf[8]);

  198.     frame_width = LE_16(&s->buf[10]) - frame_x + 1;

  199.     frame_height = LE_16(&s->buf[12]) - frame_y + 1;

  200. 

  201.     /* if only a certain region will be updated, copy the entire previous

  202.      * frame before the decode */

  203.     if (frame_x || frame_y || (frame_width != s->avctx->width) ||

  204.         (frame_height != s->avctx->height)) {

  205. 

  206.         memcpy(s->frame.data[0], s->prev_frame.data[0], 

  207.             s->avctx->height * s->frame.linesize[0]);

  208.     }

  209. 

  210.     /* check if there is a new palette */

  211.     if (s->buf[15] & 0x02) {

  212.         p += 2;

  213.         palette32 = (unsigned int *)s->palette;

  214.         for (i = 0; i < PALETTE_COUNT; i++) {

  215.             r = *p++ * 4;

  216.             g = *p++ * 4;

  217.             b = *p++ * 4;

  218.             palette32[i] = (r << 16) | (g << 8) | (b);

  219.         }

  220.         s->size -= (256 * 3 + 2);

  221.     }

  222.     if (s->size >= 0) {

  223.         /* originally UnpackFrame in VAG's code */

  224.         pb = p;

  225.         meth = *pb++;

  226.         if (meth & 0x80) {

  227.             lz_unpack(pb, s->unpack_buffer);

  228.             meth &= 0x7F;

  229.             pb = s->unpack_buffer;

  230.         }

  231. 

  232.         dp = &s->frame.data[0][frame_y * s->frame.linesize[0] + frame_x];

  233.         pp = &s->prev_frame.data[0][frame_y * s->prev_frame.linesize[0] + frame_x];

  234.         switch (meth) {

  235.         case 1:

  236.             for (i = 0; i < frame_height; i++) {

  237.                 ofs = 0;

  238.                 do {

  239.                     len = *pb++;

  240.                     if (len & 0x80) {

  241.                         len = (len & 0x7F) + 1;

  242.                         memcpy(&dp[ofs], pb, len);

  243.                         pb += len;

  244.                         ofs += len;

  245.                     } else {

  246.                         /* interframe pixel copy */

  247.                         memcpy(&dp[ofs], &pp[ofs], len + 1);

  248.                         ofs += len + 1;

  249.                     }

  250.                 } while (ofs < frame_width);

  251.                 if (ofs > frame_width) {

  252.                     printf (" VMD video: offset > width (%d > %d)\n",

  253.                         ofs, frame_width);

  254.                     break;

  255.                 }

  256.                 dp += s->frame.linesize[0];

  257.                 pp += s->prev_frame.linesize[0];

  258.             }

  259.             break;

  260. 

  261.         case 2:

  262.             for (i = 0; i < frame_height; i++) {

  263.                 memcpy(dp, pb, frame_width);

  264.                 pb += frame_width;

  265.                 dp += s->frame.linesize[0];

  266.                 pp += s->prev_frame.linesize[0];

  267.             }

  268.             break;

  269. 

  270.         case 3:

  271.             for (i = 0; i < frame_height; i++) {

  272.                 ofs = 0;

  273.                 do {

  274.                     len = *pb++;

  275.                     if (len & 0x80) {

  276.                         len = (len & 0x7F) + 1;

  277.                         if (*pb++ == 0xFF)

  278.                             len = rle_unpack(pb, dp, len);

  279.                         else

  280.                             memcpy(&dp[ofs], pb, len);

  281.                         pb += len;

  282.                         ofs += len;

  283.                     } else {

  284.                         /* interframe pixel copy */

  285.                         memcpy(&dp[ofs], &pp[ofs], len + 1);

  286.                         ofs += len + 1;

  287.                     }

  288.                 } while (ofs < frame_width);

  289.                 if (ofs > frame_width) {

  290.                     printf (" VMD video: offset > width (%d > %d)\n",

  291.                         ofs, frame_width);

  292.                 }

  293.                 dp += s->frame.linesize[0];

  294.                 pp += s->prev_frame.linesize[0];

  295.             }

  296.             break;

  297.         }

  298.     }

  299. }

  300. 

  301. static int vmdvideo_decode_init(AVCodecContext *avctx)

  302. {

  303.     VmdVideoContext *s = (VmdVideoContext *)avctx->priv_data;

  304.     int i;

  305.     unsigned int *palette32;

  306.     int palette_index = 0;

  307.     unsigned char r, g, b;

  308.     unsigned char *vmd_header;

  309.     unsigned char *raw_palette;

  310. 

  311.     s->avctx = avctx;

  312.     avctx->pix_fmt = PIX_FMT_PAL8;

  313.     avctx->has_b_frames = 0;

  314.     dsputil_init(&s->dsp, avctx);

  315. 

  316.     /* make sure the VMD header made it */

  317.     if (s->avctx->extradata_size != VMD_HEADER_SIZE) {

  318.         printf("  VMD video: expected extradata size of %d\n", 

  319.             VMD_HEADER_SIZE);

  320.         return -1;

  321.     }

  322.     vmd_header = (unsigned char *)avctx->extradata;

  323. 

  324.     s->unpack_buffer = av_malloc(LE_32(&vmd_header[800]));

  325.     if (!s->unpack_buffer)

  326.         return -1;

  327. 

  328.     /* load up the initial palette */

  329.     raw_palette = &vmd_header[28];

  330.     palette32 = (unsigned int *)s->palette;

  331.     for (i = 0; i < PALETTE_COUNT; i++) {

  332.         r = raw_palette[palette_index++] * 4;

  333.         g = raw_palette[palette_index++] * 4;

  334.         b = raw_palette[palette_index++] * 4;

  335.         palette32[i] = (r << 16) | (g << 8) | (b);

  336.     }

  337. 

  338.     s->frame.data[0] = s->prev_frame.data[0] = NULL;

  339. 

  340.     return 0;

  341. }

  342. 

  343. static int vmdvideo_decode_frame(AVCodecContext *avctx,

  344.                                  void *data, int *data_size,

  345.                                  uint8_t *buf, int buf_size)

  346. {

  347.     VmdVideoContext *s = (VmdVideoContext *)avctx->priv_data;

  348. 

  349.     s->buf = buf;

  350.     s->size = buf_size;

  351. 

  352.     s->frame.reference = 1;

  353.     if (avctx->get_buffer(avctx, &s->frame)) {

  354.         printf ("  VMD Video: get_buffer() failed\n");

  355.         return -1;

  356.     }

  357. 

  358.     vmd_decode(s);

  359. 

  360.     /* make the palette available on the way out */

  361.     memcpy(s->frame.data[1], s->palette, PALETTE_COUNT * 4);

  362. 

  363.     if (s->prev_frame.data[0])

  364.         avctx->release_buffer(avctx, &s->prev_frame);

  365. 

  366.     /* shuffle frames */

  367.     s->prev_frame = s->frame;

  368. 

  369.     *data_size = sizeof(AVFrame);

  370.     *(AVFrame*)data = s->frame;

  371. 

  372.     /* report that the buffer was completely consumed */

  373.     return buf_size;

  374. }

  375. 

  376. static int vmdvideo_decode_end(AVCodecContext *avctx)

  377. {

  378.     VmdVideoContext *s = (VmdVideoContext *)avctx->priv_data;

  379. 

  380.     if (s->prev_frame.data[0])

  381.         avctx->release_buffer(avctx, &s->prev_frame);

  382.     av_free(s->unpack_buffer);

  383. 

  384.     return 0;

  385. }

  386. 

  387. 

  388. /*

  389.  * Audio Decoder

  390.  */

  391. 

  392. typedef struct VmdAudioContext {

  393.     int channels;

  394.     int bits;

  395.     int block_align;

  396.     unsigned char steps8[16];

  397.     unsigned short steps16[16];

  398.     unsigned short steps128[256];

  399.     short predictors[2];

  400. } VmdAudioContext;

  401. 

  402. static int vmdaudio_decode_init(AVCodecContext *avctx)

  403. {

  404.     VmdAudioContext *s = (VmdAudioContext *)avctx->priv_data;

  405.     int i;

  406. 

  407.     s->channels = avctx->channels;

  408.     s->bits = avctx->bits_per_sample;

  409.     s->block_align = avctx->block_align;

  410. 

  411. printf ("  %d channels, %d bits/sample, block align = %d\n",

  412.   s->channels, s->bits, s->block_align);

  413. 

  414.     /* set up the steps8 and steps16 tables */

  415.     for (i = 0; i < 8; i++) {

  416.         if (i < 4)

  417.             s->steps8[i] = i;

  418.         else

  419.             s->steps8[i] = s->steps8[i - 1] + i - 1;

  420. 

  421.         if (i == 0)

  422.             s->steps16[i] = 0;

  423.         else if (i == 1)

  424.             s->steps16[i] = 4;

  425.         else if (i == 2)

  426.             s->steps16[i] = 16;

  427.         else

  428.             s->steps16[i] = 1 << (i + 4);

  429.     }

  430. 

  431.     /* set up the step128 table */

  432.     s->steps128[0] = 0;

  433.     s->steps128[1] = 8;

  434.     for (i = 0x02; i <= 0x20; i++)

  435.         s->steps128[i] = (i - 1) << 4;

  436.     for (i = 0x21; i <= 0x60; i++)

  437.         s->steps128[i] = (i + 0x1F) << 3;

  438.     for (i = 0x61; i <= 0x70; i++)

  439.         s->steps128[i] = (i - 0x51) << 6;

  440.     for (i = 0x71; i <= 0x78; i++)

  441.         s->steps128[i] = (i - 0x69) << 8;

  442.     for (i = 0x79; i <= 0x7D; i++)

  443.         s->steps128[i] = (i - 0x75) << 10;

  444.     s->steps128[0x7E] = 0x3000;

  445.     s->steps128[0x7F] = 0x4000;

  446. 

  447.     /* set up the negative half of each table */

  448.     for (i = 0; i < 8; i++) {

  449.         s->steps8[i + 8] = -s->steps8[i];

  450.         s->steps16[i + 8] = -s->steps16[i];

  451.     }

  452.     for (i = 0; i < 128; i++)

  453.       s->steps128[i + 128] = -s->steps128[i];

  454. 

  455.     return 0;

  456. }

  457. 

  458. static void vmdaudio_decode_audio(VmdAudioContext *s, unsigned char *data,

  459.     uint8_t *buf, int ratio) {

  460. 

  461. }

  462. 

  463. static void vmdaudio_loadsound(VmdAudioContext *s, unsigned char *data,

  464.     uint8_t *buf, int silence)

  465. {

  466.     if (s->channels == 2) {

  467.         if ((s->block_align & 0x01) == 0) {

  468.             if (silence)

  469.                 memset(data, 0, s->block_align * 2);

  470.             else

  471.                 vmdaudio_decode_audio(s, data, buf, 1);

  472.         } else {

  473.             if (silence)

  474.                 memset(data, 0, s->block_align * 2);

  475. //            else

  476. //                vmdaudio_decode_audio(s, data, buf, 1);

  477.         }

  478.     } else {

  479.     }

  480. }

  481. 

  482. static int vmdaudio_decode_frame(AVCodecContext *avctx,

  483.                                  void *data, int *data_size,

  484.                                  uint8_t *buf, int buf_size)

  485. {

  486.     VmdAudioContext *s = (VmdAudioContext *)avctx->priv_data;

  487.     unsigned int sound_flags;

  488.     unsigned char *output_samples = (unsigned char *)data;

  489. 

  490.     /* point to the start of the encoded data */

  491.     unsigned char *p = buf + 16;

  492.     unsigned char *p_end = buf + buf_size;

  493. 

  494.     if (buf[6] == 1) {

  495.         /* the chunk contains audio */

  496.         vmdaudio_loadsound(s, output_samples, p, 0);

  497.     } else if (buf[6] == 2) {

  498.         /* the chunk contains audio and silence mixed together */

  499.         sound_flags = LE_32(p);

  500.         p += 4;

  501. 

  502.         /* do something with extrabufs here? */

  503. 

  504.         while (p < p_end) {

  505.             if (sound_flags & 0x01)

  506.                 /* audio */

  507.                 vmdaudio_loadsound(s, output_samples, p, 1);

  508.             else

  509.                 /* silence */

  510.                 vmdaudio_loadsound(s, output_samples, p, 0);

  511.             p += s->block_align;

  512.             output_samples += (s->block_align * s->bits / 8);

  513.             sound_flags >>= 1;

  514.         }

  515.     } else if (buf[6] == 3) {

  516.         /* silent chunk */

  517.         vmdaudio_loadsound(s, output_samples, p, 1);

  518.     }

  519. 

  520. 

  521. //    *datasize = ;

  522.     return buf_size;

  523. }

  524. 

  525. 

  526. /*

  527.  * Public Data Structures

  528.  */

  529. 

  530. AVCodec vmdvideo_decoder = {

  531.     "vmdvideo",

  532.     CODEC_TYPE_VIDEO,

  533.     CODEC_ID_VMDVIDEO,

  534.     sizeof(VmdVideoContext),

  535.     vmdvideo_decode_init,

  536.     NULL,

  537.     vmdvideo_decode_end,

  538.     vmdvideo_decode_frame,

  539.     CODEC_CAP_DR1,

  540. };

  541. 

  542. AVCodec vmdaudio_decoder = {

  543.     "vmdaudio",

  544.     CODEC_TYPE_AUDIO,

  545.     CODEC_ID_VMDAUDIO,

  546.     sizeof(VmdAudioContext),

  547.     vmdaudio_decode_init,

  548.     NULL,

  549.     NULL,

  550.     vmdaudio_decode_frame,

  551. };