FFmpeg: libavcodec/interplayvideo.c Source File

FFmpeg

[フレーム]

libavcodec

interplayvideo.c

Go to the documentation of this file.

1 /*

2 * Interplay MVE Video Decoder

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 * Interplay MVE Video Decoder by Mike Melanson (melanson@pcisys.net)

25 * For more information about the Interplay MVE format, visit:

26 * http://www.pcisys.net/~melanson/codecs/interplay-mve.txt

27 * This code is written in such a way that the identifiers match up

28 * with the encoding descriptions in the document.

29 *

30 * This decoder presently only supports a PAL8 output colorspace.

31 *

32 * An Interplay video frame consists of 2 parts: The decoding map and

33 * the video data. A demuxer must load these 2 parts together in a single

34 * buffer before sending it through the stream to this decoder.

35 */

37 #include <stdio.h>

38 #include <stdlib.h>

39 #include <string.h>

41 #include "avcodec.h"

42 #include "bytestream.h"

43 #include "hpeldsp.h"

44 #define BITSTREAM_READER_LE

45 #include "get_bits.h"

46 #include "internal.h"

48 #define PALETTE_COUNT 256

50 typedef struct IpvideoContext {

52 AVCodecContext *avctx;

53 HpelDSPContext hdsp;

54 AVFrame *second_last_frame;

55 AVFrame *last_frame;

56 const unsigned char *decoding_map;

57 int decoding_map_size;

59 int is_16bpp;

60 GetByteContext stream_ptr, mv_ptr;

61 unsigned char *pixel_ptr;

62 int line_inc;

63 int stride;

64 int upper_motion_limit_offset;

66 uint32_t pal[256];

67 } IpvideoContext;

69 static int copy_from(IpvideoContext *s, AVFrame *src, AVFrame *dst, int delta_x, int delta_y)

70 {

71 int current_offset = s->pixel_ptr - dst->data[0];

72 int motion_offset = current_offset + delta_y * dst->linesize[0]

73 + delta_x * (1 + s->is_16bpp);

74 if (motion_offset < 0) {

75 av_log(s->avctx, AV_LOG_ERROR, "motion offset < 0 (%d)\n", motion_offset);

76 return AVERROR_INVALIDDATA;

77 } else if (motion_offset > s->upper_motion_limit_offset) {

78 av_log(s->avctx, AV_LOG_ERROR, "motion offset above limit (%d >= %d)\n",

79 motion_offset, s->upper_motion_limit_offset);

80 return AVERROR_INVALIDDATA;

81 }

82 if (!src->data[0]) {

83 av_log(s->avctx, AV_LOG_ERROR, "Invalid decode type, corrupted header?\n");

84 return AVERROR(EINVAL);

85 }

86 s->hdsp.put_pixels_tab[!s->is_16bpp][0](s->pixel_ptr, src->data[0] + motion_offset,

87 dst->linesize[0], 8);

88 return 0;

89 }

91 static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s, AVFrame *frame)

92 {

93 return copy_from(s, s->last_frame, frame, 0, 0);

94 }

96 static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s, AVFrame *frame)

97 {

98 return copy_from(s, s->second_last_frame, frame, 0, 0);

99 }

100

101 static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s, AVFrame *frame)

102 {

103 unsigned char B;

104 int x, y;

105

106 /* copy block from 2 frames ago using a motion vector; need 1 more byte */

107 if (!s->is_16bpp) {

108 B = bytestream2_get_byte(&s->stream_ptr);

109 } else {

110 B = bytestream2_get_byte(&s->mv_ptr);

111 }

112

113 if (B < 56) {

114 x = 8 + (B % 7);

115 y = B / 7;

116 } else {

117 x = -14 + ((B - 56) % 29);

118 y = 8 + ((B - 56) / 29);

119 }

120

121 av_dlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);

122 return copy_from(s, s->second_last_frame, frame, x, y);

123 }

124

125 static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s, AVFrame *frame)

126 {

127 unsigned char B;

128 int x, y;

129

130 /* copy 8x8 block from current frame from an up/left block */

131

132 /* need 1 more byte for motion */

133 if (!s->is_16bpp) {

134 B = bytestream2_get_byte(&s->stream_ptr);

135 } else {

136 B = bytestream2_get_byte(&s->mv_ptr);

137 }

138

139 if (B < 56) {

140 x = -(8 + (B % 7));

141 y = -(B / 7);

142 } else {

143 x = -(-14 + ((B - 56) % 29));

144 y = -( 8 + ((B - 56) / 29));

145 }

146

147 av_dlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);

148 return copy_from(s, frame, frame, x, y);

149 }

150

151 static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s, AVFrame *frame)

152 {

153 int x, y;

154 unsigned char B, BL, BH;

155

156 /* copy a block from the previous frame; need 1 more byte */

157 if (!s->is_16bpp) {

158 B = bytestream2_get_byte(&s->stream_ptr);

159 } else {

160 B = bytestream2_get_byte(&s->mv_ptr);

161 }

162

163 BL = B & 0x0F;

164 BH = (B >> 4) & 0x0F;

165 x = -8 + BL;

166 y = -8 + BH;

167

168 av_dlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);

169 return copy_from(s, s->last_frame, frame, x, y);

170 }

171

172 static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s, AVFrame *frame)

173 {

174 signed char x, y;

175

176 /* copy a block from the previous frame using an expanded range;

177 * need 2 more bytes */

178 x = bytestream2_get_byte(&s->stream_ptr);

179 y = bytestream2_get_byte(&s->stream_ptr);

180

181 av_dlog(s->avctx, "motion bytes = %d, %d\n", x, y);

182 return copy_from(s, s->last_frame, frame, x, y);

183 }

184

185 static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s, AVFrame *frame)

186 {

187 /* mystery opcode? skip multiple blocks? */

188 av_log(s->avctx, AV_LOG_ERROR, "Help! Mystery opcode 0x6 seen\n");

189

190 /* report success */

191 return 0;

192 }

193

194 static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s, AVFrame *frame)

195 {

196 int x, y;

197 unsigned char P[2];

198 unsigned int flags;

199

200 if (bytestream2_get_bytes_left(&s->stream_ptr) < 4) {

201 av_log(s->avctx, AV_LOG_ERROR, "too little data for opcode 0x7\n");

202 return AVERROR_INVALIDDATA;

203 }

204

205 /* 2-color encoding */

206 P[0] = bytestream2_get_byte(&s->stream_ptr);

207 P[1] = bytestream2_get_byte(&s->stream_ptr);

208

209 if (P[0] <= P[1]) {

210

211 /* need 8 more bytes from the stream */

212 for (y = 0; y < 8; y++) {

213 flags = bytestream2_get_byte(&s->stream_ptr) | 0x100;

214 for (; flags != 1; flags >>= 1)

215 *s->pixel_ptr++ = P[flags & 1];

216 s->pixel_ptr += s->line_inc;

217 }

218

219 } else {

220

221 /* need 2 more bytes from the stream */

222 flags = bytestream2_get_le16(&s->stream_ptr);

223 for (y = 0; y < 8; y += 2) {

224 for (x = 0; x < 8; x += 2, flags >>= 1) {

225 s->pixel_ptr[x ] =

226 s->pixel_ptr[x + 1 ] =

227 s->pixel_ptr[x + s->stride] =

228 s->pixel_ptr[x + 1 + s->stride] = P[flags & 1];

229 }

230 s->pixel_ptr += s->stride * 2;

231 }

232 }

233

234 /* report success */

235 return 0;

236 }

237

238 static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s, AVFrame *frame)

239 {

240 int x, y;

241 unsigned char P[4];

242 unsigned int flags = 0;

243

244 if (bytestream2_get_bytes_left(&s->stream_ptr) < 12) {

245 av_log(s->avctx, AV_LOG_ERROR, "too little data for opcode 0x8\n");

246 return AVERROR_INVALIDDATA;

247 }

248

249 /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on

250 * either top and bottom or left and right halves */

251 P[0] = bytestream2_get_byte(&s->stream_ptr);

252 P[1] = bytestream2_get_byte(&s->stream_ptr);

253

254 if (P[0] <= P[1]) {

255 for (y = 0; y < 16; y++) {

256 // new values for each 4x4 block

257 if (!(y & 3)) {

258 if (y) {

259 P[0] = bytestream2_get_byte(&s->stream_ptr);

260 P[1] = bytestream2_get_byte(&s->stream_ptr);

261 }

262 flags = bytestream2_get_le16(&s->stream_ptr);

263 }

264

265 for (x = 0; x < 4; x++, flags >>= 1)

266 *s->pixel_ptr++ = P[flags & 1];

267 s->pixel_ptr += s->stride - 4;

268 // switch to right half

269 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;

270 }

271

272 } else {

273 flags = bytestream2_get_le32(&s->stream_ptr);

274 P[2] = bytestream2_get_byte(&s->stream_ptr);

275 P[3] = bytestream2_get_byte(&s->stream_ptr);

276

277 if (P[2] <= P[3]) {

278

279 /* vertical split; left & right halves are 2-color encoded */

280

281 for (y = 0; y < 16; y++) {

282 for (x = 0; x < 4; x++, flags >>= 1)

283 *s->pixel_ptr++ = P[flags & 1];

284 s->pixel_ptr += s->stride - 4;

285 // switch to right half

286 if (y == 7) {

287 s->pixel_ptr -= 8 * s->stride - 4;

288 P[0] = P[2];

289 P[1] = P[3];

290 flags = bytestream2_get_le32(&s->stream_ptr);

291 }

292 }

293

294 } else {

295

296 /* horizontal split; top & bottom halves are 2-color encoded */

297

298 for (y = 0; y < 8; y++) {

299 if (y == 4) {

300 P[0] = P[2];

301 P[1] = P[3];

302 flags = bytestream2_get_le32(&s->stream_ptr);

303 }

304

305 for (x = 0; x < 8; x++, flags >>= 1)

306 *s->pixel_ptr++ = P[flags & 1];

307 s->pixel_ptr += s->line_inc;

308 }

309 }

310 }

311

312 /* report success */

313 return 0;

314 }

315

316 static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s, AVFrame *frame)

317 {

318 int x, y;

319 unsigned char P[4];

320

321 if (bytestream2_get_bytes_left(&s->stream_ptr) < 8) {

322 av_log(s->avctx, AV_LOG_ERROR, "too little data for opcode 0x9\n");

323 return AVERROR_INVALIDDATA;

324 }

325

326 /* 4-color encoding */

327 bytestream2_get_buffer(&s->stream_ptr, P, 4);

328

329 if (P[0] <= P[1]) {

330 if (P[2] <= P[3]) {

331

332 /* 1 of 4 colors for each pixel, need 16 more bytes */

333 for (y = 0; y < 8; y++) {

334 /* get the next set of 8 2-bit flags */

335 int flags = bytestream2_get_le16(&s->stream_ptr);

336 for (x = 0; x < 8; x++, flags >>= 2)

337 *s->pixel_ptr++ = P[flags & 0x03];

338 s->pixel_ptr += s->line_inc;

339 }

340

341 } else {

342 uint32_t flags;

343

344 /* 1 of 4 colors for each 2x2 block, need 4 more bytes */

345 flags = bytestream2_get_le32(&s->stream_ptr);

346

347 for (y = 0; y < 8; y += 2) {

348 for (x = 0; x < 8; x += 2, flags >>= 2) {

349 s->pixel_ptr[x ] =

350 s->pixel_ptr[x + 1 ] =

351 s->pixel_ptr[x + s->stride] =

352 s->pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];

353 }

354 s->pixel_ptr += s->stride * 2;

355 }

356

357 }

358 } else {

359 uint64_t flags;

360

361 /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */

362 flags = bytestream2_get_le64(&s->stream_ptr);

363 if (P[2] <= P[3]) {

364 for (y = 0; y < 8; y++) {

365 for (x = 0; x < 8; x += 2, flags >>= 2) {

366 s->pixel_ptr[x ] =

367 s->pixel_ptr[x + 1] = P[flags & 0x03];

368 }

369 s->pixel_ptr += s->stride;

370 }

371 } else {

372 for (y = 0; y < 8; y += 2) {

373 for (x = 0; x < 8; x++, flags >>= 2) {

374 s->pixel_ptr[x ] =

375 s->pixel_ptr[x + s->stride] = P[flags & 0x03];

376 }

377 s->pixel_ptr += s->stride * 2;

378 }

379 }

380 }

381

382 /* report success */

383 return 0;

384 }

385

386 static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s, AVFrame *frame)

387 {

388 int x, y;

389 unsigned char P[8];

390 int flags = 0;

391

392 if (bytestream2_get_bytes_left(&s->stream_ptr) < 16) {

393 av_log(s->avctx, AV_LOG_ERROR, "too little data for opcode 0xA\n");

394 return AVERROR_INVALIDDATA;

395 }

396

397 bytestream2_get_buffer(&s->stream_ptr, P, 4);

398

399 /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on

400 * either top and bottom or left and right halves */

401 if (P[0] <= P[1]) {

402

403 /* 4-color encoding for each quadrant; need 32 bytes */

404 for (y = 0; y < 16; y++) {

405 // new values for each 4x4 block

406 if (!(y & 3)) {

407 if (y) bytestream2_get_buffer(&s->stream_ptr, P, 4);

408 flags = bytestream2_get_le32(&s->stream_ptr);

409 }

410

411 for (x = 0; x < 4; x++, flags >>= 2)

412 *s->pixel_ptr++ = P[flags & 0x03];

413

414 s->pixel_ptr += s->stride - 4;

415 // switch to right half

416 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;

417 }

418

419 } else {

420 // vertical split?

421 int vert;

422 uint64_t flags = bytestream2_get_le64(&s->stream_ptr);

423

424 bytestream2_get_buffer(&s->stream_ptr, P + 4, 4);

425 vert = P[4] <= P[5];

426

427 /* 4-color encoding for either left and right or top and bottom

428 * halves */

429

430 for (y = 0; y < 16; y++) {

431 for (x = 0; x < 4; x++, flags >>= 2)

432 *s->pixel_ptr++ = P[flags & 0x03];

433

434 if (vert) {

435 s->pixel_ptr += s->stride - 4;

436 // switch to right half

437 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;

438 } else if (y & 1) s->pixel_ptr += s->line_inc;

439

440 // load values for second half

441 if (y == 7) {

442 memcpy(P, P + 4, 4);

443 flags = bytestream2_get_le64(&s->stream_ptr);

444 }

445 }

446 }

447

448 /* report success */

449 return 0;

450 }

451

452 static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s, AVFrame *frame)

453 {

454 int y;

455

456 /* 64-color encoding (each pixel in block is a different color) */

457 for (y = 0; y < 8; y++) {

458 bytestream2_get_buffer(&s->stream_ptr, s->pixel_ptr, 8);

459 s->pixel_ptr += s->stride;

460 }

461

462 /* report success */

463 return 0;

464 }

465

466 static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s, AVFrame *frame)

467 {

468 int x, y;

469

470 /* 16-color block encoding: each 2x2 block is a different color */

471 for (y = 0; y < 8; y += 2) {

472 for (x = 0; x < 8; x += 2) {

473 s->pixel_ptr[x ] =

474 s->pixel_ptr[x + 1 ] =

475 s->pixel_ptr[x + s->stride] =

476 s->pixel_ptr[x + 1 + s->stride] = bytestream2_get_byte(&s->stream_ptr);

477 }

478 s->pixel_ptr += s->stride * 2;

479 }

480

481 /* report success */

482 return 0;

483 }

484

485 static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s, AVFrame *frame)

486 {

487 int y;

488 unsigned char P[2];

489

490 if (bytestream2_get_bytes_left(&s->stream_ptr) < 4) {

491 av_log(s->avctx, AV_LOG_ERROR, "too little data for opcode 0xD\n");

492 return AVERROR_INVALIDDATA;

493 }

494

495 /* 4-color block encoding: each 4x4 block is a different color */

496 for (y = 0; y < 8; y++) {

497 if (!(y & 3)) {

498 P[0] = bytestream2_get_byte(&s->stream_ptr);

499 P[1] = bytestream2_get_byte(&s->stream_ptr);

500 }

501 memset(s->pixel_ptr, P[0], 4);

502 memset(s->pixel_ptr + 4, P[1], 4);

503 s->pixel_ptr += s->stride;

504 }

505

506 /* report success */

507 return 0;

508 }

509

510 static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s, AVFrame *frame)

511 {

512 int y;

513 unsigned char pix;

514

515 /* 1-color encoding: the whole block is 1 solid color */

516 pix = bytestream2_get_byte(&s->stream_ptr);

517

518 for (y = 0; y < 8; y++) {

519 memset(s->pixel_ptr, pix, 8);

520 s->pixel_ptr += s->stride;

521 }

522

523 /* report success */

524 return 0;

525 }

526

527 static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s, AVFrame *frame)

528 {

529 int x, y;

530 unsigned char sample[2];

531

532 /* dithered encoding */

533 sample[0] = bytestream2_get_byte(&s->stream_ptr);

534 sample[1] = bytestream2_get_byte(&s->stream_ptr);

535

536 for (y = 0; y < 8; y++) {

537 for (x = 0; x < 8; x += 2) {

538 *s->pixel_ptr++ = sample[ y & 1 ];

539 *s->pixel_ptr++ = sample[!(y & 1)];

540 }

541 s->pixel_ptr += s->line_inc;

542 }

543

544 /* report success */

545 return 0;

546 }

547

548 static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext *s, AVFrame *frame)

549 {

550 signed char x, y;

551

552 /* copy a block from the second last frame using an expanded range */

553 x = bytestream2_get_byte(&s->stream_ptr);

554 y = bytestream2_get_byte(&s->stream_ptr);

555

556 av_dlog(s->avctx, "motion bytes = %d, %d\n", x, y);

557 return copy_from(s, s->second_last_frame, frame, x, y);

558 }

559

560 static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s, AVFrame *frame)

561 {

562 int x, y;

563 uint16_t P[2];

564 unsigned int flags;

565 uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

566

567 /* 2-color encoding */

568 P[0] = bytestream2_get_le16(&s->stream_ptr);

569 P[1] = bytestream2_get_le16(&s->stream_ptr);

570

571 if (!(P[0] & 0x8000)) {

572

573 for (y = 0; y < 8; y++) {

574 flags = bytestream2_get_byte(&s->stream_ptr) | 0x100;

575 for (; flags != 1; flags >>= 1)

576 *pixel_ptr++ = P[flags & 1];

577 pixel_ptr += s->line_inc;

578 }

579

580 } else {

581

582 flags = bytestream2_get_le16(&s->stream_ptr);

583 for (y = 0; y < 8; y += 2) {

584 for (x = 0; x < 8; x += 2, flags >>= 1) {

585 pixel_ptr[x ] =

586 pixel_ptr[x + 1 ] =

587 pixel_ptr[x + s->stride] =

588 pixel_ptr[x + 1 + s->stride] = P[flags & 1];

589 }

590 pixel_ptr += s->stride * 2;

591 }

592 }

593

594 return 0;

595 }

596

597 static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s, AVFrame *frame)

598 {

599 int x, y;

600 uint16_t P[4];

601 unsigned int flags = 0;

602 uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

603

604 /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on

605 * either top and bottom or left and right halves */

606 P[0] = bytestream2_get_le16(&s->stream_ptr);

607 P[1] = bytestream2_get_le16(&s->stream_ptr);

608

609 if (!(P[0] & 0x8000)) {

610

611 for (y = 0; y < 16; y++) {

612 // new values for each 4x4 block

613 if (!(y & 3)) {

614 if (y) {

615 P[0] = bytestream2_get_le16(&s->stream_ptr);

616 P[1] = bytestream2_get_le16(&s->stream_ptr);

617 }

618 flags = bytestream2_get_le16(&s->stream_ptr);

619 }

620

621 for (x = 0; x < 4; x++, flags >>= 1)

622 *pixel_ptr++ = P[flags & 1];

623 pixel_ptr += s->stride - 4;

624 // switch to right half

625 if (y == 7) pixel_ptr -= 8 * s->stride - 4;

626 }

627

628 } else {

629

630 flags = bytestream2_get_le32(&s->stream_ptr);

631 P[2] = bytestream2_get_le16(&s->stream_ptr);

632 P[3] = bytestream2_get_le16(&s->stream_ptr);

633

634 if (!(P[2] & 0x8000)) {

635

636 /* vertical split; left & right halves are 2-color encoded */

637

638 for (y = 0; y < 16; y++) {

639 for (x = 0; x < 4; x++, flags >>= 1)

640 *pixel_ptr++ = P[flags & 1];

641 pixel_ptr += s->stride - 4;

642 // switch to right half

643 if (y == 7) {

644 pixel_ptr -= 8 * s->stride - 4;

645 P[0] = P[2];

646 P[1] = P[3];

647 flags = bytestream2_get_le32(&s->stream_ptr);

648 }

649 }

650

651 } else {

652

653 /* horizontal split; top & bottom halves are 2-color encoded */

654

655 for (y = 0; y < 8; y++) {

656 if (y == 4) {

657 P[0] = P[2];

658 P[1] = P[3];

659 flags = bytestream2_get_le32(&s->stream_ptr);

660 }

661

662 for (x = 0; x < 8; x++, flags >>= 1)

663 *pixel_ptr++ = P[flags & 1];

664 pixel_ptr += s->line_inc;

665 }

666 }

667 }

668

669 /* report success */

670 return 0;

671 }

672

673 static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s, AVFrame *frame)

674 {

675 int x, y;

676 uint16_t P[4];

677 uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

678

679 /* 4-color encoding */

680 for (x = 0; x < 4; x++)

681 P[x] = bytestream2_get_le16(&s->stream_ptr);

682

683 if (!(P[0] & 0x8000)) {

684 if (!(P[2] & 0x8000)) {

685

686 /* 1 of 4 colors for each pixel */

687 for (y = 0; y < 8; y++) {

688 /* get the next set of 8 2-bit flags */

689 int flags = bytestream2_get_le16(&s->stream_ptr);

690 for (x = 0; x < 8; x++, flags >>= 2)

691 *pixel_ptr++ = P[flags & 0x03];

692 pixel_ptr += s->line_inc;

693 }

694

695 } else {

696 uint32_t flags;

697

698 /* 1 of 4 colors for each 2x2 block */

699 flags = bytestream2_get_le32(&s->stream_ptr);

700

701 for (y = 0; y < 8; y += 2) {

702 for (x = 0; x < 8; x += 2, flags >>= 2) {

703 pixel_ptr[x ] =

704 pixel_ptr[x + 1 ] =

705 pixel_ptr[x + s->stride] =

706 pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];

707 }

708 pixel_ptr += s->stride * 2;

709 }

710

711 }

712 } else {

713 uint64_t flags;

714

715 /* 1 of 4 colors for each 2x1 or 1x2 block */

716 flags = bytestream2_get_le64(&s->stream_ptr);

717 if (!(P[2] & 0x8000)) {

718 for (y = 0; y < 8; y++) {

719 for (x = 0; x < 8; x += 2, flags >>= 2) {

720 pixel_ptr[x ] =

721 pixel_ptr[x + 1] = P[flags & 0x03];

722 }

723 pixel_ptr += s->stride;

724 }

725 } else {

726 for (y = 0; y < 8; y += 2) {

727 for (x = 0; x < 8; x++, flags >>= 2) {

728 pixel_ptr[x ] =

729 pixel_ptr[x + s->stride] = P[flags & 0x03];

730 }

731 pixel_ptr += s->stride * 2;

732 }

733 }

734 }

735

736 /* report success */

737 return 0;

738 }

739

740 static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s, AVFrame *frame)

741 {

742 int x, y;

743 uint16_t P[8];

744 int flags = 0;

745 uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

746

747 for (x = 0; x < 4; x++)

748 P[x] = bytestream2_get_le16(&s->stream_ptr);

749

750 /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on

751 * either top and bottom or left and right halves */

752 if (!(P[0] & 0x8000)) {

753

754 /* 4-color encoding for each quadrant */

755 for (y = 0; y < 16; y++) {

756 // new values for each 4x4 block

757 if (!(y & 3)) {

758 if (y)

759 for (x = 0; x < 4; x++)

760 P[x] = bytestream2_get_le16(&s->stream_ptr);

761 flags = bytestream2_get_le32(&s->stream_ptr);

762 }

763

764 for (x = 0; x < 4; x++, flags >>= 2)

765 *pixel_ptr++ = P[flags & 0x03];

766

767 pixel_ptr += s->stride - 4;

768 // switch to right half

769 if (y == 7) pixel_ptr -= 8 * s->stride - 4;

770 }

771

772 } else {

773 // vertical split?

774 int vert;

775 uint64_t flags = bytestream2_get_le64(&s->stream_ptr);

776

777 for (x = 4; x < 8; x++)

778 P[x] = bytestream2_get_le16(&s->stream_ptr);

779 vert = !(P[4] & 0x8000);

780

781 /* 4-color encoding for either left and right or top and bottom

782 * halves */

783

784 for (y = 0; y < 16; y++) {

785 for (x = 0; x < 4; x++, flags >>= 2)

786 *pixel_ptr++ = P[flags & 0x03];

787

788 if (vert) {

789 pixel_ptr += s->stride - 4;

790 // switch to right half

791 if (y == 7) pixel_ptr -= 8 * s->stride - 4;

792 } else if (y & 1) pixel_ptr += s->line_inc;

793

794 // load values for second half

795 if (y == 7) {

796 memcpy(P, P + 4, 8);

797 flags = bytestream2_get_le64(&s->stream_ptr);

798 }

799 }

800 }

801

802 /* report success */

803 return 0;

804 }

805

806 static int ipvideo_decode_block_opcode_0xB_16(IpvideoContext *s, AVFrame *frame)

807 {

808 int x, y;

809 uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

810

811 /* 64-color encoding (each pixel in block is a different color) */

812 for (y = 0; y < 8; y++) {

813 for (x = 0; x < 8; x++)

814 pixel_ptr[x] = bytestream2_get_le16(&s->stream_ptr);

815 pixel_ptr += s->stride;

816 }

817

818 /* report success */

819 return 0;

820 }

821

822 static int ipvideo_decode_block_opcode_0xC_16(IpvideoContext *s, AVFrame *frame)

823 {

824 int x, y;

825 uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

826

827 /* 16-color block encoding: each 2x2 block is a different color */

828 for (y = 0; y < 8; y += 2) {

829 for (x = 0; x < 8; x += 2) {

830 pixel_ptr[x ] =

831 pixel_ptr[x + 1 ] =

832 pixel_ptr[x + s->stride] =

833 pixel_ptr[x + 1 + s->stride] = bytestream2_get_le16(&s->stream_ptr);

834 }

835 pixel_ptr += s->stride * 2;

836 }

837

838 /* report success */

839 return 0;

840 }

841

842 static int ipvideo_decode_block_opcode_0xD_16(IpvideoContext *s, AVFrame *frame)

843 {

844 int x, y;

845 uint16_t P[2];

846 uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

847

848 /* 4-color block encoding: each 4x4 block is a different color */

849 for (y = 0; y < 8; y++) {

850 if (!(y & 3)) {

851 P[0] = bytestream2_get_le16(&s->stream_ptr);

852 P[1] = bytestream2_get_le16(&s->stream_ptr);

853 }

854 for (x = 0; x < 8; x++)

855 pixel_ptr[x] = P[x >> 2];

856 pixel_ptr += s->stride;

857 }

858

859 /* report success */

860 return 0;

861 }

862

863 static int ipvideo_decode_block_opcode_0xE_16(IpvideoContext *s, AVFrame *frame)

864 {

865 int x, y;

866 uint16_t pix;

867 uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

868

869 /* 1-color encoding: the whole block is 1 solid color */

870 pix = bytestream2_get_le16(&s->stream_ptr);

871

872 for (y = 0; y < 8; y++) {

873 for (x = 0; x < 8; x++)

874 pixel_ptr[x] = pix;

875 pixel_ptr += s->stride;

876 }

877

878 /* report success */

879 return 0;

880 }

881

882 static int (* const ipvideo_decode_block[])(IpvideoContext *s, AVFrame *frame) = {

883 ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1,

884 ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3,

885 ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5,

886 ipvideo_decode_block_opcode_0x6, ipvideo_decode_block_opcode_0x7,

887 ipvideo_decode_block_opcode_0x8, ipvideo_decode_block_opcode_0x9,

888 ipvideo_decode_block_opcode_0xA, ipvideo_decode_block_opcode_0xB,

889 ipvideo_decode_block_opcode_0xC, ipvideo_decode_block_opcode_0xD,

890 ipvideo_decode_block_opcode_0xE, ipvideo_decode_block_opcode_0xF,

891 };

892

893 static int (* const ipvideo_decode_block16[])(IpvideoContext *s, AVFrame *frame) = {

894 ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1,

895 ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3,

896 ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5,

897 ipvideo_decode_block_opcode_0x6_16, ipvideo_decode_block_opcode_0x7_16,

898 ipvideo_decode_block_opcode_0x8_16, ipvideo_decode_block_opcode_0x9_16,

899 ipvideo_decode_block_opcode_0xA_16, ipvideo_decode_block_opcode_0xB_16,

900 ipvideo_decode_block_opcode_0xC_16, ipvideo_decode_block_opcode_0xD_16,

901 ipvideo_decode_block_opcode_0xE_16, ipvideo_decode_block_opcode_0x1,

902 };

903

904 static void ipvideo_decode_opcodes(IpvideoContext *s, AVFrame *frame)

905 {

906 int x, y;

907 unsigned char opcode;

908 int ret;

909 GetBitContext gb;

910

911 bytestream2_skip(&s->stream_ptr, 14); /* data starts 14 bytes in */

912 if (!s->is_16bpp) {

913 /* this is PAL8, so make the palette available */

914 memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);

915

916 s->stride = frame->linesize[0];

917 } else {

918 s->stride = frame->linesize[0] >> 1;

919 s->mv_ptr = s->stream_ptr;

920 bytestream2_skip(&s->mv_ptr, bytestream2_get_le16(&s->stream_ptr));

921 }

922 s->line_inc = s->stride - 8;

923 s->upper_motion_limit_offset = (s->avctx->height - 8) * frame->linesize[0]

924 + (s->avctx->width - 8) * (1 + s->is_16bpp);

925

926 init_get_bits(&gb, s->decoding_map, s->decoding_map_size * 8);

927 for (y = 0; y < s->avctx->height; y += 8) {

928 for (x = 0; x < s->avctx->width; x += 8) {

929 opcode = get_bits(&gb, 4);

930

931 av_dlog(s->avctx,

932 " block @ (%3d, %3d): encoding 0x%X, data ptr offset %d\n",

933 x, y, opcode, bytestream2_tell(&s->stream_ptr));

934

935 if (!s->is_16bpp) {

936 s->pixel_ptr = frame->data[0] + x

937 + y*frame->linesize[0];

938 ret = ipvideo_decode_block[opcode](s, frame);

939 } else {

940 s->pixel_ptr = frame->data[0] + x*2

941 + y*frame->linesize[0];

942 ret = ipvideo_decode_block16[opcode](s, frame);

943 }

944 if (ret != 0) {

945 av_log(s->avctx, AV_LOG_ERROR, "decode problem on frame %d, @ block (%d, %d)\n",

946 s->avctx->frame_number, x, y);

947 return;

948 }

949 }

950 }

951 if (bytestream2_get_bytes_left(&s->stream_ptr) > 1) {

952 av_log(s->avctx, AV_LOG_ERROR,

953 "decode finished with %d bytes left over\n",

954 bytestream2_get_bytes_left(&s->stream_ptr));

955 }

956 }

957

958 static av_cold int ipvideo_decode_init(AVCodecContext *avctx)

959 {

960 IpvideoContext *s = avctx->priv_data;

961

962 s->avctx = avctx;

963

964 s->is_16bpp = avctx->bits_per_coded_sample == 16;

965 avctx->pix_fmt = s->is_16bpp ? AV_PIX_FMT_RGB555 : AV_PIX_FMT_PAL8;

966

967 ff_hpeldsp_init(&s->hdsp, avctx->flags);

968

969 s->last_frame = av_frame_alloc();

970 s->second_last_frame = av_frame_alloc();

971 if (!s->last_frame || !s->second_last_frame) {

972 av_frame_free(&s->last_frame);

973 av_frame_free(&s->second_last_frame);

974 return AVERROR(ENOMEM);

975 }

976

977 return 0;

978 }

979

980 static int ipvideo_decode_frame(AVCodecContext *avctx,

981 void *data, int *got_frame,

982 AVPacket *avpkt)

983 {

984 const uint8_t *buf = avpkt->data;

985 int buf_size = avpkt->size;

986 IpvideoContext *s = avctx->priv_data;

987 AVFrame *frame = data;

988 int ret;

989

990 /* decoding map contains 4 bits of information per 8x8 block */

991 s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2);

992

993 /* compressed buffer needs to be large enough to at least hold an entire

994 * decoding map */

995 if (buf_size < s->decoding_map_size)

996 return buf_size;

997

998 if (av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, NULL)) {

999 av_frame_unref(s->last_frame);

1000 av_frame_unref(s->second_last_frame);

1001 }

1002

1003 s->decoding_map = buf;

1004 bytestream2_init(&s->stream_ptr, buf + s->decoding_map_size,

1005 buf_size - s->decoding_map_size);

1006

1007 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)

1008 return ret;

1009

1010 if (!s->is_16bpp) {

1011 const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);

1012 if (pal) {

1013 frame->palette_has_changed = 1;

1014 memcpy(s->pal, pal, AVPALETTE_SIZE);

1015 }

1016 }

1017

1018 ipvideo_decode_opcodes(s, frame);

1019

1020 *got_frame = 1;

1021

1022 /* shuffle frames */

1023 av_frame_unref(s->second_last_frame);

1024 FFSWAP(AVFrame*, s->second_last_frame, s->last_frame);

1025 if ((ret = av_frame_ref(s->last_frame, frame)) < 0)

1026 return ret;

1027

1028 /* report that the buffer was completely consumed */

1029 return buf_size;

1030 }

1031

1032 static av_cold int ipvideo_decode_end(AVCodecContext *avctx)

1033 {

1034 IpvideoContext *s = avctx->priv_data;

1035

1036 av_frame_free(&s->last_frame);

1037 av_frame_free(&s->second_last_frame);

1038

1039 return 0;

1040 }

1041

1042 AVCodec ff_interplay_video_decoder = {

1043 .name = "interplayvideo",

1044 .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"),

1045 .type = AVMEDIA_TYPE_VIDEO,

1046 .id = AV_CODEC_ID_INTERPLAY_VIDEO,

1047 .priv_data_size = sizeof(IpvideoContext),

1048 .init = ipvideo_decode_init,

1049 .close = ipvideo_decode_end,

1050 .decode = ipvideo_decode_frame,

1051 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_PARAM_CHANGE,

1052 };

Generated on Sun Mar 8 2015 02:34:54 for FFmpeg by doxygen 1.8.2