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

30 #include "msmpeg4.h"

31 #include "msmpeg4data.h"

32 #include "qpeldsp.h"

33 #include "vc1.h"

34 #include "mss12.h"

35 #include "mss2dsp.h"

37 typedef struct MSS2Context {

38 VC1Context v;

39 int split_position;

40 AVFrame *last_pic;

41 MSS12Context c;

42 MSS2DSPContext dsp;

43 QpelDSPContext qdsp;

44 SliceContext sc[2];

45 } MSS2Context;

47 static void arith2_normalise(ArithCoder *c)

48 {

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

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

51 c->high ^= 0x8000;

52 c->value ^= 0x8000;

53 c->low ^= 0x8000;

54 }

55 c->high = (uint16_t)c->high << 8 | 0xFF;

56 c->value = (uint16_t)c->value << 8 | bytestream2_get_byte(c->gbc.gB);

57 c->low = (uint16_t)c->low << 8;

58 }

59 }

61 ARITH_GET_BIT(arith2)

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

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

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

67 {

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

70 if (value > split)

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

72 else

73 return value;

74 }

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

77 int low, int high, int n)

78 {

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

81 if (high > split)

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

83 else

84 c->high = high;

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

88 if (low > split)

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

90 else

91 c->low += low;

92 }

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

95 {

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

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

98 int val;

100 if (n << scale > range)

101 scale--;

102

103 n <<= scale;

104

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

106

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

108

109 arith2_normalise(c);

110

111 return val;

112 }

113

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

115 {

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

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

118 int i = 0, val;

119

120 if (n << scale > range)

121 scale--;

122

123 n <<= scale;

124

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

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

127

128 arith2_rescale_interval(c, range,

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

130

131 return i;

132 }

133

134 ARITH_GET_MODEL_SYM(arith2)

135

136 static int arith2_get_consumed_bytes(ArithCoder *c)

137 {

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

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

140 int bits = 1;

141

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

143 bits++;

144 diff <<= 1;

145 }

146

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

148 }

149

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

151 {

152 c->low = 0;

153 c->high = 0xFFFFFF;

154 c->value = bytestream2_get_be24(gB);

155 c->gbc.gB = gB;

156 c->get_model_sym = arith2_get_model_sym;

157 c->get_number = arith2_get_number;

158 }

159

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

161 {

162 int i, ncol;

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

164

165 if (!ctx->free_colours)

166 return 0;

167

168 ncol = *buf++;

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

170 return AVERROR_INVALIDDATA;

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

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

173

174 return 1 + ncol * 3;

175 }

176

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

178 int keyframe, int w, int h)

179 {

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

181

182 if (!keyframe) {

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

184

185 #define READ_PAIR(a, b) \

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

187 t = bytestream2_get_byte(gB); \

188 a |= t >> 4; \

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

190 b |= bytestream2_get_byte(gB); \

191

192 READ_PAIR(x, endx)

193 READ_PAIR(y, endy)

194

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

196 return AVERROR_INVALIDDATA;

197 dst += x + stride * y;

198 w = endx - x + 1;

199 h = endy - y + 1;

200 if (y)

201 prev_avail = 1;

202 }

203

204 do {

205 uint16_t *p = dst;

206 do {

207 if (repeat-- < 1) {

208 int b = bytestream2_get_byte(gB);

209 if (b < 128)

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

211 else if (b > 129) {

212 repeat = 0;

213 while (b-- > 130) {

214 if (repeat >= (INT_MAX >> 8) - 1) {

215 av_log(NULL, AV_LOG_ERROR, "repeat overflow\n");

216 return AVERROR_INVALIDDATA;

217 }

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

219 }

220 if (last_symbol == -2) {

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

222 repeat -= skip;

223 p += skip;

224 }

225 } else

226 last_symbol = 127 - b;

227 }

228 if (last_symbol >= 0)

229 *p = last_symbol;

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

231 *p = *(p - stride);

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

233 dst += stride;

234 prev_avail = 1;

235 } while (--h);

236

237 return 0;

238 }

239

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

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

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

243 {

244 uint8_t bits[270] = { 0 };

245 uint32_t codes[270];

246 VLC vlc;

247

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

249 int remaining_codes, surplus_codes, i;

250

251 const int alphabet_size = 270 - keyframe;

252

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

254

255 if (!keyframe) {

256 int x, y, clipw, cliph;

257

258 x = get_bits(gb, 12);

259 y = get_bits(gb, 12);

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

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

262

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

264 return AVERROR_INVALIDDATA;

265 pal_dst += pal_stride * y + x;

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

267 w = clipw;

268 h = cliph;

269 if (y)

270 prev_avail = 1;

271 } else {

272 if (slice > 0) {

273 pal_dst += pal_stride * kf_slipt;

274 rgb_dst += rgb_stride * kf_slipt;

275 prev_avail = 1;

276 h -= kf_slipt;

277 } else

278 h = kf_slipt;

279 }

280

281 /* read explicit codes */

282 do {

283 while (current_codes--) {

284 int symbol = get_bits(gb, 8);

285 if (symbol >= 204 - keyframe)

286 symbol += 14 - keyframe;

287 else if (symbol > 189)

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

289 if (bits[symbol])

290 return AVERROR_INVALIDDATA;

291 bits[symbol] = current_length;

292 codes[symbol] = next_code++;

293 read_codes++;

294 }

295 current_length++;

296 next_code <<= 1;

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

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

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

300 return AVERROR_INVALIDDATA;

301 } while (current_codes != remaining_codes);

302

303 remaining_codes = alphabet_size - read_codes;

304

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

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

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

308 current_length++;

309 next_code <<= 1;

310 }

311

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

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

314 if (!bits[i]) {

315 if (surplus_codes-- == 0) {

316 current_length++;

317 next_code <<= 1;

318 }

319 bits[i] = current_length;

320 codes[i] = next_code++;

321 }

322

323 if (next_code != 1 << current_length)

324 return AVERROR_INVALIDDATA;

325

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

327 return i;

328

329 /* frame decode */

330 do {

331 uint8_t *pp = pal_dst;

332 uint8_t *rp = rgb_dst;

333 do {

334 if (repeat-- < 1) {

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

336 if (b < 256)

337 last_symbol = b;

338 else if (b < 268) {

339 b -= 256;

340 if (b == 11)

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

342

343 if (!b)

344 repeat = 0;

345 else

346 repeat = get_bits(gb, b);

347

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

349

350 if (last_symbol == -2) {

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

352 repeat -= skip;

353 pp += skip;

354 rp += skip * 3;

355 }

356 } else

357 last_symbol = 267 - b;

358 }

359 if (last_symbol >= 0) {

360 *pp = last_symbol;

361 AV_WB24(rp, pal[last_symbol]);

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

363 *pp = *(pp - pal_stride);

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

365 }

366 rp += 3;

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

368 pal_dst += pal_stride;

369 rgb_dst += rgb_stride;

370 prev_avail = 1;

371 } while (--h);

372

373 ff_free_vlc(&vlc);

374 return 0;

375 }

376

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

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

379 {

380 MSS2Context *ctx = avctx->priv_data;

381 MSS12Context *c = &ctx->c;

382 VC1Context *v = avctx->priv_data;

383 MpegEncContext *s = &v->s;

384 AVFrame *f;

385 int ret;

386

387 ff_mpeg_flush(avctx);

388

389 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)

390 return ret;

391

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

393

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

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

396 return AVERROR_INVALIDDATA;

397 }

398

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

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

401 return AVERROR_INVALIDDATA;

402 }

403

404 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

405

406 if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {

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

408 avctx->pix_fmt = AV_PIX_FMT_RGB24;

409 return ret;

410 }

411

412 ff_mpeg_er_frame_start(s);

413

414 v->bits = buf_size * 8;

415

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

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

418 if (v->respic & 1)

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

420 if (v->respic & 2)

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

422

423 ff_vc1_decode_blocks(v);

424

425 ff_er_frame_end(&s->er);

426

427 ff_mpv_frame_end(s);

428

429 f = s->current_picture.f;

430

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

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

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

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

435 } else if (v->respic)

436 avpriv_request_sample(v->s.avctx,

437 "Asymmetric WMV9 rectangle subsampling");

438

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

440

441 if (wmv9_mask != -1)

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

443 c->rgb_stride, wmv9_mask,

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

445 c->pal_stride,

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

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

448 w, h);

449 else

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

451 c->rgb_stride,

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

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

454 w, h);

455

456 avctx->pix_fmt = AV_PIX_FMT_RGB24;

457

458 return 0;

459 }

460

461 typedef struct Rectangle {

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

463 } Rectangle;

464

465 #define MAX_WMV9_RECTANGLES 20

466 #define ARITH2_PADDING 2

467

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

469 AVPacket *avpkt)

470 {

471 const uint8_t *buf = avpkt->data;

472 int buf_size = avpkt->size;

473 MSS2Context *ctx = avctx->priv_data;

474 MSS12Context *c = &ctx->c;

475 AVFrame *frame = data;

476 GetBitContext gb;

477 GetByteContext gB;

478 ArithCoder acoder;

479

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

481

482 Rectangle wmv9rects[MAX_WMV9_RECTANGLES], *r;

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

484

485 av_assert0(AV_INPUT_BUFFER_PADDING_SIZE >=

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

487

488 if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)

489 return ret;

490

491 if (keyframe = get_bits1(&gb))

492 skip_bits(&gb, 7);

493 has_wmv9 = get_bits1(&gb);

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

495 is_rle = get_bits1(&gb);

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

497 if (c->slice_split > 0)

498 ctx->split_position = c->slice_split;

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

500 if (get_bits1(&gb)) {

501 if (get_bits1(&gb)) {

502 if (get_bits1(&gb))

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

504 else

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

506 } else

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

508 } else {

509 if (keyframe)

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

511 }

512 } else

513 ctx->split_position = avctx->height;

514

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

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

517 return AVERROR_INVALIDDATA;

518

519 align_get_bits(&gb);

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

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

522

523 if (buf_size < 1)

524 return AVERROR_INVALIDDATA;

525

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

527 return AVERROR_INVALIDDATA;

528

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

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

531 av_frame_unref(ctx->last_pic);

532

533 if (has_wmv9) {

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

535 arith2_init(&acoder, &gB);

536

537 implicit_rect = !arith2_get_bit(&acoder);

538

539 while (arith2_get_bit(&acoder)) {

540 if (used_rects == MAX_WMV9_RECTANGLES)

541 return AVERROR_INVALIDDATA;

542 r = &wmv9rects[used_rects];

543 if (!used_rects)

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

545 else

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

547 wmv9rects[used_rects - 1].x) +

548 wmv9rects[used_rects - 1].x;

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

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

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

552 used_rects++;

553 }

554

555 if (implicit_rect && used_rects) {

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

557 return AVERROR_INVALIDDATA;

558 }

559

560 if (implicit_rect) {

561 wmv9rects[0].x = 0;

562 wmv9rects[0].y = 0;

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

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

565

566 used_rects = 1;

567 }

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

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

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

571 return AVERROR_INVALIDDATA;

572 }

573 if (!i) {

574 wmv9_mask = arith2_get_bit(&acoder) - 1;

575 if (!wmv9_mask)

576 wmv9_mask = arith2_get_number(&acoder, 256);

577 }

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

579 }

580

581 buf += arith2_get_consumed_bytes(&acoder);

582 buf_size -= arith2_get_consumed_bytes(&acoder);

583 if (buf_size < 1)

584 return AVERROR_INVALIDDATA;

585 }

586

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

588 if (keyframe && !is_555) {

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

590 return AVERROR_INVALIDDATA;

591 buf += i;

592 buf_size -= i;

593 } else if (has_mv) {

594 buf += 4;

595 buf_size -= 4;

596 if (buf_size < 1)

597 return AVERROR_INVALIDDATA;

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

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

600 }

601

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

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

604

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

606 return ret;

607

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

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

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

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

612 } else {

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

614 return AVERROR_INVALIDDATA;

615 }

616 } else {

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

618 return ret;

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

620 return ret;

621

622 c->last_rgb_pic = NULL;

623 }

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

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

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

627

628 frame->key_frame = keyframe;

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

630

631 if (is_555) {

632 bytestream2_init(&gB, buf, buf_size);

633

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

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

636 return AVERROR_INVALIDDATA;

637

638 buf_size -= bytestream2_tell(&gB);

639 } else {

640 if (keyframe) {

641 c->corrupted = 0;

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

643 if (c->slice_split)

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

645 }

646 if (is_rle) {

647 if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)

648 return ret;

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

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

651 ctx->split_position, 0,

652 avctx->width, avctx->height))

653 return ret;

654 align_get_bits(&gb);

655

656 if (c->slice_split)

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

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

659 ctx->split_position, 1,

660 avctx->width, avctx->height))

661 return ret;

662

663 align_get_bits(&gb);

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

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

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

667 if (c->corrupted)

668 return AVERROR_INVALIDDATA;

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

670 arith2_init(&acoder, &gB);

671 c->keyframe = keyframe;

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

673 avctx->width,

674 ctx->split_position))

675 return AVERROR_INVALIDDATA;

676

677 buf += arith2_get_consumed_bytes(&acoder);

678 buf_size -= arith2_get_consumed_bytes(&acoder);

679 if (c->slice_split) {

680 if (buf_size < 1)

681 return AVERROR_INVALIDDATA;

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

683 arith2_init(&acoder, &gB);

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

685 ctx->split_position,

686 avctx->width,

687 avctx->height - ctx->split_position))

688 return AVERROR_INVALIDDATA;

689

690 buf += arith2_get_consumed_bytes(&acoder);

691 buf_size -= arith2_get_consumed_bytes(&acoder);

692 }

693 } else

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

695 }

696

697 if (has_wmv9) {

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

699 int x = wmv9rects[i].x;

700 int y = wmv9rects[i].y;

701 int w = wmv9rects[i].w;

702 int h = wmv9rects[i].h;

703 if (wmv9rects[i].coded) {

704 int WMV9codedFrameSize;

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

706 return AVERROR_INVALIDDATA;

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

708 x, y, w, h, wmv9_mask))

709 return ret;

710 buf += WMV9codedFrameSize + 3;

711 buf_size -= WMV9codedFrameSize + 3;

712 } else {

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

714 if (wmv9_mask != -1) {

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

716 wmv9_mask,

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

718 c->pal_stride,

719 w, h);

720 } else {

721 do {

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

723 dst += c->rgb_stride;

724 } while (--h);

725 }

726 }

727 }

728 }

729

730 if (buf_size)

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

732

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

734 av_frame_unref(ctx->last_pic);

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

736 if (ret < 0)

737 return ret;

738 }

739

740 *got_frame = 1;

741

742 return avpkt->size;

743 }

744

745 static av_cold int wmv9_init(AVCodecContext *avctx)

746 {

747 VC1Context *v = avctx->priv_data;

748 int ret;

749

750 v->s.avctx = avctx;

751

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

753 return ret;

754 ff_vc1dsp_init(&v->vc1dsp);

755

756 v->profile = PROFILE_MAIN;

757

758 v->zz_8x4 = ff_wmv2_scantableA;

759 v->zz_4x8 = ff_wmv2_scantableB;

760 v->res_y411 = 0;

761 v->res_sprite = 0;

762

763 v->frmrtq_postproc = 7;

764 v->bitrtq_postproc = 31;

765

766 v->res_x8 = 0;

767 v->multires = 0;

768 v->res_fasttx = 1;

769

770 v->fastuvmc = 0;

771

772 v->extended_mv = 0;

773

774 v->dquant = 1;

775 v->vstransform = 1;

776

777 v->res_transtab = 0;

778

779 v->overlap = 0;

780

781 v->resync_marker = 0;

782 v->rangered = 0;

783

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

785 v->quantizer_mode = 0;

786

787 v->finterpflag = 0;

788

789 v->res_rtm_flag = 1;

790

791 ff_vc1_init_transposed_scantables(v);

792

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

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

795 return ret;

796

797 /* error concealment */

798 v->s.me.qpel_put = v->s.qdsp.put_qpel_pixels_tab;

799 v->s.me.qpel_avg = v->s.qdsp.avg_qpel_pixels_tab;

800

801 return 0;

802 }

803

804 static av_cold int mss2_decode_end(AVCodecContext *avctx)

805 {

806 MSS2Context *const ctx = avctx->priv_data;

807

808 av_frame_free(&ctx->last_pic);

809

810 ff_mss12_decode_end(&ctx->c);

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

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

813 ff_vc1_decode_end(avctx);

814

815 return 0;

816 }

817

818 static av_cold int mss2_decode_init(AVCodecContext *avctx)

819 {

820 MSS2Context * const ctx = avctx->priv_data;

821 MSS12Context *c = &ctx->c;

822 int ret;

823 c->avctx = avctx;

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

825 return ret;

826 ctx->last_pic = av_frame_alloc();

827 c->pal_stride = c->mask_stride;

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

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

830 if (!c->pal_pic || !c->last_pal_pic || !ctx->last_pic) {

831 mss2_decode_end(avctx);

832 return AVERROR(ENOMEM);

833 }

834 if (ret = wmv9_init(avctx)) {

835 mss2_decode_end(avctx);

836 return ret;

837 }

838 ff_mss2dsp_init(&ctx->dsp);

839 ff_qpeldsp_init(&ctx->qdsp);

840

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

842 : AV_PIX_FMT_RGB24;

843

844

845 return 0;

846 }

847

848 AVCodec ff_mss2_decoder = {

849 .name = "mss2",

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

851 .type = AVMEDIA_TYPE_VIDEO,

852 .id = AV_CODEC_ID_MSS2,

853 .priv_data_size = sizeof(MSS2Context),

854 .init = mss2_decode_init,

855 .close = mss2_decode_end,

856 .decode = mss2_decode_frame,

857 .capabilities = AV_CODEC_CAP_DR1,

858 };

mss2_decode_init

static av_cold int mss2_decode_init(AVCodecContext *avctx)

Definition: mss2.c:818

NULL

#define NULL

Definition: coverity.c:32

MSS2Context::c

MSS12Context c

Definition: mss2.c:41

val

const char const char void * val

Definition: avisynth_c.h:634

GetByteContext

Definition: bytestream.h:33

ARITH2_PADDING

#define ARITH2_PADDING

Definition: mss2.c:466

QpelDSPContext::avg_qpel_pixels_tab

qpel_mc_func avg_qpel_pixels_tab[2][16]

Definition: qpeldsp.h:74

const char * s

Definition: avisynth_c.h:631

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

arith2_get_scaled_value

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

Definition: mss2.c:66

MSS2Context::qdsp

QpelDSPContext qdsp

Definition: mss2.c:43

VC1Context

The VC1 Context.

Definition: vc1.h:173

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:181

Definition: vp9dsp_template.c:2093

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

decode_rle

static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, int pal_stride, uint8_t *rgb_dst, int rgb_stride, uint32_t *pal, int keyframe, int kf_slipt, int slice, int w, int h)

Definition: mss2.c:240

ctx

AVFormatContext * ctx

Definition: movenc-test.c:48

ArithCoder::high

int high

Definition: mss12.h:49

ff_mss12_decode_init

av_cold int ff_mss12_decode_init(MSS12Context *c, int version, SliceContext *sc1, SliceContext *sc2)

Definition: mss12.c:564

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:260

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

ff_msmpeg4_decode_init

int ff_msmpeg4_decode_init(AVCodecContext *avctx)

Definition: msmpeg4dec.c:288

AV_PIX_FMT_RGB24

packed RGB 8:8:8, 24bpp, RGBRGB...

Definition: pixfmt.h:65

MpegEncContext::end_mb_y

int end_mb_y

end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...

Definition: mpegvideo.h:151

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

MSS2DSPContext::mss2_gray_fill_masked

void(* mss2_gray_fill_masked)(uint8_t *dst, int dst_stride, int maskcolor, const uint8_t *mask, int mask_stride, int w, int h)

Definition: mss2dsp.h:42

AVCodecContext::max_b_frames

int max_b_frames

maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...

Definition: avcodec.h:1810

VC1Context::extended_mv

int extended_mv

Ext MV in P/B (not in Simple)

Definition: vc1.h:223

ArithCoder::value

int value

Definition: mss12.h:49

ff_er_frame_end

void ff_er_frame_end(ERContext *s)

Definition: error_resilience.c:872

MSS12Context::corrupted

int corrupted

Definition: mss12.h:89

arith2_rescale_interval

static void arith2_rescale_interval(ArithCoder *c, int range, int low, int high, int n)

Definition: mss2.c:76

AVPacket::size

int size

Definition: avcodec.h:1468

const char * b

Definition: vf_curves.c:109

MSS2DSPContext::mss2_blit_wmv9

void(* mss2_blit_wmv9)(uint8_t *dst, int dst_stride, const uint8_t *srcy, int srcy_stride, const uint8_t *srcu, const uint8_t *srcv, int srcuv_stride, int w, int h)

Definition: mss2dsp.h:32

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1752

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:133

Rectangle::w

int w

Definition: mss2.c:462

AVDISCARD_ALL

discard all

Definition: avcodec.h:688

VC1Context::fastuvmc

int fastuvmc

Rounding of qpel vector to hpel ? (not in Simple)

Definition: vc1.h:222

VC1Context::end_mb_x

int end_mb_x

Horizontal macroblock limit (used only by mss2)

Definition: vc1.h:393

PROFILE_MAIN

Definition: vc1_common.h:50

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:87

MSS12Context::rgb_pic

uint8_t * rgb_pic

Definition: mss12.h:83

MSS12Context::mask_stride

int mask_stride

Definition: mss12.h:82

MpegEncContext::qdsp

QpelDSPContext qdsp

Definition: mpegvideo.h:232

AVCodec

AVCodec.

Definition: avcodec.h:3392

VC1Context::frmrtq_postproc

int frmrtq_postproc

3bits,

Definition: vc1.h:219

ff_mss12_decode_rect

int ff_mss12_decode_rect(SliceContext *sc, ArithCoder *acoder, int x, int y, int width, int height)

Definition: mss12.c:528

VC1Context::bits

int bits

Definition: vc1.h:179

MSS12Context::slice_split

int slice_split

Definition: mss12.h:90

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

VC1Context::res_transtab

int res_transtab

reserved, always 0

Definition: vc1.h:188

avpriv_request_sample

void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

bits

uint8_t bits

Definition: crc.c:295

MSS12Context::pal

uint32_t pal[256]

Definition: mss12.h:77

uint8_t

Definition: audio_convert.c:194

MSS12Context::last_pal_pic

uint8_t * last_pal_pic

Definition: mss12.h:79

av_cold

#define av_cold

Definition: attributes.h:82

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:141

MSS12Context::rgb_stride

int rgb_stride

Definition: mss12.h:85

MSS12Context::keyframe

int keyframe

Definition: mss12.h:87

ff_vc1_init_common

av_cold int ff_vc1_init_common(VC1Context *v)

Init VC-1 specific tables and VC1Context members.

Definition: vc1.c:1576

MotionEstContext::qpel_put

qpel_mc_func(* qpel_put)[16]

Definition: motion_est.h:91

av_frame_ref

int av_frame_ref(AVFrame *dst, const AVFrame *src)

Set up a new reference to the data described by the source frame.

Definition: frame.c:375

Rectangle::coded

int coded

Definition: mss2.c:462

MSS2Context::split_position

int split_position

Definition: mss2.c:39

MpegEncContext::current_picture

Picture current_picture

copy of the current picture structure.

Definition: mpegvideo.h:177

vc1.h

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

qpeldsp.h

quarterpel DSP functions

VC1Context::profile

int profile

Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags...

Definition: vc1.h:218

MSS2Context

Definition: mss2.c:37

msmpeg4data.h

MSMPEG4 data tables.

AVPacket::data

uint8_t * data

Definition: avcodec.h:1467

ArithCoder::gB

GetByteContext * gB

Definition: mss12.h:52

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:212

ff_vc1_decode_end

int ff_vc1_decode_end(AVCodecContext *avctx)

Close a VC1/WMV3 decoder.

Definition: vc1dec.c:584

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

ArithCoder::get_model_sym

int(* get_model_sym)(struct ArithCoder *c, Model *m)

Definition: mss12.h:54

arith2_get_number

static int arith2_get_number(ArithCoder *c, int n)

Definition: mss2.c:94

Rectangle::h

int h

Definition: mss2.c:462

arith2_get_prob

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

Definition: mss2.c:114

wmv9_init

static av_cold int wmv9_init(AVCodecContext *avctx)

Definition: mss2.c:745

MSS12Context

Definition: mss12.h:75

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

ff_mss2dsp_init

av_cold void ff_mss2dsp_init(MSS2DSPContext *dsp)

Definition: mss2dsp.c:150

VC1Context::res_y411

int res_y411

reserved, old interlaced mode

Definition: vc1.h:184

VC1Context::overlap

int overlap

overlapped transforms in use

Definition: vc1.h:226

VC1Context::res_x8

int res_x8

reserved

Definition: vc1.h:185

decode_wmv9

static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int x, int y, int w, int h, int wmv9_mask)

Definition: mss2.c:377

AVERROR

#define AVERROR(e)

Definition: error.h:43

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:154

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:176

MpegEncContext::er

ERContext er

Definition: mpegvideo.h:550

const char * r

Definition: vf_curves.c:107

ARITH_GET_MODEL_SYM

#define ARITH_GET_MODEL_SYM(prefix)

Definition: mss12.h:118

SliceContext

Definition: mss12.h:68

MSS12Context::mvY

int mvY

Definition: mss12.h:88

MSS2DSPContext::upsample_plane

void(* upsample_plane)(uint8_t *plane, int plane_stride, int w, int h)

Definition: mss2dsp.h:45

avassert.h

simple assert() macros that are a bit more flexible than ISO C assert().

ff_vc1_decode_blocks

void ff_vc1_decode_blocks(VC1Context *v)

Definition: vc1_block.c:2929

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3399

AV_RL24

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24

Definition: bytestream.h:87

QpelDSPContext::put_qpel_pixels_tab

qpel_mc_func put_qpel_pixels_tab[2][16]

Definition: qpeldsp.h:73

MpegEncContext::gb

GetBitContext gb

Definition: mpegvideo.h:445

VC1Context::resync_marker

int resync_marker

could this stream contain resync markers

Definition: vc1.h:396

VC1Context::zz_8x4

const uint8_t * zz_8x4

Zigzag scan table for TT_8x4 coding mode.

Definition: vc1.h:241

VC1Context::res_rtm_flag

int res_rtm_flag

reserved, set to 1

Definition: vc1.h:191

MSS12Context::pal_stride

int pal_stride

Definition: mss12.h:80

ff_wmv2_scantableB

const uint8_t ff_wmv2_scantableB[64]

Definition: msmpeg4data.c:1994

VLC

Definition: get_bits.h:63

split

static char * split(char *message, char delim)

Definition: af_channelmap.c:81

arith2_init

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

Definition: mss2.c:150

ff_mpeg_flush

void ff_mpeg_flush(AVCodecContext *avctx)

Definition: mpegvideo.c:2771

MSS12Context::avctx

AVCodecContext * avctx

Definition: mss12.h:76

VC1Context::zz_4x8

const uint8_t * zz_4x8

Zigzag scan table for TT_4x8 coding mode.

Definition: vc1.h:242

ff_reget_buffer

int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)

Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...

Definition: utils.c:943

AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:266

MSS2Context::sc

SliceContext sc[2]

Definition: mss2.c:44

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:252

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1711

value

GLsizei GLboolean const GLfloat * value

Definition: opengl_enc.c:109

ff_mpeg_er_frame_start

void ff_mpeg_er_frame_start(MpegEncContext *s)

Definition: mpeg_er.c:46

ArithCoder

Definition: mss12.h:48

msmpeg4.h

AV_WB24

#define AV_WB24(p, d)

Definition: intreadwrite.h:450

ff_vc1_parse_frame_header

int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)

Definition: vc1.c:628

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:574

decode_555

static int decode_555(GetByteContext *gB, uint16_t *dst, int stride, int keyframe, int w, int h)

Definition: mss2.c:177

MpegEncContext::me

MotionEstContext me

Definition: mpegvideo.h:282

int n

Definition: avisynth_c.h:547

AVCodecContext::height

int height

Definition: avcodec.h:1711

arith2_get_consumed_bytes

static int arith2_get_consumed_bytes(ArithCoder *c)

Definition: mss2.c:136

Rectangle

Definition: mss2.c:461

bytestream2_tell

static av_always_inline int bytestream2_tell(GetByteContext *g)

Definition: bytestream.h:188

VC1Context::rangered

int rangered

RANGEREDFRM (range reduction) syntax element present at frame level.

Definition: vc1.h:189

AVFrame::format

int format

format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...

Definition: frame.h:242

VC1Context::finterpflag

int finterpflag

INTERPFRM present.

Definition: vc1.h:228

ff_mss12_decode_end

av_cold int ff_mss12_decode_end(MSS12Context *c)

Definition: mss12.c:676

MpegEncContext::loop_filter

int loop_filter

Definition: mpegvideo.h:380

VC1Context::res_sprite

int res_sprite

Simple/Main Profile sequence header.

Definition: vc1.h:183

MSS2DSPContext

Definition: mss2dsp.h:31

AV_RB24

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24

Definition: bytestream.h:87

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:209

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:449

VC1Context::multires

int multires

frame-level RESPIC syntax element present

Definition: vc1.h:186

error_resilience.h

AVCodecContext

main external API structure.

Definition: avcodec.h:1532

mpeg_er.h

ff_wmv2_scantableA

const uint8_t ff_wmv2_scantableA[64]

Definition: msmpeg4data.c:1987

mss2_decode_end

static av_cold int mss2_decode_end(AVCodecContext *avctx)

Definition: mss2.c:804

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: utils.c:894

init_vlc

#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)

Definition: get_bits.h:465

buf

void * buf

Definition: avisynth_c.h:553

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:312

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:305

Picture::f

struct AVFrame * f

Definition: mpegpicture.h:46

AV_CODEC_ID_MSS2

Definition: avcodec.h:274

VC1Context::respic

uint8_t respic

Frame-level flag for resized images.

Definition: vc1.h:274

ff_mpv_frame_start

int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)

generic function called after decoding the header and before a frame is decoded.

Definition: mpegvideo.c:1190

VC1Context::quantizer_mode

int quantizer_mode

2bits, quantizer mode used for sequence, see QUANT_*

Definition: vc1.h:227

MpegEncContext::max_b_frames

int max_b_frames

max number of b-frames for encoding

Definition: mpegvideo.h:112

MpegEncContext::pict_type

int pict_type

AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...

Definition: mpegvideo.h:209

QpelDSPContext

quarterpel DSP context

Definition: qpeldsp.h:72

MAX_WMV9_RECTANGLES

#define MAX_WMV9_RECTANGLES

Definition: mss2.c:465

VC1Context::vstransform

int vstransform

variable-size [48]x[48] transform type + info

Definition: vc1.h:225

MIN_CACHE_BITS

#define MIN_CACHE_BITS

Definition: get_bits.h:125

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:474

ff_mss2_decoder

AVCodec ff_mss2_decoder

Definition: mss2.c:848

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:192

MotionEstContext::qpel_avg

qpel_mc_func(* qpel_avg)[16]

Definition: motion_est.h:92

VC1Context::s

MpegEncContext s

Definition: vc1.h:174

MSS2Context::v

VC1Context v

Definition: mss2.c:38

MpegEncContext

MpegEncContext.

Definition: mpegvideo.h:78

ff_vc1_init_transposed_scantables

void ff_vc1_init_transposed_scantables(VC1Context *v)

Definition: vc1dec.c:400

MpegEncContext::avctx

struct AVCodecContext * avctx

Definition: mpegvideo.h:95

Rectangle::y

int y

Definition: mss2.c:462

decode

static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)

Definition: ccaption_dec.c:572

stride

GLint GLenum GLboolean GLsizei stride

Definition: opengl_enc.c:105

AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:63

GetBitContext

Definition: get_bits.h:54

internal.h

common internal api header.

ff_mss12_slicecontext_reset

void ff_mss12_slicecontext_reset(SliceContext *sc)

Definition: mss12.c:428

MSS2DSPContext::mss2_blit_wmv9_masked

void(* mss2_blit_wmv9_masked)(uint8_t *dst, int dst_stride, int maskcolor, const uint8_t *mask, int mask_stride, const uint8_t *srcy, int srcy_stride, const uint8_t *srcu, const uint8_t *srcv, int srcuv_stride, int w, int h)

Definition: mss2dsp.h:36

static double c[64]

Definition: vsrc_mptestsrc.c:87

VC1Context::res_fasttx

int res_fasttx

reserved, always 1

Definition: vc1.h:187

AV_PIX_FMT_RGB555

#define AV_PIX_FMT_RGB555

Definition: pixfmt.h:318

AVCodecContext::skip_loop_filter

enum AVDiscard skip_loop_filter