FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
vmdav.c
Go to the documentation of this file.
1 /*
2  * Sierra VMD Audio & Video Decoders
3  * Copyright (C) 2004 the ffmpeg project
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Sierra VMD audio & video decoders
25  * by Vladimir "VAG" Gneushev (vagsoft at mail.ru)
26  * for more information on the Sierra VMD format, visit:
27  * http://www.pcisys.net/~melanson/codecs/
28  *
29  * The video decoder outputs PAL8 colorspace data. The decoder expects
30  * a 0x330-byte VMD file header to be transmitted via extradata during
31  * codec initialization. Each encoded frame that is sent to this decoder
32  * is expected to be prepended with the appropriate 16-byte frame
33  * information record from the VMD file.
34  *
35  * The audio decoder, like the video decoder, expects each encoded data
36  * chunk to be prepended with the appropriate 16-byte frame information
37  * record from the VMD file. It does not require the 0x330-byte VMD file
38  * header, but it does need the audio setup parameters passed in through
39  * normal libavcodec API means.
40  */
41 
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 
46 #include "libavutil/avassert.h"
47 #include "libavutil/channel_layout.h"
48 #include "libavutil/common.h"
49 #include "libavutil/intreadwrite.h"
50 #include "avcodec.h"
51 #include "internal.h"
52 #include "bytestream.h"
53 
54 #define VMD_HEADER_SIZE 0x330
55 #define PALETTE_COUNT 256
56 
57 /*
58  * Video Decoder
59  */
60 
61 typedef struct VmdVideoContext {
62 
63  AVCodecContext *avctx;
64  AVFrame prev_frame;
65 
66  const unsigned char *buf;
67  int size;
68 
69  unsigned char palette[PALETTE_COUNT * 4];
70  unsigned char *unpack_buffer;
71  int unpack_buffer_size;
72 
73  int x_off, y_off;
74 } VmdVideoContext;
75 
76 #define QUEUE_SIZE 0x1000
77 #define QUEUE_MASK 0x0FFF
78 
79 static void lz_unpack(const unsigned char *src, int src_len,
80  unsigned char *dest, int dest_len)
81 {
82  unsigned char *d;
83  unsigned char *d_end;
84  unsigned char queue[QUEUE_SIZE];
85  unsigned int qpos;
86  unsigned int dataleft;
87  unsigned int chainofs;
88  unsigned int chainlen;
89  unsigned int speclen;
90  unsigned char tag;
91  unsigned int i, j;
92  GetByteContext gb;
93 
94  bytestream2_init(&gb, src, src_len);
95  d = dest;
96  d_end = d + dest_len;
97  dataleft = bytestream2_get_le32(&gb);
98  memset(queue, 0x20, QUEUE_SIZE);
99  if (bytestream2_get_bytes_left(&gb) < 4)
100  return;
101  if (bytestream2_peek_le32(&gb) == 0x56781234) {
102  bytestream2_skipu(&gb, 4);
103  qpos = 0x111;
104  speclen = 0xF + 3;
105  } else {
106  qpos = 0xFEE;
107  speclen = 100; /* no speclen */
108  }
109 
110  while (dataleft > 0 && bytestream2_get_bytes_left(&gb) > 0) {
111  tag = bytestream2_get_byteu(&gb);
112  if ((tag == 0xFF) && (dataleft > 8)) {
113  if (d_end - d < 8 || bytestream2_get_bytes_left(&gb) < 8)
114  return;
115  for (i = 0; i < 8; i++) {
116  queue[qpos++] = *d++ = bytestream2_get_byteu(&gb);
117  qpos &= QUEUE_MASK;
118  }
119  dataleft -= 8;
120  } else {
121  for (i = 0; i < 8; i++) {
122  if (dataleft == 0)
123  break;
124  if (tag & 0x01) {
125  if (d_end - d < 1 || bytestream2_get_bytes_left(&gb) < 1)
126  return;
127  queue[qpos++] = *d++ = bytestream2_get_byteu(&gb);
128  qpos &= QUEUE_MASK;
129  dataleft--;
130  } else {
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;
136  }
137  if (d_end - d < chainlen)
138  return;
139  for (j = 0; j < chainlen; j++) {
140  *d = queue[chainofs++ & QUEUE_MASK];
141  queue[qpos++] = *d++;
142  qpos &= QUEUE_MASK;
143  }
144  dataleft -= chainlen;
145  }
146  tag >>= 1;
147  }
148  }
149  }
150 }
151 static int rle_unpack(const unsigned char *src, unsigned char *dest,
152  int src_count, int src_size, int dest_len)
153 {
154  unsigned char *pd;
155  int i, l, used = 0;
156  unsigned char *dest_end = dest + dest_len;
157  GetByteContext gb;
158  uint16_t run_val;
159 
160  bytestream2_init(&gb, src, src_size);
161  pd = dest;
162  if (src_count & 1) {
163  if (bytestream2_get_bytes_left(&gb) < 1)
164  return 0;
165  *pd++ = bytestream2_get_byteu(&gb);
166  used++;
167  }
168 
169  do {
170  if (bytestream2_get_bytes_left(&gb) < 1)
171  break;
172  l = bytestream2_get_byteu(&gb);
173  if (l & 0x80) {
174  l = (l & 0x7F) * 2;
175  if (dest_end - pd < l || bytestream2_get_bytes_left(&gb) < l)
176  return bytestream2_tell(&gb);
177  bytestream2_get_bufferu(&gb, pd, l);
178  pd += l;
179  } else {
180  if (dest_end - pd < 2*l || bytestream2_get_bytes_left(&gb) < 2)
181  return bytestream2_tell(&gb);
182  run_val = bytestream2_get_ne16(&gb);
183  for (i = 0; i < l; i++) {
184  AV_WN16(pd, run_val);
185  pd += 2;
186  }
187  l *= 2;
188  }
189  used += l;
190  } while (used < src_count);
191 
192  return bytestream2_tell(&gb);
193 }
194 
195 static int vmd_decode(VmdVideoContext *s, AVFrame *frame)
196 {
197  int i;
198  unsigned int *palette32;
199  unsigned char r, g, b;
200 
201  GetByteContext gb;
202 
203  unsigned char meth;
204  unsigned char *dp; /* pointer to current frame */
205  unsigned char *pp; /* pointer to previous frame */
206  unsigned char len;
207  int ofs;
208 
209  int frame_x, frame_y;
210  int frame_width, frame_height;
211 
212  frame_x = AV_RL16(&s->buf[6]);
213  frame_y = AV_RL16(&s->buf[8]);
214  frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;
215  frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;
216 
217  if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&
218  (frame_x || frame_y)) {
219 
220  s->x_off = frame_x;
221  s->y_off = frame_y;
222  }
223  frame_x -= s->x_off;
224  frame_y -= s->y_off;
225 
226  if (frame_x < 0 || frame_width < 0 ||
227  frame_x >= s->avctx->width ||
228  frame_width > s->avctx->width ||
229  frame_x + frame_width > s->avctx->width) {
230  av_log(s->avctx, AV_LOG_ERROR,
231  "Invalid horizontal range %d-%d\n",
232  frame_x, frame_width);
233  return AVERROR_INVALIDDATA;
234  }
235  if (frame_y < 0 || frame_height < 0 ||
236  frame_y >= s->avctx->height ||
237  frame_height > s->avctx->height ||
238  frame_y + frame_height > s->avctx->height) {
239  av_log(s->avctx, AV_LOG_ERROR,
240  "Invalid vertical range %d-%d\n",
241  frame_x, frame_width);
242  return AVERROR_INVALIDDATA;
243  }
244 
245  /* if only a certain region will be updated, copy the entire previous
246  * frame before the decode */
247  if (s->prev_frame.data[0] &&
248  (frame_x || frame_y || (frame_width != s->avctx->width) ||
249  (frame_height != s->avctx->height))) {
250 
251  memcpy(frame->data[0], s->prev_frame.data[0],
252  s->avctx->height * frame->linesize[0]);
253  }
254 
255  /* check if there is a new palette */
256  bytestream2_init(&gb, s->buf + 16, s->size - 16);
257  if (s->buf[15] & 0x02) {
258  bytestream2_skip(&gb, 2);
259  palette32 = (unsigned int *)s->palette;
260  if (bytestream2_get_bytes_left(&gb) >= PALETTE_COUNT * 3) {
261  for (i = 0; i < PALETTE_COUNT; i++) {
262  r = bytestream2_get_byteu(&gb) * 4;
263  g = bytestream2_get_byteu(&gb) * 4;
264  b = bytestream2_get_byteu(&gb) * 4;
265  palette32[i] = 0xFFU << 24 | (r << 16) | (g << 8) | (b);
266  palette32[i] |= palette32[i] >> 6 & 0x30303;
267  }
268  } else {
269  av_log(s->avctx, AV_LOG_ERROR, "Incomplete palette\n");
270  return AVERROR_INVALIDDATA;
271  }
272  }
273 
274  if (!s->size)
275  return 0;
276 
277  /* originally UnpackFrame in VAG's code */
278  if (bytestream2_get_bytes_left(&gb) < 1)
279  return AVERROR_INVALIDDATA;
280  meth = bytestream2_get_byteu(&gb);
281  if (meth & 0x80) {
282  if (!s->unpack_buffer_size) {
283  av_log(s->avctx, AV_LOG_ERROR,
284  "Trying to unpack LZ-compressed frame with no LZ buffer\n");
285  return AVERROR_INVALIDDATA;
286  }
287  lz_unpack(gb.buffer, bytestream2_get_bytes_left(&gb),
288  s->unpack_buffer, s->unpack_buffer_size);
289  meth &= 0x7F;
290  bytestream2_init(&gb, s->unpack_buffer, s->unpack_buffer_size);
291  }
292 
293  dp = &frame->data[0][frame_y * frame->linesize[0] + frame_x];
294  pp = &s->prev_frame.data[0][frame_y * s->prev_frame.linesize[0] + frame_x];
295  switch (meth) {
296  case 1:
297  for (i = 0; i < frame_height; i++) {
298  ofs = 0;
299  do {
300  len = bytestream2_get_byte(&gb);
301  if (len & 0x80) {
302  len = (len & 0x7F) + 1;
303  if (ofs + len > frame_width ||
304  bytestream2_get_bytes_left(&gb) < len)
305  return AVERROR_INVALIDDATA;
306  bytestream2_get_bufferu(&gb, &dp[ofs], len);
307  ofs += len;
308  } else {
309  /* interframe pixel copy */
310  if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
311  return AVERROR_INVALIDDATA;
312  memcpy(&dp[ofs], &pp[ofs], len + 1);
313  ofs += len + 1;
314  }
315  } while (ofs < frame_width);
316  if (ofs > frame_width) {
317  av_log(s->avctx, AV_LOG_ERROR,
318  "offset > width (%d > %d)\n",
319  ofs, frame_width);
320  return AVERROR_INVALIDDATA;
321  }
322  dp += frame->linesize[0];
323  pp += s->prev_frame.linesize[0];
324  }
325  break;
326 
327  case 2:
328  for (i = 0; i < frame_height; i++) {
329  bytestream2_get_buffer(&gb, dp, frame_width);
330  dp += frame->linesize[0];
331  pp += s->prev_frame.linesize[0];
332  }
333  break;
334 
335  case 3:
336  for (i = 0; i < frame_height; i++) {
337  ofs = 0;
338  do {
339  len = bytestream2_get_byte(&gb);
340  if (len & 0x80) {
341  len = (len & 0x7F) + 1;
342  if (bytestream2_peek_byte(&gb) == 0xFF) {
343  int slen = len;
344  bytestream2_get_byte(&gb);
345  len = rle_unpack(gb.buffer, &dp[ofs],
346  len, bytestream2_get_bytes_left(&gb),
347  frame_width - ofs);
348  ofs += slen;
349  bytestream2_skip(&gb, len);
350  } else {
351  bytestream2_get_buffer(&gb, &dp[ofs], len);
352  ofs += len;
353  }
354  } else {
355  /* interframe pixel copy */
356  if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
357  return AVERROR_INVALIDDATA;
358  memcpy(&dp[ofs], &pp[ofs], len + 1);
359  ofs += len + 1;
360  }
361  } while (ofs < frame_width);
362  if (ofs > frame_width) {
363  av_log(s->avctx, AV_LOG_ERROR,
364  "offset > width (%d > %d)\n",
365  ofs, frame_width);
366  return AVERROR_INVALIDDATA;
367  }
368  dp += frame->linesize[0];
369  pp += s->prev_frame.linesize[0];
370  }
371  break;
372  }
373  return 0;
374 }
375 
376 static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
377 {
378  VmdVideoContext *s = avctx->priv_data;
379  int i;
380  unsigned int *palette32;
381  int palette_index = 0;
382  unsigned char r, g, b;
383  unsigned char *vmd_header;
384  unsigned char *raw_palette;
385 
386  s->avctx = avctx;
387  avctx->pix_fmt = AV_PIX_FMT_PAL8;
388 
389  /* make sure the VMD header made it */
390  if (s->avctx->extradata_size != VMD_HEADER_SIZE) {
391  av_log(s->avctx, AV_LOG_ERROR, "expected extradata size of %d\n",
392  VMD_HEADER_SIZE);
393  return AVERROR_INVALIDDATA;
394  }
395  vmd_header = (unsigned char *)avctx->extradata;
396 
397  s->unpack_buffer_size = AV_RL32(&vmd_header[800]);
398  if (s->unpack_buffer_size) {
399  s->unpack_buffer = av_malloc(s->unpack_buffer_size);
400  if (!s->unpack_buffer)
401  return AVERROR(ENOMEM);
402  }
403 
404  /* load up the initial palette */
405  raw_palette = &vmd_header[28];
406  palette32 = (unsigned int *)s->palette;
407  for (i = 0; i < PALETTE_COUNT; i++) {
408  r = raw_palette[palette_index++] * 4;
409  g = raw_palette[palette_index++] * 4;
410  b = raw_palette[palette_index++] * 4;
411  palette32[i] = (r << 16) | (g << 8) | (b);
412  }
413 
414  avcodec_get_frame_defaults(&s->prev_frame);
415 
416  return 0;
417 }
418 
419 static int vmdvideo_decode_frame(AVCodecContext *avctx,
420  void *data, int *got_frame,
421  AVPacket *avpkt)
422 {
423  const uint8_t *buf = avpkt->data;
424  int buf_size = avpkt->size;
425  VmdVideoContext *s = avctx->priv_data;
426  AVFrame *frame = data;
427  int ret;
428 
429  s->buf = buf;
430  s->size = buf_size;
431 
432  if (buf_size < 16)
433  return AVERROR_INVALIDDATA;
434 
435  if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
436  return ret;
437 
438  if ((ret = vmd_decode(s, frame)) < 0)
439  return ret;
440 
441  /* make the palette available on the way out */
442  memcpy(frame->data[1], s->palette, PALETTE_COUNT * 4);
443 
444  /* shuffle frames */
445  av_frame_unref(&s->prev_frame);
446  if ((ret = av_frame_ref(&s->prev_frame, frame)) < 0)
447  return ret;
448 
449  *got_frame = 1;
450 
451  /* report that the buffer was completely consumed */
452  return buf_size;
453 }
454 
455 static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
456 {
457  VmdVideoContext *s = avctx->priv_data;
458 
459  av_frame_unref(&s->prev_frame);
460  av_free(s->unpack_buffer);
461 
462  return 0;
463 }
464 
465 
466 /*
467  * Audio Decoder
468  */
469 
470 #define BLOCK_TYPE_AUDIO 1
471 #define BLOCK_TYPE_INITIAL 2
472 #define BLOCK_TYPE_SILENCE 3
473 
474 typedef struct VmdAudioContext {
475  int out_bps;
476  int chunk_size;
477 } VmdAudioContext;
478 
479 static const uint16_t vmdaudio_table[128] = {
480  0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
481  0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
482  0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
483  0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
484  0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
485  0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
486  0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
487  0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
488  0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
489  0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
490  0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
491  0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
492  0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
493 };
494 
495 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
496 {
497  VmdAudioContext *s = avctx->priv_data;
498 
499  if (avctx->channels < 1 || avctx->channels > 2) {
500  av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
501  return AVERROR(EINVAL);
502  }
503  if (avctx->block_align < 1 || avctx->block_align % avctx->channels) {
504  av_log(avctx, AV_LOG_ERROR, "invalid block align\n");
505  return AVERROR(EINVAL);
506  }
507 
508  avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
509  AV_CH_LAYOUT_STEREO;
510 
511  if (avctx->bits_per_coded_sample == 16)
512  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
513  else
514  avctx->sample_fmt = AV_SAMPLE_FMT_U8;
515  s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
516 
517  s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
518 
519  av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
520  "block align = %d, sample rate = %d\n",
521  avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
522  avctx->sample_rate);
523 
524  return 0;
525 }
526 
527 static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size,
528  int channels)
529 {
530  int ch;
531  const uint8_t *buf_end = buf + buf_size;
532  int predictor[2];
533  int st = channels - 1;
534 
535  /* decode initial raw sample */
536  for (ch = 0; ch < channels; ch++) {
537  predictor[ch] = (int16_t)AV_RL16(buf);
538  buf += 2;
539  *out++ = predictor[ch];
540  }
541 
542  /* decode DPCM samples */
543  ch = 0;
544  while (buf < buf_end) {
545  uint8_t b = *buf++;
546  if (b & 0x80)
547  predictor[ch] -= vmdaudio_table[b & 0x7F];
548  else
549  predictor[ch] += vmdaudio_table[b];
550  predictor[ch] = av_clip_int16(predictor[ch]);
551  *out++ = predictor[ch];
552  ch ^= st;
553  }
554 }
555 
556 static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
557  int *got_frame_ptr, AVPacket *avpkt)
558 {
559  AVFrame *frame = data;
560  const uint8_t *buf = avpkt->data;
561  const uint8_t *buf_end;
562  int buf_size = avpkt->size;
563  VmdAudioContext *s = avctx->priv_data;
564  int block_type, silent_chunks, audio_chunks;
565  int ret;
566  uint8_t *output_samples_u8;
567  int16_t *output_samples_s16;
568 
569  if (buf_size < 16) {
570  av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
571  *got_frame_ptr = 0;
572  return buf_size;
573  }
574 
575  block_type = buf[6];
576  if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
577  av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
578  return AVERROR(EINVAL);
579  }
580  buf += 16;
581  buf_size -= 16;
582 
583  /* get number of silent chunks */
584  silent_chunks = 0;
585  if (block_type == BLOCK_TYPE_INITIAL) {
586  uint32_t flags;
587  if (buf_size < 4) {
588  av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
589  return AVERROR(EINVAL);
590  }
591  flags = AV_RB32(buf);
592  silent_chunks = av_popcount(flags);
593  buf += 4;
594  buf_size -= 4;
595  } else if (block_type == BLOCK_TYPE_SILENCE) {
596  silent_chunks = 1;
597  buf_size = 0; // should already be zero but set it just to be sure
598  }
599 
600  /* ensure output buffer is large enough */
601  audio_chunks = buf_size / s->chunk_size;
602 
603  /* drop incomplete chunks */
604  buf_size = audio_chunks * s->chunk_size;
605 
606  /* get output buffer */
607  frame->nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) /
608  avctx->channels;
609  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
610  return ret;
611  output_samples_u8 = frame->data[0];
612  output_samples_s16 = (int16_t *)frame->data[0];
613 
614  /* decode silent chunks */
615  if (silent_chunks > 0) {
616  int silent_size = avctx->block_align * silent_chunks;
617  av_assert0(avctx->block_align * silent_chunks <= frame->nb_samples * avctx->channels);
618 
619  if (s->out_bps == 2) {
620  memset(output_samples_s16, 0x00, silent_size * 2);
621  output_samples_s16 += silent_size;
622  } else {
623  memset(output_samples_u8, 0x80, silent_size);
624  output_samples_u8 += silent_size;
625  }
626  }
627 
628  /* decode audio chunks */
629  if (audio_chunks > 0) {
630  buf_end = buf + buf_size;
631  av_assert0((buf_size & (avctx->channels > 1)) == 0);
632  while (buf_end - buf >= s->chunk_size) {
633  if (s->out_bps == 2) {
634  decode_audio_s16(output_samples_s16, buf, s->chunk_size,
635  avctx->channels);
636  output_samples_s16 += avctx->block_align;
637  } else {
638  memcpy(output_samples_u8, buf, s->chunk_size);
639  output_samples_u8 += avctx->block_align;
640  }
641  buf += s->chunk_size;
642  }
643  }
644 
645  *got_frame_ptr = 1;
646 
647  return avpkt->size;
648 }
649 
650 
651 /*
652  * Public Data Structures
653  */
654 
655 AVCodec ff_vmdvideo_decoder = {
656  .name = "vmdvideo",
657  .type = AVMEDIA_TYPE_VIDEO,
658  .id = AV_CODEC_ID_VMDVIDEO,
659  .priv_data_size = sizeof(VmdVideoContext),
660  .init = vmdvideo_decode_init,
661  .close = vmdvideo_decode_end,
662  .decode = vmdvideo_decode_frame,
663  .capabilities = CODEC_CAP_DR1,
664  .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
665 };
666 
667 AVCodec ff_vmdaudio_decoder = {
668  .name = "vmdaudio",
669  .type = AVMEDIA_TYPE_AUDIO,
670  .id = AV_CODEC_ID_VMDAUDIO,
671  .priv_data_size = sizeof(VmdAudioContext),
672  .init = vmdaudio_decode_init,
673  .decode = vmdaudio_decode_frame,
674  .capabilities = CODEC_CAP_DR1,
675  .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),
676 };
Generated on Wed Jun 19 2013 19:20:57 for FFmpeg by   doxygen 1.8.2