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 "error_resilience.h"

28 #include "internal.h"

29 #include "msmpeg4data.h"

30 #include "vc1.h"

31 #include "mss12.h"

32 #include "mss2dsp.h"

34 typedef struct MSS2Context {

35 VC1Context v;

36 int split_position;

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 AVERROR_INVALIDDATA;

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 AVERROR_INVALIDDATA;

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 int ret;

377

378 ff_mpeg_flush(avctx);

379

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

381 int i = ff_find_unused_picture(s, 0);

382 if (i < 0)

383 return i;

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

385 }

386

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

388

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

390

391 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {

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

393 return AVERROR_INVALIDDATA;

394 }

395

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

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

398 return AVERROR_INVALIDDATA;

399 }

400

401 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

402

403 if ((ret = ff_MPV_frame_start(s, avctx)) < 0) {

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

405 avctx->pix_fmt = AV_PIX_FMT_RGB24;

406 return ret;

407 }

408

409 ff_mpeg_er_frame_start(s);

410

411 v->bits = buf_size * 8;

412

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

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

415 if (v->respic & 1)

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

417 if (v->respic & 2)

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

419

420 ff_vc1_decode_blocks(v);

421

422 ff_er_frame_end(&s->er);

423

424 ff_MPV_frame_end(s);

425

426 f = &s->current_picture.f;

427

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

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

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

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

432 } else if (v->respic)

433 avpriv_request_sample(v->s.avctx,

434 "Asymmetric WMV9 rectangle subsampling");

435

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

437

438 if (wmv9_mask != -1)

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

440 c->rgb_stride, wmv9_mask,

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

442 c->pal_stride,

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

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

445 w, h);

446 else

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

448 c->rgb_stride,

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

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

451 w, h);

452

453 avctx->pix_fmt = AV_PIX_FMT_RGB24;

454

455 return 0;

456 }

457

458 typedef struct Rectangle {

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

460 } Rectangle;

461

462 #define MAX_WMV9_RECTANGLES 20

463 #define ARITH2_PADDING 2

464

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

466 AVPacket *avpkt)

467 {

468 const uint8_t *buf = avpkt->data;

469 int buf_size = avpkt->size;

470 MSS2Context *ctx = avctx->priv_data;

471 MSS12Context *c = &ctx->c;

472 AVFrame *frame = data;

473 GetBitContext gb;

474 GetByteContext gB;

475 ArithCoder acoder;

476

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

478

479 Rectangle wmv9rects[MAX_WMV9_RECTANGLES], *r;

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

481

482 av_assert0(FF_INPUT_BUFFER_PADDING_SIZE >=

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

484

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

486

487 if (keyframe = get_bits1(&gb))

488 skip_bits(&gb, 7);

489 has_wmv9 = get_bits1(&gb);

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

491 is_rle = get_bits1(&gb);

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

493 if (c->slice_split > 0)

494 ctx->split_position = c->slice_split;

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

496 if (get_bits1(&gb)) {

497 if (get_bits1(&gb)) {

498 if (get_bits1(&gb))

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

500 else

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

502 } else

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

504 } else {

505 if (keyframe)

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

507 }

508 } else

509 ctx->split_position = avctx->height;

510

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

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

513 return AVERROR_INVALIDDATA;

514

515 align_get_bits(&gb);

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

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

518

519 if (buf_size < 1)

520 return AVERROR_INVALIDDATA;

521

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

523 return AVERROR_INVALIDDATA;

524

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

526 if (ctx->last_pic.format != avctx->pix_fmt)

527 av_frame_unref(&ctx->last_pic);

528

529 if (has_wmv9) {

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

531 arith2_init(&acoder, &gB);

532

533 implicit_rect = !arith2_get_bit(&acoder);

534

535 while (arith2_get_bit(&acoder)) {

536 if (used_rects == MAX_WMV9_RECTANGLES)

537 return AVERROR_INVALIDDATA;

538 r = &wmv9rects[used_rects];

539 if (!used_rects)

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

541 else

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

543 wmv9rects[used_rects - 1].x) +

544 wmv9rects[used_rects - 1].x;

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

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

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

548 used_rects++;

549 }

550

551 if (implicit_rect && used_rects) {

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

553 return AVERROR_INVALIDDATA;

554 }

555

556 if (implicit_rect) {

557 wmv9rects[0].x = 0;

558 wmv9rects[0].y = 0;

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

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

561

562 used_rects = 1;

563 }

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

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

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

567 return AVERROR_INVALIDDATA;

568 }

569 if (!i) {

570 wmv9_mask = arith2_get_bit(&acoder) - 1;

571 if (!wmv9_mask)

572 wmv9_mask = arith2_get_number(&acoder, 256);

573 }

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

575 }

576

577 buf += arith2_get_consumed_bytes(&acoder);

578 buf_size -= arith2_get_consumed_bytes(&acoder);

579 if (buf_size < 1)

580 return AVERROR_INVALIDDATA;

581 }

582

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

584 if (keyframe && !is_555) {

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

586 return AVERROR_INVALIDDATA;

587 buf += i;

588 buf_size -= i;

589 } else if (has_mv) {

590 buf += 4;

591 buf_size -= 4;

592 if (buf_size < 1)

593 return AVERROR_INVALIDDATA;

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

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

596 }

597

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

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

600

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

602 return ret;

603

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

605 av_assert0(frame->linesize[0] == ctx->last_pic.linesize[0]);

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

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

608 } else {

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

610 return AVERROR_INVALIDDATA;

611 }

612 } else {

613 if ((ret = ff_reget_buffer(avctx, &ctx->last_pic)) < 0)

614 return ret;

615 if ((ret = av_frame_ref(frame, &ctx->last_pic)) < 0)

616 return ret;

617

618 c->last_rgb_pic = NULL;

619 }

620 c->rgb_pic = frame->data[0] +

621 frame->linesize[0] * (avctx->height - 1);

622 c->rgb_stride = -frame->linesize[0];

623

624 frame->key_frame = keyframe;

625 frame->pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

626

627 if (is_555) {

628 bytestream2_init(&gB, buf, buf_size);

629

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

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

632 return AVERROR_INVALIDDATA;

633

634 buf_size -= bytestream2_tell(&gB);

635 } else {

636 if (keyframe) {

637 c->corrupted = 0;

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

639 if (c->slice_split)

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

641 }

642 if (is_rle) {

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

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

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

646 ctx->split_position, 0,

647 avctx->width, avctx->height))

648 return ret;

649 align_get_bits(&gb);

650

651 if (c->slice_split)

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

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

654 ctx->split_position, 1,

655 avctx->width, avctx->height))

656 return ret;

657

658 align_get_bits(&gb);

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

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

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

662 if (c->corrupted)

663 return AVERROR_INVALIDDATA;

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

665 arith2_init(&acoder, &gB);

666 c->keyframe = keyframe;

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

668 avctx->width,

669 ctx->split_position))

670 return AVERROR_INVALIDDATA;

671

672 buf += arith2_get_consumed_bytes(&acoder);

673 buf_size -= arith2_get_consumed_bytes(&acoder);

674 if (c->slice_split) {

675 if (buf_size < 1)

676 return AVERROR_INVALIDDATA;

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

678 arith2_init(&acoder, &gB);

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

680 ctx->split_position,

681 avctx->width,

682 avctx->height - ctx->split_position))

683 return AVERROR_INVALIDDATA;

684

685 buf += arith2_get_consumed_bytes(&acoder);

686 buf_size -= arith2_get_consumed_bytes(&acoder);

687 }

688 } else

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

690 }

691

692 if (has_wmv9) {

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

694 int x = wmv9rects[i].x;

695 int y = wmv9rects[i].y;

696 int w = wmv9rects[i].w;

697 int h = wmv9rects[i].h;

698 if (wmv9rects[i].coded) {

699 int WMV9codedFrameSize;

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

701 return AVERROR_INVALIDDATA;

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

703 x, y, w, h, wmv9_mask))

704 return ret;

705 buf += WMV9codedFrameSize + 3;

706 buf_size -= WMV9codedFrameSize + 3;

707 } else {

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

709 if (wmv9_mask != -1) {

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

711 wmv9_mask,

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

713 c->pal_stride,

714 w, h);

715 } else {

716 do {

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

718 dst += c->rgb_stride;

719 } while (--h);

720 }

721 }

722 }

723 }

724

725 if (buf_size)

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

727

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

729 av_frame_unref(&ctx->last_pic);

730 ret = av_frame_ref(&ctx->last_pic, frame);

731 if (ret < 0)

732 return ret;

733 }

734

735 *got_frame = 1;

736

737 return avpkt->size;

738 }

739

740 static av_cold int wmv9_init(AVCodecContext *avctx)

741 {

742 VC1Context *v = avctx->priv_data;

743 int ret;

744

745 v->s.avctx = avctx;

746 avctx->flags |= CODEC_FLAG_EMU_EDGE;

747 v->s.flags |= CODEC_FLAG_EMU_EDGE;

748

749 if ((ret = ff_vc1_init_common(v)) < 0)

750 return ret;

751 ff_vc1dsp_init(&v->vc1dsp);

752

753 v->profile = PROFILE_MAIN;

754

755 v->zz_8x4 = ff_wmv2_scantableA;

756 v->zz_4x8 = ff_wmv2_scantableB;

757 v->res_y411 = 0;

758 v->res_sprite = 0;

759

760 v->frmrtq_postproc = 7;

761 v->bitrtq_postproc = 31;

762

763 v->res_x8 = 0;

764 v->multires = 0;

765 v->res_fasttx = 1;

766

767 v->fastuvmc = 0;

768

769 v->extended_mv = 0;

770

771 v->dquant = 1;

772 v->vstransform = 1;

773

774 v->res_transtab = 0;

775

776 v->overlap = 0;

777

778 v->s.resync_marker = 0;

779 v->rangered = 0;

780

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

782 v->quantizer_mode = 0;

783

784 v->finterpflag = 0;

785

786 v->res_rtm_flag = 1;

787

788 ff_vc1_init_transposed_scantables(v);

789

790 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0 ||

791 (ret = ff_vc1_decode_init_alloc_tables(v)) < 0)

792 return ret;

793

794 /* error concealment */

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

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

797

798 return 0;

799 }

800

801 static av_cold int mss2_decode_end(AVCodecContext *avctx)

802 {

803 MSS2Context *const ctx = avctx->priv_data;

804

805 av_frame_unref(&ctx->last_pic);

806

807 ff_mss12_decode_end(&ctx->c);

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

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

810 ff_vc1_decode_end(avctx);

811

812 return 0;

813 }

814

815 static av_cold int mss2_decode_init(AVCodecContext *avctx)

816 {

817 MSS2Context * const ctx = avctx->priv_data;

818 MSS12Context *c = &ctx->c;

819 int ret;

820 c->avctx = avctx;

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

822 return ret;

823 c->pal_stride = c->mask_stride;

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

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

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

827 mss2_decode_end(avctx);

828 return AVERROR(ENOMEM);

829 }

830 if (ret = wmv9_init(avctx)) {

831 mss2_decode_end(avctx);

832 return ret;

833 }

834 ff_mss2dsp_init(&ctx->dsp);

835

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

837 : AV_PIX_FMT_RGB24;

838

839 return 0;

840 }

841

842 AVCodec ff_mss2_decoder = {

843 .name = "mss2",

844 .type = AVMEDIA_TYPE_VIDEO,

845 .id = AV_CODEC_ID_MSS2,

846 .priv_data_size = sizeof(MSS2Context),

847 .init = mss2_decode_init,

848 .close = mss2_decode_end,

849 .decode = mss2_decode_frame,

850 .capabilities = CODEC_CAP_DR1,

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

852 };

Generated on Wed Jul 10 2013 23:48:02 for FFmpeg by doxygen 1.8.2