FFmpeg: libavcodec/vmdav.c Source File

FFmpeg

[フレーム]

libavcodec

vmdav.c

Go to the documentation of this file.

1 /*

2 * Sierra VMD Audio & Video Decoders

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 */

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 */

42 #include <stdio.h>

43 #include <stdlib.h>

44 #include <string.h>

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"

54 #define VMD_HEADER_SIZE 0x330

55 #define PALETTE_COUNT 256

57 /*

58 * Video Decoder

59 */

61 typedef struct VmdVideoContext {

63 AVCodecContext *avctx;

64 AVFrame *prev_frame;

66 const unsigned char *buf;

67 int size;

69 unsigned char palette[PALETTE_COUNT * 4];

70 unsigned char *unpack_buffer;

71 int unpack_buffer_size;

73 int x_off, y_off;

74 } VmdVideoContext;

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)

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;

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