FFmpeg: libavcodec/mss2.c Source File

FFmpeg

[フレーム]

libavcodec

mss2.c

Go to the documentation of this file.

1 /*

2 * Microsoft Screen 2 (aka Windows Media Video V9 Screen) decoder

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

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

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

14 * Lesser General Public License for more details.

15 *

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

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 /**

22 * @file

23 * Microsoft Screen 2 (aka Windows Media Video V9 Screen) decoder

24 */

26 #include "libavutil/avassert.h"

27 #include "internal.h"

28 #include "msmpeg4data.h"

29 #include "vc1.h"

30 #include "mss12.h"

31 #include "mss2dsp.h"

33 typedef struct MSS2Context {

34 VC1Context v;

35 int split_position;

36 AVFrame pic;

37 AVFrame last_pic;

38 MSS12Context c;

39 MSS2DSPContext dsp;

40 SliceContext sc[2];

41 } MSS2Context;

43 static void arith2_normalise(ArithCoder *c)

44 {

45 while ((c->high >> 15) - (c->low >> 15) < 2) {

46 if ((c->low ^ c->high) & 0x10000) {

47 c->high ^= 0x8000;

48 c->value ^= 0x8000;

49 c->low ^= 0x8000;

50 }

51 c->high = c->high << 8 & 0xFFFFFF | 0xFF;

52 c->value = c->value << 8 & 0xFFFFFF | bytestream2_get_byte(c->gbc.gB);

53 c->low = c->low << 8 & 0xFFFFFF;

54 }

55 }

57 ARITH_GET_BIT(2)

59 /* L. Stuiver and A. Moffat: "Piecewise Integer Mapping for Arithmetic Coding."

60 * In Proc. 8th Data Compression Conference (DCC '98), pp. 3-12, Mar. 1998 */

62 static int arith2_get_scaled_value(int value, int n, int range)

63 {

64 int split = (n << 1) - range;

66 if (value > split)

67 return split + (value - split >> 1);

68 else

69 return value;

70 }

72 static void arith2_rescale_interval(ArithCoder *c, int range,

73 int low, int high, int n)

74 {

75 int split = (n << 1) - range;

77 if (high > split)

78 c->high = split + (high - split << 1);

79 else

80 c->high = high;

82 c->high += c->low - 1;

84 if (low > split)

85 c->low += split + (low - split << 1);

86 else

87 c->low += low;

88 }

90 static int arith2_get_number(ArithCoder *c, int n)

91 {

92 int range = c->high - c->low + 1;

93 int scale = av_log2(range) - av_log2(n);

94 int val;

96 if (n << scale > range)

97 scale--;

99 n <<= scale;

100

101 val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale;

102

103 arith2_rescale_interval(c, range, val << scale, (val + 1) << scale, n);

104

105 arith2_normalise(c);

106

107 return val;

108 }

109

110 static int arith2_get_prob(ArithCoder *c, int16_t *probs)

111 {

112 int range = c->high - c->low + 1, n = *probs;

113 int scale = av_log2(range) - av_log2(n);

114 int i = 0, val;

115

116 if (n << scale > range)

117 scale--;

118

119 n <<= scale;

120

121 val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale;

122 while (probs[++i] > val) ;

123

124 arith2_rescale_interval(c, range,

125 probs[i] << scale, probs[i - 1] << scale, n);

126

127 return i;

128 }

129

130 ARITH_GET_MODEL_SYM(2)

131

132 static int arith2_get_consumed_bytes(ArithCoder *c)

133 {

134 int diff = (c->high >> 16) - (c->low >> 16);

135 int bp = bytestream2_tell(c->gbc.gB) - 3 << 3;

136 int bits = 1;

137

138 while (!(diff & 0x80)) {

139 bits++;

140 diff <<= 1;

141 }

142

143 return (bits + bp + 7 >> 3) + ((c->low >> 16) + 1 == c->high >> 16);

144 }

145

146 static void arith2_init(ArithCoder *c, GetByteContext *gB)

147 {

148 c->low = 0;

149 c->high = 0xFFFFFF;

150 c->value = bytestream2_get_be24(gB);

151 c->gbc.gB = gB;

152 c->get_model_sym = arith2_get_model_sym;

153 c->get_number = arith2_get_number;

154 }

155

156 static int decode_pal_v2(MSS12Context *ctx, const uint8_t *buf, int buf_size)

157 {

158 int i, ncol;

159 uint32_t *pal = ctx->pal + 256 - ctx->free_colours;

160

161 if (!ctx->free_colours)

162 return 0;

163

164 ncol = *buf++;

165 if (ncol > ctx->free_colours || buf_size < 2 + ncol * 3)

166 return -1;

167 for (i = 0; i < ncol; i++)

168 *pal++ = AV_RB24(buf + 3 * i);

169

170 return 1 + ncol * 3;

171 }

172

173 static int decode_555(GetByteContext *gB, uint16_t *dst, int stride,

174 int keyframe, int w, int h)

175 {

176 int last_symbol = 0, repeat = 0, prev_avail = 0;

177

178 if (!keyframe) {

179 int x, y, endx, endy, t;

180

181 #define READ_PAIR(a, b) \

182 a = bytestream2_get_byte(gB) << 4; \

183 t = bytestream2_get_byte(gB); \

184 a |= t >> 4; \

185 b = (t & 0xF) << 8; \

186 b |= bytestream2_get_byte(gB); \

187

188 READ_PAIR(x, endx)

189 READ_PAIR(y, endy)

190

191 if (endx >= w || endy >= h || x > endx || y > endy)

192 return -1;

193 dst += x + stride * y;

194 w = endx - x + 1;

195 h = endy - y + 1;

196 if (y)

197 prev_avail = 1;

198 }

199

200 do {

201 uint16_t *p = dst;

202 do {

203 if (repeat-- < 1) {

204 int b = bytestream2_get_byte(gB);

205 if (b < 128)

206 last_symbol = b << 8 | bytestream2_get_byte(gB);

207 else if (b > 129) {

208 repeat = 0;

209 while (b-- > 130)

210 repeat = (repeat << 8) + bytestream2_get_byte(gB) + 1;

211 if (last_symbol == -2) {

212 int skip = FFMIN((unsigned)repeat, dst + w - p);

213 repeat -= skip;

214 p += skip;

215 }

216 } else

217 last_symbol = 127 - b;

218 }

219 if (last_symbol >= 0)

220 *p = last_symbol;

221 else if (last_symbol == -1 && prev_avail)

222 *p = *(p - stride);

223 } while (++p < dst + w);

224 dst += stride;

225 prev_avail = 1;

226 } while (--h);

227

228 return 0;

229 }

230

231 static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, int pal_stride,

232 uint8_t *rgb_dst, int rgb_stride, uint32_t *pal,

233 int keyframe, int kf_slipt, int slice, int w, int h)

234 {

235 uint8_t bits[270] = { 0 };

236 uint32_t codes[270];

237 VLC vlc;

238

239 int current_length = 0, read_codes = 0, next_code = 0, current_codes = 0;

240 int remaining_codes, surplus_codes, i;

241

242 const int alphabet_size = 270 - keyframe;

243

244 int last_symbol = 0, repeat = 0, prev_avail = 0;

245

246 if (!keyframe) {

247 int x, y, clipw, cliph;

248

249 x = get_bits(gb, 12);

250 y = get_bits(gb, 12);

251 clipw = get_bits(gb, 12) + 1;

252 cliph = get_bits(gb, 12) + 1;

253

254 if (x + clipw > w || y + cliph > h)

255 return AVERROR_INVALIDDATA;

256 pal_dst += pal_stride * y + x;

257 rgb_dst += rgb_stride * y + x * 3;

258 w = clipw;

259 h = cliph;

260 if (y)

261 prev_avail = 1;

262 } else {

263 if (slice > 0) {

264 pal_dst += pal_stride * kf_slipt;

265 rgb_dst += rgb_stride * kf_slipt;

266 prev_avail = 1;

267 h -= kf_slipt;

268 } else

269 h = kf_slipt;

270 }

271

272 /* read explicit codes */

273 do {

274 while (current_codes--) {

275 int symbol = get_bits(gb, 8);

276 if (symbol >= 204 - keyframe)

277 symbol += 14 - keyframe;

278 else if (symbol > 189)

279 symbol = get_bits1(gb) + (symbol << 1) - 190;

280 if (bits[symbol])

281 return AVERROR_INVALIDDATA;

282 bits[symbol] = current_length;

283 codes[symbol] = next_code++;

284 read_codes++;

285 }

286 current_length++;

287 next_code <<= 1;

288 remaining_codes = (1 << current_length) - next_code;

289 current_codes = get_bits(gb, av_ceil_log2(remaining_codes + 1));

290 if (current_length > 22 || current_codes > remaining_codes)

291 return AVERROR_INVALIDDATA;

292 } while (current_codes != remaining_codes);

293

294 remaining_codes = alphabet_size - read_codes;

295

296 /* determine the minimum length to fit the rest of the alphabet */

297 while ((surplus_codes = (2 << current_length) -

298 (next_code << 1) - remaining_codes) < 0) {

299 current_length++;

300 next_code <<= 1;

301 }

302

303 /* add the rest of the symbols lexicographically */

304 for (i = 0; i < alphabet_size; i++)

305 if (!bits[i]) {

306 if (surplus_codes-- == 0) {

307 current_length++;

308 next_code <<= 1;

309 }

310 bits[i] = current_length;

311 codes[i] = next_code++;

312 }

313

314 if (next_code != 1 << current_length)

315 return AVERROR_INVALIDDATA;

316

317 if (i = init_vlc(&vlc, 9, alphabet_size, bits, 1, 1, codes, 4, 4, 0))

318 return i;

319

320 /* frame decode */

321 do {

322 uint8_t *pp = pal_dst;

323 uint8_t *rp = rgb_dst;

324 do {

325 if (repeat-- < 1) {

326 int b = get_vlc2(gb, vlc.table, 9, 3);

327 if (b < 256)

328 last_symbol = b;

329 else if (b < 268) {

330 b -= 256;

331 if (b == 11)

332 b = get_bits(gb, 4) + 10;

333

334 if (!b)

335 repeat = 0;

336 else

337 repeat = get_bits(gb, b);

338

339 repeat += (1 << b) - 1;

340

341 if (last_symbol == -2) {

342 int skip = FFMIN(repeat, pal_dst + w - pp);

343 repeat -= skip;

344 pp += skip;

345 rp += skip * 3;

346 }

347 } else

348 last_symbol = 267 - b;

349 }

350 if (last_symbol >= 0) {

351 *pp = last_symbol;

352 AV_WB24(rp, pal[last_symbol]);

353 } else if (last_symbol == -1 && prev_avail) {

354 *pp = *(pp - pal_stride);

355 memcpy(rp, rp - rgb_stride, 3);

356 }

357 rp += 3;

358 } while (++pp < pal_dst + w);

359 pal_dst += pal_stride;

360 rgb_dst += rgb_stride;

361 prev_avail = 1;

362 } while (--h);

363

364 ff_free_vlc(&vlc);

365 return 0;

366 }

367

368 static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,

369 int x, int y, int w, int h, int wmv9_mask)

370 {

371 MSS2Context *ctx = avctx->priv_data;

372 MSS12Context *c = &ctx->c;

373 VC1Context *v = avctx->priv_data;

374 MpegEncContext *s = &v->s;

375 AVFrame *f;

376

377 ff_mpeg_flush(avctx);

378

379 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {

380 int i = ff_find_unused_picture(s, 0);

381 if (i < 0)

382 return -1;

383 s->current_picture_ptr = &s->picture[i];

384 }

385

386 init_get_bits(&s->gb, buf, buf_size * 8);

387

388 s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL;

389

390 if (ff_vc1_parse_frame_header(v, &s->gb) == -1) {

391 av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");

392 return AVERROR_INVALIDDATA;

393 }

394

395 if (s->pict_type != AV_PICTURE_TYPE_I) {

396 av_log(v->s.avctx, AV_LOG_ERROR, "expected I-frame\n");

397 return AVERROR_INVALIDDATA;

398 }

399

400 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

401

402 if (ff_MPV_frame_start(s, avctx) < 0) {

403 av_log(v->s.avctx, AV_LOG_ERROR, "ff_MPV_frame_start error\n");

404 avctx->pix_fmt = AV_PIX_FMT_RGB24;

405 return -1;

406 }

407

408 ff_er_frame_start(s);

409

410 v->bits = buf_size * 8;

411

412 v->end_mb_x = (w + 15) >> 4;

413 s->end_mb_y = (h + 15) >> 4;

414 if (v->respic & 1)

415 v->end_mb_x = v->end_mb_x + 1 >> 1;

416 if (v->respic & 2)

417 s->end_mb_y = s->end_mb_y + 1 >> 1;

418

419 ff_vc1_decode_blocks(v);

420

421 ff_er_frame_end(s);

422

423 ff_MPV_frame_end(s);

424

425 f = &s->current_picture.f;

426

427 if (v->respic == 3) {

428 ctx->dsp.upsample_plane(f->data[0], f->linesize[0], w, h);

429 ctx->dsp.upsample_plane(f->data[1], f->linesize[1], w >> 1, h >> 1);

430 ctx->dsp.upsample_plane(f->data[2], f->linesize[2], w >> 1, h >> 1);

431 } else if (v->respic)

432 av_log_ask_for_sample(v->s.avctx,

433 "Asymmetric WMV9 rectangle subsampling\n");

434

435 av_assert0(f->linesize[1] == f->linesize[2]);

436

437 if (wmv9_mask != -1)

438 ctx->dsp.mss2_blit_wmv9_masked(c->rgb_pic + y * c->rgb_stride + x * 3,

439 c->rgb_stride, wmv9_mask,

440 c->pal_pic + y * c->pal_stride + x,

441 c->pal_stride,

442 f->data[0], f->linesize[0],

443 f->data[1], f->data[2], f->linesize[1],

444 w, h);

445 else

446 ctx->dsp.mss2_blit_wmv9(c->rgb_pic + y * c->rgb_stride + x * 3,

447 c->rgb_stride,

448 f->data[0], f->linesize[0],

449 f->data[1], f->data[2], f->linesize[1],

450 w, h);

451

452 avctx->pix_fmt = AV_PIX_FMT_RGB24;

453

454 return 0;

455 }

456

457 typedef struct Rectangle {

458 int coded, x, y, w, h;

459 } Rectangle;

460

461 #define MAX_WMV9_RECTANGLES 20

462 #define ARITH2_PADDING 2

463

464 static int mss2_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

465 AVPacket *avpkt)

466 {

467 const uint8_t *buf = avpkt->data;

468 int buf_size = avpkt->size;

469 MSS2Context *ctx = avctx->priv_data;

470 MSS12Context *c = &ctx->c;

471 GetBitContext gb;

472 GetByteContext gB;

473 ArithCoder acoder;

474

475 int keyframe, has_wmv9, has_mv, is_rle, is_555, ret;

476

477 Rectangle wmv9rects[MAX_WMV9_RECTANGLES], *r;

478 int used_rects = 0, i, implicit_rect = 0, av_uninit(wmv9_mask);

479

480 av_assert0(FF_INPUT_BUFFER_PADDING_SIZE >=

481 ARITH2_PADDING + (MIN_CACHE_BITS + 7) / 8);

482

483 init_get_bits(&gb, buf, buf_size * 8);

484

485 if (keyframe = get_bits1(&gb))

486 skip_bits(&gb, 7);

487 has_wmv9 = get_bits1(&gb);

488 has_mv = keyframe ? 0 : get_bits1(&gb);

489 is_rle = get_bits1(&gb);

490 is_555 = is_rle && get_bits1(&gb);

491 if (c->slice_split > 0)

492 ctx->split_position = c->slice_split;

493 else if (c->slice_split < 0) {

494 if (get_bits1(&gb)) {

495 if (get_bits1(&gb)) {

496 if (get_bits1(&gb))

497 ctx->split_position = get_bits(&gb, 16);

498 else

499 ctx->split_position = get_bits(&gb, 12);

500 } else

501 ctx->split_position = get_bits(&gb, 8) << 4;

502 } else {

503 if (keyframe)

504 ctx->split_position = avctx->height / 2;

505 }

506 } else

507 ctx->split_position = avctx->height;

508

509 if (c->slice_split && (ctx->split_position < 1 - is_555 ||

510 ctx->split_position > avctx->height - 1))

511 return AVERROR_INVALIDDATA;

512

513 align_get_bits(&gb);

514 buf += get_bits_count(&gb) >> 3;

515 buf_size -= get_bits_count(&gb) >> 3;

516

517 if (buf_size < 1)

518 return AVERROR_INVALIDDATA;

519

520 if (is_555 && (has_wmv9 || has_mv || c->slice_split && ctx->split_position))

521 return AVERROR_INVALIDDATA;

522

523 avctx->pix_fmt = is_555 ? AV_PIX_FMT_RGB555 : AV_PIX_FMT_RGB24;

524 if (ctx->pic.data[0] && ctx->pic.format != avctx->pix_fmt)

525 avctx->release_buffer(avctx, &ctx->pic);

526

527 if (has_wmv9) {

528 bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);

529 arith2_init(&acoder, &gB);

530

531 implicit_rect = !arith2_get_bit(&acoder);

532

533 while (arith2_get_bit(&acoder)) {

534 if (used_rects == MAX_WMV9_RECTANGLES)

535 return AVERROR_INVALIDDATA;

536 r = &wmv9rects[used_rects];

537 if (!used_rects)

538 r->x = arith2_get_number(&acoder, avctx->width);

539 else

540 r->x = arith2_get_number(&acoder, avctx->width -

541 wmv9rects[used_rects - 1].x) +

542 wmv9rects[used_rects - 1].x;

543 r->y = arith2_get_number(&acoder, avctx->height);

544 r->w = arith2_get_number(&acoder, avctx->width - r->x) + 1;

545 r->h = arith2_get_number(&acoder, avctx->height - r->y) + 1;

546 used_rects++;

547 }

548

549 if (implicit_rect && used_rects) {

550 av_log(avctx, AV_LOG_ERROR, "implicit_rect && used_rects > 0\n");

551 return AVERROR_INVALIDDATA;

552 }

553

554 if (implicit_rect) {

555 wmv9rects[0].x = 0;

556 wmv9rects[0].y = 0;

557 wmv9rects[0].w = avctx->width;

558 wmv9rects[0].h = avctx->height;

559

560 used_rects = 1;

561 }

562 for (i = 0; i < used_rects; i++) {

563 if (!implicit_rect && arith2_get_bit(&acoder)) {

564 av_log(avctx, AV_LOG_ERROR, "Unexpected grandchildren\n");

565 return AVERROR_INVALIDDATA;

566 }

567 if (!i) {

568 wmv9_mask = arith2_get_bit(&acoder) - 1;

569 if (!wmv9_mask)

570 wmv9_mask = arith2_get_number(&acoder, 256);

571 }

572 wmv9rects[i].coded = arith2_get_number(&acoder, 2);

573 }

574

575 buf += arith2_get_consumed_bytes(&acoder);

576 buf_size -= arith2_get_consumed_bytes(&acoder);

577 if (buf_size < 1)

578 return AVERROR_INVALIDDATA;

579 }

580

581 c->mvX = c->mvY = 0;

582 if (keyframe && !is_555) {

583 if ((i = decode_pal_v2(c, buf, buf_size)) < 0)

584 return AVERROR_INVALIDDATA;

585 buf += i;

586 buf_size -= i;

587 } else if (has_mv) {

588 buf += 4;

589 buf_size -= 4;

590 if (buf_size < 1)

591 return AVERROR_INVALIDDATA;

592 c->mvX = AV_RB16(buf - 4) - avctx->width;

593 c->mvY = AV_RB16(buf - 2) - avctx->height;

594 }

595

596 if (c->mvX < 0 || c->mvY < 0) {

597 FFSWAP(AVFrame, ctx->pic, ctx->last_pic);

598 FFSWAP(uint8_t *, c->pal_pic, c->last_pal_pic);

599

600 if (ctx->pic.data[0])

601 avctx->release_buffer(avctx, &ctx->pic);

602

603 ctx->pic.reference = 3;

604 ctx->pic.buffer_hints = FF_BUFFER_HINTS_VALID |

605 FF_BUFFER_HINTS_READABLE |

606 FF_BUFFER_HINTS_PRESERVE |

607 FF_BUFFER_HINTS_REUSABLE;

608

609 if ((ret = ff_get_buffer(avctx, &ctx->pic)) < 0) {

610 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

611 return ret;

612 }

613

614 if (ctx->last_pic.data[0]) {

615 av_assert0(ctx->pic.linesize[0] == ctx->last_pic.linesize[0]);

616 c->last_rgb_pic = ctx->last_pic.data[0] +

617 ctx->last_pic.linesize[0] * (avctx->height - 1);

618 } else {

619 av_log(avctx, AV_LOG_ERROR, "Missing keyframe\n");

620 return -1;

621 }

622 } else {

623 if (ctx->last_pic.data[0])

624 avctx->release_buffer(avctx, &ctx->last_pic);

625

626 ctx->pic.reference = 3;

627 ctx->pic.buffer_hints = FF_BUFFER_HINTS_VALID |

628 FF_BUFFER_HINTS_READABLE |

629 FF_BUFFER_HINTS_PRESERVE |

630 FF_BUFFER_HINTS_REUSABLE;

631

632 if ((ret = avctx->reget_buffer(avctx, &ctx->pic)) < 0) {

633 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");

634 return ret;

635 }

636

637 c->last_rgb_pic = NULL;

638 }

639 c->rgb_pic = ctx->pic.data[0] +

640 ctx->pic.linesize[0] * (avctx->height - 1);

641 c->rgb_stride = -ctx->pic.linesize[0];

642

643 ctx->pic.key_frame = keyframe;

644 ctx->pic.pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

645

646 if (is_555) {

647 bytestream2_init(&gB, buf, buf_size);

648

649 if (decode_555(&gB, (uint16_t *)c->rgb_pic, c->rgb_stride >> 1,

650 keyframe, avctx->width, avctx->height))

651 return AVERROR_INVALIDDATA;

652

653 buf_size -= bytestream2_tell(&gB);

654 } else {

655 if (keyframe) {

656 c->corrupted = 0;

657 ff_mss12_slicecontext_reset(&ctx->sc[0]);

658 if (c->slice_split)

659 ff_mss12_slicecontext_reset(&ctx->sc[1]);

660 }

661 if (is_rle) {

662 init_get_bits(&gb, buf, buf_size * 8);

663 if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,

664 c->rgb_pic, c->rgb_stride, c->pal, keyframe,

665 ctx->split_position, 0,

666 avctx->width, avctx->height))

667 return ret;

668 align_get_bits(&gb);

669

670 if (c->slice_split)

671 if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,

672 c->rgb_pic, c->rgb_stride, c->pal, keyframe,

673 ctx->split_position, 1,

674 avctx->width, avctx->height))

675 return ret;

676

677 align_get_bits(&gb);

678 buf += get_bits_count(&gb) >> 3;

679 buf_size -= get_bits_count(&gb) >> 3;

680 } else if (!implicit_rect || wmv9_mask != -1) {

681 if (c->corrupted)

682 return AVERROR_INVALIDDATA;

683 bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);

684 arith2_init(&acoder, &gB);

685 c->keyframe = keyframe;

686 if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[0], &acoder, 0, 0,

687 avctx->width,

688 ctx->split_position))

689 return AVERROR_INVALIDDATA;

690

691 buf += arith2_get_consumed_bytes(&acoder);

692 buf_size -= arith2_get_consumed_bytes(&acoder);

693 if (c->slice_split) {

694 if (buf_size < 1)

695 return AVERROR_INVALIDDATA;

696 bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);

697 arith2_init(&acoder, &gB);

698 if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[1], &acoder, 0,

699 ctx->split_position,

700 avctx->width,

701 avctx->height - ctx->split_position))

702 return AVERROR_INVALIDDATA;

703

704 buf += arith2_get_consumed_bytes(&acoder);

705 buf_size -= arith2_get_consumed_bytes(&acoder);

706 }

707 } else

708 memset(c->pal_pic, 0, c->pal_stride * avctx->height);

709 }

710

711 if (has_wmv9) {

712 for (i = 0; i < used_rects; i++) {

713 int x = wmv9rects[i].x;

714 int y = wmv9rects[i].y;

715 int w = wmv9rects[i].w;

716 int h = wmv9rects[i].h;

717 if (wmv9rects[i].coded) {

718 int WMV9codedFrameSize;

719 if (buf_size < 4 || !(WMV9codedFrameSize = AV_RL24(buf)))

720 return AVERROR_INVALIDDATA;

721 if (ret = decode_wmv9(avctx, buf + 3, buf_size - 3,

722 x, y, w, h, wmv9_mask))

723 return ret;

724 buf += WMV9codedFrameSize + 3;

725 buf_size -= WMV9codedFrameSize + 3;

726 } else {

727 uint8_t *dst = c->rgb_pic + y * c->rgb_stride + x * 3;

728 if (wmv9_mask != -1) {

729 ctx->dsp.mss2_gray_fill_masked(dst, c->rgb_stride,

730 wmv9_mask,

731 c->pal_pic + y * c->pal_stride + x,

732 c->pal_stride,

733 w, h);

734 } else {

735 do {

736 memset(dst, 0x80, w * 3);

737 dst += c->rgb_stride;

738 } while (--h);

739 }

740 }

741 }

742 }

743

744 if (buf_size)

745 av_log(avctx, AV_LOG_WARNING, "buffer not fully consumed\n");

746

747 *got_frame = 1;

748 *(AVFrame *)data = ctx->pic;

749

750 return avpkt->size;

751 }

752

753 static av_cold int wmv9_init(AVCodecContext *avctx)

754 {

755 VC1Context *v = avctx->priv_data;

756

757 v->s.avctx = avctx;

758 avctx->flags |= CODEC_FLAG_EMU_EDGE;

759 v->s.flags |= CODEC_FLAG_EMU_EDGE;

760

761 if (avctx->idct_algo == FF_IDCT_AUTO)

762 avctx->idct_algo = FF_IDCT_WMV2;

763

764 if (ff_vc1_init_common(v) < 0)

765 return -1;

766 ff_vc1dsp_init(&v->vc1dsp);

767

768 v->profile = PROFILE_MAIN;

769

770 v->zz_8x4 = ff_wmv2_scantableA;

771 v->zz_4x8 = ff_wmv2_scantableB;

772 v->res_y411 = 0;

773 v->res_sprite = 0;

774

775 v->frmrtq_postproc = 7;

776 v->bitrtq_postproc = 31;

777

778 v->res_x8 = 0;

779 v->multires = 0;

780 v->res_fasttx = 1;

781

782 v->fastuvmc = 0;

783

784 v->extended_mv = 0;

785

786 v->dquant = 1;

787 v->vstransform = 1;

788

789 v->res_transtab = 0;

790

791 v->overlap = 0;

792

793 v->s.resync_marker = 0;

794 v->rangered = 0;

795

796 v->s.max_b_frames = avctx->max_b_frames = 0;

797 v->quantizer_mode = 0;

798

799 v->finterpflag = 0;

800

801 v->res_rtm_flag = 1;

802

803 ff_vc1_init_transposed_scantables(v);

804

805 if (ff_msmpeg4_decode_init(avctx) < 0 ||

806 ff_vc1_decode_init_alloc_tables(v) < 0)

807 return -1;

808

809 /* error concealment */

810 v->s.me.qpel_put = v->s.dsp.put_qpel_pixels_tab;

811 v->s.me.qpel_avg = v->s.dsp.avg_qpel_pixels_tab;

812

813 return 0;

814 }

815

816 static av_cold int mss2_decode_end(AVCodecContext *avctx)

817 {

818 MSS2Context *const ctx = avctx->priv_data;

819

820 if (ctx->pic.data[0])

821 avctx->release_buffer(avctx, &ctx->pic);

822 if (ctx->last_pic.data[0])

823 avctx->release_buffer(avctx, &ctx->last_pic);

824

825 ff_mss12_decode_end(&ctx->c);

826 av_freep(&ctx->c.pal_pic);

827 av_freep(&ctx->c.last_pal_pic);

828 ff_vc1_decode_end(avctx);

829

830 return 0;

831 }

832

833 static av_cold int mss2_decode_init(AVCodecContext *avctx)

834 {

835 MSS2Context * const ctx = avctx->priv_data;

836 MSS12Context *c = &ctx->c;

837 int ret;

838 c->avctx = avctx;

839 avctx->coded_frame = &ctx->pic;

840 if (ret = ff_mss12_decode_init(c, 1, &ctx->sc[0], &ctx->sc[1]))

841 return ret;

842 c->pal_stride = c->mask_stride;

843 c->pal_pic = av_mallocz(c->pal_stride * avctx->height);

844 c->last_pal_pic = av_mallocz(c->pal_stride * avctx->height);

845 if (!c->pal_pic || !c->last_pal_pic) {

846 mss2_decode_end(avctx);

847 return AVERROR(ENOMEM);

848 }

849 if (ret = wmv9_init(avctx)) {

850 mss2_decode_end(avctx);

851 return ret;

852 }

853 ff_mss2dsp_init(&ctx->dsp);

854

855 avctx->pix_fmt = c->free_colours == 127 ? AV_PIX_FMT_RGB555

856 : AV_PIX_FMT_RGB24;

857

858 return 0;

859 }

860

861 AVCodec ff_mss2_decoder = {

862 .name = "mss2",

863 .type = AVMEDIA_TYPE_VIDEO,

864 .id = AV_CODEC_ID_MSS2,

865 .priv_data_size = sizeof(MSS2Context),

866 .init = mss2_decode_init,

867 .close = mss2_decode_end,

868 .decode = mss2_decode_frame,

869 .capabilities = CODEC_CAP_DR1,

870 .long_name = NULL_IF_CONFIG_SMALL("MS Windows Media Video V9 Screen"),

871 };

Generated on Sat May 25 2013 03:58:38 for FFmpeg by doxygen 1.8.2