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_end(AVCodecContext *avctx)
377 {
378  VmdVideoContext *s = avctx->priv_data;
379 
380  av_frame_free(&s->prev_frame);
381  av_freep(&s->unpack_buffer);
382 
383  return 0;
384 }
385 
386 static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
387 {
388  VmdVideoContext *s = avctx->priv_data;
389  int i;
390  unsigned int *palette32;
391  int palette_index = 0;
392  unsigned char r, g, b;
393  unsigned char *vmd_header;
394  unsigned char *raw_palette;
395 
396  s->avctx = avctx;
397  avctx->pix_fmt = AV_PIX_FMT_PAL8;
398 
399  /* make sure the VMD header made it */
400  if (s->avctx->extradata_size != VMD_HEADER_SIZE) {
401  av_log(s->avctx, AV_LOG_ERROR, "expected extradata size of %d\n",
402  VMD_HEADER_SIZE);
403  return AVERROR_INVALIDDATA;
404  }
405  vmd_header = (unsigned char *)avctx->extradata;
406 
407  s->unpack_buffer_size = AV_RL32(&vmd_header[800]);
408  if (s->unpack_buffer_size) {
409  s->unpack_buffer = av_malloc(s->unpack_buffer_size);
410  if (!s->unpack_buffer)
411  return AVERROR(ENOMEM);
412  }
413 
414  /* load up the initial palette */
415  raw_palette = &vmd_header[28];
416  palette32 = (unsigned int *)s->palette;
417  for (i = 0; i < PALETTE_COUNT; i++) {
418  r = raw_palette[palette_index++] * 4;
419  g = raw_palette[palette_index++] * 4;
420  b = raw_palette[palette_index++] * 4;
421  palette32[i] = 0xFFU << 24 | (r << 16) | (g << 8) | (b);
422  palette32[i] |= palette32[i] >> 6 & 0x30303;
423  }
424 
425  s->prev_frame = av_frame_alloc();
426  if (!s->prev_frame) {
427  vmdvideo_decode_end(avctx);
428  return AVERROR(ENOMEM);
429  }
430 
431  return 0;
432 }
433 
434 static int vmdvideo_decode_frame(AVCodecContext *avctx,
435  void *data, int *got_frame,
436  AVPacket *avpkt)
437 {
438  const uint8_t *buf = avpkt->data;
439  int buf_size = avpkt->size;
440  VmdVideoContext *s = avctx->priv_data;
441  AVFrame *frame = data;
442  int ret;
443 
444  s->buf = buf;
445  s->size = buf_size;
446 
447  if (buf_size < 16)
448  return AVERROR_INVALIDDATA;
449 
450  if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
451  return ret;
452 
453  if ((ret = vmd_decode(s, frame)) < 0)
454  return ret;
455 
456  /* make the palette available on the way out */
457  memcpy(frame->data[1], s->palette, PALETTE_COUNT * 4);
458 
459  /* shuffle frames */
460  av_frame_unref(s->prev_frame);
461  if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
462  return ret;
463 
464  *got_frame = 1;
465 
466  /* report that the buffer was completely consumed */
467  return buf_size;
468 }
469 
470 /*
471  * Audio Decoder
472  */
473 
474 #define BLOCK_TYPE_AUDIO 1
475 #define BLOCK_TYPE_INITIAL 2
476 #define BLOCK_TYPE_SILENCE 3
477 
478 typedef struct VmdAudioContext {
479  int out_bps;
480  int chunk_size;
481 } VmdAudioContext;
482 
483 static const uint16_t vmdaudio_table[128] = {
484  0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
485  0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
486  0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
487  0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
488  0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
489  0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
490  0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
491  0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
492  0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
493  0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
494  0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
495  0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
496  0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
497 };
498 
499 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
500 {
501  VmdAudioContext *s = avctx->priv_data;
502 
503  if (avctx->channels < 1 || avctx->channels > 2) {
504  av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
505  return AVERROR(EINVAL);
506  }
507  if (avctx->block_align < 1 || avctx->block_align % avctx->channels) {
508  av_log(avctx, AV_LOG_ERROR, "invalid block align\n");
509  return AVERROR(EINVAL);
510  }
511 
512  avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
513  AV_CH_LAYOUT_STEREO;
514 
515  if (avctx->bits_per_coded_sample == 16)
516  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
517  else
518  avctx->sample_fmt = AV_SAMPLE_FMT_U8;
519  s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
520 
521  s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
522 
523  av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
524  "block align = %d, sample rate = %d\n",
525  avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
526  avctx->sample_rate);
527 
528  return 0;
529 }
530 
531 static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size,
532  int channels)
533 {
534  int ch;
535  const uint8_t *buf_end = buf + buf_size;
536  int predictor[2];
537  int st = channels - 1;
538 
539  /* decode initial raw sample */
540  for (ch = 0; ch < channels; ch++) {
541  predictor[ch] = (int16_t)AV_RL16(buf);
542  buf += 2;
543  *out++ = predictor[ch];
544  }
545 
546  /* decode DPCM samples */
547  ch = 0;
548  while (buf < buf_end) {
549  uint8_t b = *buf++;
550  if (b & 0x80)
551  predictor[ch] -= vmdaudio_table[b & 0x7F];
552  else
553  predictor[ch] += vmdaudio_table[b];
554  predictor[ch] = av_clip_int16(predictor[ch]);
555  *out++ = predictor[ch];
556  ch ^= st;
557  }
558 }
559 
560 static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
561  int *got_frame_ptr, AVPacket *avpkt)
562 {
563  AVFrame *frame = data;
564  const uint8_t *buf = avpkt->data;
565  const uint8_t *buf_end;
566  int buf_size = avpkt->size;
567  VmdAudioContext *s = avctx->priv_data;
568  int block_type, silent_chunks, audio_chunks;
569  int ret;
570  uint8_t *output_samples_u8;
571  int16_t *output_samples_s16;
572 
573  if (buf_size < 16) {
574  av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
575  *got_frame_ptr = 0;
576  return buf_size;
577  }
578 
579  block_type = buf[6];
580  if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
581  av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
582  return AVERROR(EINVAL);
583  }
584  buf += 16;
585  buf_size -= 16;
586 
587  /* get number of silent chunks */
588  silent_chunks = 0;
589  if (block_type == BLOCK_TYPE_INITIAL) {
590  uint32_t flags;
591  if (buf_size < 4) {
592  av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
593  return AVERROR(EINVAL);
594  }
595  flags = AV_RB32(buf);
596  silent_chunks = av_popcount(flags);
597  buf += 4;
598  buf_size -= 4;
599  } else if (block_type == BLOCK_TYPE_SILENCE) {
600  silent_chunks = 1;
601  buf_size = 0; // should already be zero but set it just to be sure
602  }
603 
604  /* ensure output buffer is large enough */
605  audio_chunks = buf_size / s->chunk_size;
606 
607  /* drop incomplete chunks */
608  buf_size = audio_chunks * s->chunk_size;
609 
610  /* get output buffer */
611  frame->nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) /
612  avctx->channels;
613  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
614  return ret;
615  output_samples_u8 = frame->data[0];
616  output_samples_s16 = (int16_t *)frame->data[0];
617 
618  /* decode silent chunks */
619  if (silent_chunks > 0) {
620  int silent_size = avctx->block_align * silent_chunks;
621  av_assert0(avctx->block_align * silent_chunks <= frame->nb_samples * avctx->channels);
622 
623  if (s->out_bps == 2) {
624  memset(output_samples_s16, 0x00, silent_size * 2);
625  output_samples_s16 += silent_size;
626  } else {
627  memset(output_samples_u8, 0x80, silent_size);
628  output_samples_u8 += silent_size;
629  }
630  }
631 
632  /* decode audio chunks */
633  if (audio_chunks > 0) {
634  buf_end = buf + buf_size;
635  av_assert0((buf_size & (avctx->channels > 1)) == 0);
636  while (buf_end - buf >= s->chunk_size) {
637  if (s->out_bps == 2) {
638  decode_audio_s16(output_samples_s16, buf, s->chunk_size,
639  avctx->channels);
640  output_samples_s16 += avctx->block_align;
641  } else {
642  memcpy(output_samples_u8, buf, s->chunk_size);
643  output_samples_u8 += avctx->block_align;
644  }
645  buf += s->chunk_size;
646  }
647  }
648 
649  *got_frame_ptr = 1;
650 
651  return avpkt->size;
652 }
653 
654 
655 /*
656  * Public Data Structures
657  */
658 
659 AVCodec ff_vmdvideo_decoder = {
660  .name = "vmdvideo",
661  .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
662  .type = AVMEDIA_TYPE_VIDEO,
663  .id = AV_CODEC_ID_VMDVIDEO,
664  .priv_data_size = sizeof(VmdVideoContext),
665  .init = vmdvideo_decode_init,
666  .close = vmdvideo_decode_end,
667  .decode = vmdvideo_decode_frame,
668  .capabilities = CODEC_CAP_DR1,
669 };
670 
671 AVCodec ff_vmdaudio_decoder = {
672  .name = "vmdaudio",
673  .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),
674  .type = AVMEDIA_TYPE_AUDIO,
675  .id = AV_CODEC_ID_VMDAUDIO,
676  .priv_data_size = sizeof(VmdAudioContext),
677  .init = vmdaudio_decode_init,
678  .decode = vmdaudio_decode_frame,
679  .capabilities = CODEC_CAP_DR1,
680 };
Generated on Sat Jan 25 2014 19:51:56 for FFmpeg by   doxygen 1.8.2