FFmpeg: libavcodec/vc1dec.c Source File

FFmpeg

[フレーム]

libavcodec

vc1dec.c

Go to the documentation of this file.

1 /*

2 * VC-1 and WMV3 decoder

6 *

7 * This file is part of FFmpeg.

8 *

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

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

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

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

13 *

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

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

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

17 * Lesser General Public License for more details.

18 *

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

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

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

22 */

24 /**

25 * @file

26 * VC-1 and WMV3 decoder

27 */

29 #include "config_components.h"

31 #include "avcodec.h"

32 #include "blockdsp.h"

33 #include "codec_internal.h"

34 #include "decode.h"

35 #include "get_bits.h"

36 #include "hwaccel_internal.h"

37 #include "hwconfig.h"

38 #include "mpeg_er.h"

39 #include "mpegutils.h"

40 #include "mpegvideo.h"

41 #include "mpegvideodec.h"

42 #include "msmpeg4_vc1_data.h"

43 #include "profiles.h"

44 #include "simple_idct.h"

45 #include "vc1.h"

46 #include "vc1data.h"

47 #include "vc1_vlc_data.h"

48 #include "libavutil/attributes.h"

49 #include "libavutil/avassert.h"

50 #include "libavutil/imgutils.h"

51 #include "libavutil/mem.h"

52 #include "libavutil/thread.h"

55 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {

56 #if CONFIG_VC1_DXVA2_HWACCEL

57 AV_PIX_FMT_DXVA2_VLD,

58 #endif

59 #if CONFIG_VC1_D3D11VA_HWACCEL

60 AV_PIX_FMT_D3D11VA_VLD,

61 AV_PIX_FMT_D3D11,

62 #endif

63 #if CONFIG_VC1_D3D12VA_HWACCEL

64 AV_PIX_FMT_D3D12,

65 #endif

66 #if CONFIG_VC1_NVDEC_HWACCEL

67 AV_PIX_FMT_CUDA,

68 #endif

69 #if CONFIG_VC1_VAAPI_HWACCEL

70 AV_PIX_FMT_VAAPI,

71 #endif

72 #if CONFIG_VC1_VDPAU_HWACCEL

73 AV_PIX_FMT_VDPAU,

74 #endif

75 AV_PIX_FMT_YUV420P,

76 AV_PIX_FMT_NONE

77 };

79 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER

81 typedef struct SpriteData {

82 /**

83 * Transform coefficients for both sprites in 16.16 fixed point format,

84 * in the order they appear in the bitstream:

85 * x scale

86 * rotation 1 (unused)

87 * x offset

88 * rotation 2 (unused)

89 * y scale

90 * y offset

91 * alpha

92 */

93 int coefs[2][7];

95 int effect_type, effect_flag;

96 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params

97 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format

98 } SpriteData;

100 static inline int get_fp_val(GetBitContext* gb)

101 {

102 return (get_bits_long(gb, 30) - (1 << 29)) << 1;

103 }

104

105 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])

106 {

107 c[1] = c[3] = 0;

108

109 switch (get_bits(gb, 2)) {

110 case 0:

111 c[0] = 1 << 16;

112 c[2] = get_fp_val(gb);

113 c[4] = 1 << 16;

114 break;

115 case 1:

116 c[0] = c[4] = get_fp_val(gb);

117 c[2] = get_fp_val(gb);

118 break;

119 case 2:

120 c[0] = get_fp_val(gb);

121 c[2] = get_fp_val(gb);

122 c[4] = get_fp_val(gb);

123 break;

124 case 3:

125 c[0] = get_fp_val(gb);

126 c[1] = get_fp_val(gb);

127 c[2] = get_fp_val(gb);

128 c[3] = get_fp_val(gb);

129 c[4] = get_fp_val(gb);

130 break;

131 }

132 c[5] = get_fp_val(gb);

133 if (get_bits1(gb))

134 c[6] = get_fp_val(gb);

135 else

136 c[6] = 1 << 16;

137 }

138

139 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)

140 {

141 AVCodecContext *avctx = v->s.avctx;

142 int sprite, i;

143

144 for (sprite = 0; sprite <= v->two_sprites; sprite++) {

145 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);

146 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])

147 avpriv_request_sample(avctx, "Non-zero rotation coefficients");

148 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");

149 for (i = 0; i < 7; i++)

150 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",

151 sd->coefs[sprite][i] / (1<<16),

152 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));

153 av_log(avctx, AV_LOG_DEBUG, "\n");

154 }

155

156 skip_bits(gb, 2);

157 if (sd->effect_type = get_bits_long(gb, 30)) {

158 switch (sd->effect_pcount1 = get_bits(gb, 4)) {

159 case 7:

160 vc1_sprite_parse_transform(gb, sd->effect_params1);

161 break;

162 case 14:

163 vc1_sprite_parse_transform(gb, sd->effect_params1);

164 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);

165 break;

166 default:

167 for (i = 0; i < sd->effect_pcount1; i++)

168 sd->effect_params1[i] = get_fp_val(gb);

169 }

170 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {

171 // effect 13 is simple alpha blending and matches the opacity above

172 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);

173 for (i = 0; i < sd->effect_pcount1; i++)

174 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",

175 sd->effect_params1[i] / (1 << 16),

176 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));

177 av_log(avctx, AV_LOG_DEBUG, "\n");

178 }

179

180 sd->effect_pcount2 = get_bits(gb, 16);

181 if (sd->effect_pcount2 > 10) {

182 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");

183 return AVERROR_INVALIDDATA;

184 } else if (sd->effect_pcount2) {

185 i = -1;

186 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");

187 while (++i < sd->effect_pcount2) {

188 sd->effect_params2[i] = get_fp_val(gb);

189 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",

190 sd->effect_params2[i] / (1 << 16),

191 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));

192 }

193 av_log(avctx, AV_LOG_DEBUG, "\n");

194 }

195 }

196 if (sd->effect_flag = get_bits1(gb))

197 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");

198

199 if (get_bits_count(gb) >= gb->size_in_bits +

200 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {

201 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");

202 return AVERROR_INVALIDDATA;

203 }

204 if (get_bits_count(gb) < gb->size_in_bits - 8)

205 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");

206

207 return 0;

208 }

209

210 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)

211 {

212 int i, plane, row, sprite;

213 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };

214 const uint8_t *src_h[2][2];

215 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;

216 int ysub[2];

217 MpegEncContext *s = &v->s;

218

219 for (i = 0; i <= v->two_sprites; i++) {

220 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);

221 xadv[i] = sd->coefs[i][0];

222 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])

223 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);

224

225 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);

226 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);

227 }

228 alpha = av_clip_uint16(sd->coefs[1][6]);

229

230 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {

231 int width = v->output_width>>!!plane;

232

233 for (row = 0; row < v->output_height>>!!plane; row++) {

234 uint8_t *dst = v->sprite_output_frame->data[plane] +

235 v->sprite_output_frame->linesize[plane] * row;

236

237 for (sprite = 0; sprite <= v->two_sprites; sprite++) {

238 const uint8_t *iplane = s->cur_pic.data[plane];

239 int iline = s->cur_pic.linesize[plane];

240 int ycoord = yoff[sprite] + yadv[sprite] * row;

241 int yline = ycoord >> 16;

242 int next_line;

243 ysub[sprite] = ycoord & 0xFFFF;

244 if (sprite) {

245 iplane = s->last_pic.data[plane];

246 iline = s->last_pic.linesize[plane];

247 }

248 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;

249 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {

250 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;

251 if (ysub[sprite])

252 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;

253 } else {

254 if (sr_cache[sprite][0] != yline) {

255 if (sr_cache[sprite][1] == yline) {

256 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);

257 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);

258 } else {

259 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);

260 sr_cache[sprite][0] = yline;

261 }

262 }

263 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {

264 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],

265 iplane + next_line, xoff[sprite],

266 xadv[sprite], width);

267 sr_cache[sprite][1] = yline + 1;

268 }

269 src_h[sprite][0] = v->sr_rows[sprite][0];

270 src_h[sprite][1] = v->sr_rows[sprite][1];

271 }

272 }

273

274 if (!v->two_sprites) {

275 if (ysub[0]) {

276 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);

277 } else {

278 memcpy(dst, src_h[0][0], width);

279 }

280 } else {

281 if (ysub[0] && ysub[1]) {

282 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],

283 src_h[1][0], src_h[1][1], ysub[1], alpha, width);

284 } else if (ysub[0]) {

285 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],

286 src_h[1][0], alpha, width);

287 } else if (ysub[1]) {

288 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],

289 src_h[0][0], (1<<16)-1-alpha, width);

290 } else {

291 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);

292 }

293 }

294 }

295

296 if (!plane) {

297 for (i = 0; i <= v->two_sprites; i++) {

298 xoff[i] >>= 1;

299 yoff[i] >>= 1;

300 }

301 }

302

303 }

304 }

305

306

307 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)

308 {

309 int ret;

310 MpegEncContext *s = &v->s;

311 AVCodecContext *avctx = s->avctx;

312 SpriteData sd;

313

314 memset(&sd, 0, sizeof(sd));

315

316 ret = vc1_parse_sprites(v, gb, &sd);

317 if (ret < 0)

318 return ret;

319

320 if (!s->cur_pic.data[0]) {

321 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");

322 return AVERROR_UNKNOWN;

323 }

324

325 if (v->two_sprites && (!s->last_pic.ptr || !s->last_pic.data[0])) {

326 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");

327 v->two_sprites = 0;

328 }

329

330 av_frame_unref(v->sprite_output_frame);

331 if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)

332 return ret;

333

334 vc1_draw_sprites(v, &sd);

335

336 return 0;

337 }

338

339 static void vc1_sprite_flush(AVCodecContext *avctx)

340 {

341 VC1Context *v = avctx->priv_data;

342 MpegEncContext *s = &v->s;

343 MPVWorkPicture *f = &s->cur_pic;

344 int plane, i;

345

346 /* Windows Media Image codecs have a convergence interval of two keyframes.

347 Since we can't enforce it, clear to black the missing sprite. This is

348 wrong but it looks better than doing nothing. */

349

350 if (f->data[0])

351 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)

352 for (i = 0; i < v->sprite_height>>!!plane; i++)

353 memset(f->data[plane] + i * f->linesize[plane],

354 plane ? 128 : 0, f->linesize[plane]);

355 }

356

357 #endif

358

359 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)

360 {

361 MpegEncContext *s = &v->s;

362 int i, ret;

363 int mb_height = FFALIGN(s->mb_height, 2);

364

365 /* Allocate mb bitplanes */

366 v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);

367 v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);

368 v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);

369 v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);

370 v->acpred_plane = av_malloc (s->mb_stride * mb_height);

371 v->over_flags_plane = av_malloc (s->mb_stride * mb_height);

372 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||

373 !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)

374 return AVERROR(ENOMEM);

375

376 v->n_allocated_blks = s->mb_width + 2;

377 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);

378 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 3 * s->mb_stride);

379 if (!v->block || !v->cbp_base)

380 return AVERROR(ENOMEM);

381 v->cbp = v->cbp_base + 2 * s->mb_stride;

382 v->ttblk_base = av_mallocz(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride);

383 if (!v->ttblk_base)

384 return AVERROR(ENOMEM);

385 v->ttblk = v->ttblk_base + 2 * s->mb_stride;

386 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride);

387 if (!v->is_intra_base)

388 return AVERROR(ENOMEM);

389 v->is_intra = v->is_intra_base + 2 * s->mb_stride;

390 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride);

391 if (!v->luma_mv_base)

392 return AVERROR(ENOMEM);

393 v->luma_mv = v->luma_mv_base + 2 * s->mb_stride;

394

395 /* allocate block type info in that way so it could be used with s->block_index[] */

396 v->mb_type_base = av_mallocz(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);

397 if (!v->mb_type_base)

398 return AVERROR(ENOMEM);

399 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;

400 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;

401 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);

402

403 /* allocate memory to store block level MV info */

404 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);

405 if (!v->blk_mv_type_base)

406 return AVERROR(ENOMEM);

407 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;

408 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));

409 if (!v->mv_f_base)

410 return AVERROR(ENOMEM);

411 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;

412 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);

413 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));

414 if (!v->mv_f_next_base)

415 return AVERROR(ENOMEM);

416 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;

417 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);

418

419 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {

420 for (i = 0; i < 4; i++)

421 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))

422 return AVERROR(ENOMEM);

423 }

424

425 ret = ff_intrax8_common_init(s->avctx, &v->x8,

426 s->block, s->block_last_index,

427 s->mb_width, s->mb_height);

428 if (ret < 0)

429 return ret;

430

431 return 0;

432 }

433

434 static enum AVPixelFormat vc1_get_format(AVCodecContext *avctx)

435 {

436 if (avctx->codec_id == AV_CODEC_ID_MSS2)

437 return AV_PIX_FMT_YUV420P;

438

439 if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY)) {

440 if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)

441 avctx->color_range = AVCOL_RANGE_MPEG;

442 return AV_PIX_FMT_GRAY8;

443 }

444

445 if (avctx->codec_id == AV_CODEC_ID_VC1IMAGE ||

446 avctx->codec_id == AV_CODEC_ID_WMV3IMAGE)

447 return AV_PIX_FMT_YUV420P;

448

449 return ff_get_format(avctx, vc1_hwaccel_pixfmt_list_420);

450 }

451

452 static void vc1_decode_reset(AVCodecContext *avctx);

453

454 av_cold int ff_vc1_decode_init(AVCodecContext *avctx)

455 {

456 VC1Context *const v = avctx->priv_data;

457 MpegEncContext *const s = &v->s;

458 int ret;

459

460 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);

461 if (ret < 0)

462 return ret;

463

464 ret = ff_mpv_decode_init(s, avctx);

465 if (ret < 0)

466 return ret;

467

468 avctx->pix_fmt = vc1_get_format(avctx);

469

470 ret = ff_mpv_common_init(s);

471 if (ret < 0)

472 return ret;

473

474 s->y_dc_scale_table = ff_wmv3_dc_scale_table;

475 s->c_dc_scale_table = ff_wmv3_dc_scale_table;

476

477 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,

478 ff_wmv1_scantable[0]);

479 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,

480 ff_wmv1_scantable[1]);

481

482 ret = vc1_decode_init_alloc_tables(v);

483 if (ret < 0) {

484 vc1_decode_reset(avctx);

485 return ret;

486 }

487 return 0;

488 }

489

490 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)

491 {

492 int i;

493 for (i = 0; i < 64; i++) {

494 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))

495 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);

496 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);

497 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);

498 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);

499 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);

500 }

501 v->left_blk_sh = 0;

502 v->top_blk_sh = 3;

503 }

504

505 static av_cold void vc1_init_static(void)

506 {

507 static VLCElem vlc_table[32372];

508 VLCInitState state = VLC_INIT_STATE(vlc_table);

509

510 VLC_INIT_STATIC_TABLE(ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,

511 vc1_norm2_bits, 1, 1,

512 vc1_norm2_codes, 1, 1, 0);

513 VLC_INIT_STATIC_TABLE(ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,

514 vc1_norm6_bits, 1, 1,

515 vc1_norm6_codes, 2, 2, 0);

516 VLC_INIT_STATIC_TABLE(ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,

517 vc1_imode_bits, 1, 1,

518 vc1_imode_codes, 1, 1, 0);

519 for (int i = 0; i < 3; i++) {

520 ff_vc1_ttmb_vlc[i] =

521 ff_vlc_init_tables(&state, VC1_TTMB_VLC_BITS, 16,

522 vc1_ttmb_bits[i], 1, 1,

523 vc1_ttmb_codes[i], 2, 2, 0);

524 ff_vc1_ttblk_vlc[i] =

525 ff_vlc_init_tables(&state, VC1_TTBLK_VLC_BITS, 8,

526 vc1_ttblk_bits[i], 1, 1,

527 vc1_ttblk_codes[i], 1, 1, 0);

528 ff_vc1_subblkpat_vlc[i] =

529 ff_vlc_init_tables(&state, VC1_SUBBLKPAT_VLC_BITS, 15,

530 vc1_subblkpat_bits[i], 1, 1,

531 vc1_subblkpat_codes[i], 1, 1, 0);

532 }

533 for (int i = 0; i < 4; i++) {

534 ff_vc1_4mv_block_pattern_vlc[i] =

535 ff_vlc_init_tables(&state, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,

536 vc1_4mv_block_pattern_bits[i], 1, 1,

537 vc1_4mv_block_pattern_codes[i], 1, 1, 0);

538 ff_vc1_cbpcy_p_vlc[i] =

539 ff_vlc_init_tables(&state, VC1_CBPCY_P_VLC_BITS, 64,

540 vc1_cbpcy_p_bits[i], 1, 1,

541 vc1_cbpcy_p_codes[i], 2, 2, 0);

542 ff_vc1_mv_diff_vlc[i] =

543 ff_vlc_init_tables(&state, VC1_MV_DIFF_VLC_BITS, 73,

544 vc1_mv_diff_bits[i], 1, 1,

545 vc1_mv_diff_codes[i], 2, 2, 0);

546 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */

547 ff_vc1_intfr_4mv_mbmode_vlc[i] =

548 ff_vlc_init_tables(&state, VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,

549 vc1_intfr_4mv_mbmode_bits[i], 1, 1,

550 vc1_intfr_4mv_mbmode_codes[i], 2, 2, 0);

551 /* initialize NON-4MV MBMODE VLC tables for the same */

552 ff_vc1_intfr_non4mv_mbmode_vlc[i] =

553 ff_vlc_init_tables(&state, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,

554 vc1_intfr_non4mv_mbmode_bits[i], 1, 1,

555 vc1_intfr_non4mv_mbmode_codes[i], 1, 1, 0);

556 /* initialize interlaced MVDATA tables (1-Ref) */

557 ff_vc1_1ref_mvdata_vlc[i] =

558 ff_vlc_init_tables(&state, VC1_1REF_MVDATA_VLC_BITS, 72,

559 vc1_1ref_mvdata_bits[i], 1, 1,

560 vc1_1ref_mvdata_codes[i], 4, 4, 0);

561 /* Initialize 2MV Block pattern VLC tables */

562 ff_vc1_2mv_block_pattern_vlc[i] =

563 ff_vlc_init_tables(&state, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,

564 vc1_2mv_block_pattern_bits[i], 1, 1,

565 vc1_2mv_block_pattern_codes[i], 1, 1, 0);

566 }

567 for (int i = 0; i < 8; i++) {

568 ff_vc1_ac_coeff_table[i] =

569 ff_vlc_init_tables(&state, AC_VLC_BITS, ff_vc1_ac_sizes[i],

570 &vc1_ac_tables[i][0][1], 8, 4,

571 &vc1_ac_tables[i][0][0], 8, 4, 0);

572 /* initialize interlaced MVDATA tables (2-Ref) */

573 ff_vc1_2ref_mvdata_vlc[i] =

574 ff_vlc_init_tables(&state, VC1_2REF_MVDATA_VLC_BITS, 126,

575 vc1_2ref_mvdata_bits[i], 1, 1,

576 vc1_2ref_mvdata_codes[i], 4, 4, 0);

577 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */

578 ff_vc1_icbpcy_vlc[i] =

579 ff_vlc_init_tables(&state, VC1_ICBPCY_VLC_BITS, 63,

580 vc1_icbpcy_p_bits[i], 1, 1,

581 vc1_icbpcy_p_codes[i], 2, 2, 0);

582 /* Initialize interlaced field picture MBMODE VLC tables */

583 ff_vc1_if_mmv_mbmode_vlc[i] =

584 ff_vlc_init_tables(&state, VC1_IF_MMV_MBMODE_VLC_BITS, 8,

585 vc1_if_mmv_mbmode_bits[i], 1, 1,

586 vc1_if_mmv_mbmode_codes[i], 1, 1, 0);

587 ff_vc1_if_1mv_mbmode_vlc[i] =

588 ff_vlc_init_tables(&state, VC1_IF_1MV_MBMODE_VLC_BITS, 6,

589 vc1_if_1mv_mbmode_bits[i], 1, 1,

590 vc1_if_1mv_mbmode_codes[i], 1, 1, 0);

591 }

592 ff_msmp4_vc1_vlcs_init_once();

593 }

594

595 /**

596 * Init VC-1 specific tables and VC1Context members

597 * @param v The VC1Context to initialize

598 * @return Status

599 */

600 av_cold void ff_vc1_init_common(VC1Context *v)

601 {

602 static AVOnce init_static_once = AV_ONCE_INIT;

603 MpegEncContext *const s = &v->s;

604

605 /* defaults */

606 v->pq = -1;

607 v->mvrange = 0; /* 7.1.1.18, p80 */

608

609 s->avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;

610 s->out_format = FMT_H263;

611

612 s->h263_pred = 1;

613 s->msmpeg4_version = MSMP4_VC1;

614

615 ff_vc1dsp_init(&v->vc1dsp);

616

617 /* For error resilience */

618 ff_qpeldsp_init(&s->qdsp);

619

620 /* VLC tables */

621 ff_thread_once(&init_static_once, vc1_init_static);

622 }

623

624 /** Initialize a VC1/WMV3 decoder

625 * @todo TODO: Handle VC-1 IDUs (Transport level?)

626 * @todo TODO: Decipher remaining bits in extra_data

627 */

628 static av_cold int vc1_decode_init(AVCodecContext *avctx)

629 {

630 VC1Context *v = avctx->priv_data;

631 MpegEncContext *s = &v->s;

632 GetBitContext gb;

633 int ret;

634

635 /* save the container output size for WMImage */

636 v->output_width = avctx->width;

637 v->output_height = avctx->height;

638

639 if (!avctx->extradata_size || !avctx->extradata)

640 return AVERROR_INVALIDDATA;

641 v->s.avctx = avctx;

642

643 ff_vc1_init_common(v);

644

645 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {

646 int count = 0;

647

648 // looks like WMV3 has a sequence header stored in the extradata

649 // advanced sequence header may be before the first frame

650 // the last byte of the extradata is a version number, 1 for the

651 // samples we can decode

652

653 ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size);

654 if (ret < 0)

655 return ret;

656

657 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)

658 return ret;

659

660 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE && !v->res_sprite) {

661 avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");

662 return AVERROR_PATCHWELCOME;

663 }

664

665 count = avctx->extradata_size*8 - get_bits_count(&gb);

666 if (count > 0) {

667 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",

668 count, get_bits_long(&gb, FFMIN(count, 32)));

669 } else if (count < 0) {

670 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);

671 }

672 } else { // VC1/WVC1/WVP2

673 const uint8_t *start = avctx->extradata;

674 const uint8_t *end = avctx->extradata + avctx->extradata_size;

675 const uint8_t *next;

676 int size, buf2_size;

677 uint8_t *buf2 = NULL;

678 int seq_initialized = 0, ep_initialized = 0;

679

680 if (avctx->extradata_size < 16) {

681 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);

682 return AVERROR_INVALIDDATA;

683 }

684

685 buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

686 if (!buf2)

687 return AVERROR(ENOMEM);

688

689 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv

690 next = start;

691 for (; next < end; start = next) {

692 next = find_next_marker(start + 4, end);

693 size = next - start - 4;

694 if (size <= 0)

695 continue;

696 buf2_size = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);

697 init_get_bits(&gb, buf2, buf2_size * 8);

698 switch (AV_RB32(start)) {

699 case VC1_CODE_SEQHDR:

700 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {

701 av_free(buf2);

702 return ret;

703 }

704 seq_initialized = 1;

705 break;

706 case VC1_CODE_ENTRYPOINT:

707 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {

708 av_free(buf2);

709 return ret;

710 }

711 ep_initialized = 1;

712 break;

713 }

714 }

715 av_free(buf2);

716 if (!seq_initialized || !ep_initialized) {

717 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");

718 return AVERROR_INVALIDDATA;

719 }

720 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);

721 }

722

723 avctx->profile = v->profile;

724 if (v->profile == PROFILE_ADVANCED)

725 avctx->level = v->level;

726

727 ff_blockdsp_init(&s->bdsp);

728 ff_h264chroma_init(&v->h264chroma, 8);

729

730 avctx->has_b_frames = !!avctx->max_b_frames;

731

732 if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)

733 avctx->color_primaries = v->color_prim;

734 if (v->transfer_char == 1 || v->transfer_char == 7)

735 avctx->color_trc = v->transfer_char;

736 if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)

737 avctx->colorspace = v->matrix_coef;

738

739 s->mb_width = (avctx->coded_width + 15) >> 4;

740 s->mb_height = (avctx->coded_height + 15) >> 4;

741

742 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {

743 ff_vc1_init_transposed_scantables(v);

744 } else {

745 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);

746 v->left_blk_sh = 3;

747 v->top_blk_sh = 0;

748 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_int16_8bit;

749 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;

750 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;

751 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;

752 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_int16_8bit;

753 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;

754 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;

755 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;

756 }

757

758 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {

759 v->sprite_width = avctx->coded_width;

760 v->sprite_height = avctx->coded_height;

761

762 avctx->coded_width = avctx->width = v->output_width;

763 avctx->coded_height = avctx->height = v->output_height;

764

765 // prevent 16.16 overflows

766 if (v->sprite_width > 1 << 14 ||

767 v->sprite_height > 1 << 14 ||

768 v->output_width > 1 << 14 ||

769 v->output_height > 1 << 14) {

770 return AVERROR_INVALIDDATA;

771 }

772

773 if ((v->sprite_width&1) || (v->sprite_height&1)) {

774 avpriv_request_sample(avctx, "odd sprites support");

775 return AVERROR_PATCHWELCOME;

776 }

777 }

778 return 0;

779 }

780

781 static av_cold void vc1_decode_reset(AVCodecContext *avctx)

782 {

783 VC1Context *v = avctx->priv_data;

784 int i;

785

786 av_frame_free(&v->sprite_output_frame);

787

788 for (i = 0; i < 4; i++)

789 av_freep(&v->sr_rows[i >> 1][i & 1]);

790 ff_mpv_common_end(&v->s);

791 memset(v->s.block_index, 0, sizeof(v->s.block_index));

792 av_freep(&v->mv_type_mb_plane);

793 av_freep(&v->direct_mb_plane);

794 av_freep(&v->forward_mb_plane);

795 av_freep(&v->fieldtx_plane);

796 av_freep(&v->acpred_plane);

797 av_freep(&v->over_flags_plane);

798 av_freep(&v->mb_type_base);

799 av_freep(&v->blk_mv_type_base);

800 av_freep(&v->mv_f_base);

801 av_freep(&v->mv_f_next_base);

802 av_freep(&v->block);

803 av_freep(&v->cbp_base);

804 av_freep(&v->ttblk_base);

805 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]

806 av_freep(&v->luma_mv_base);

807 ff_intrax8_common_end(&v->x8);

808 }

809

810 /**

811 * Close a MSS2/VC1/WMV3 decoder

812 */

813 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)

814 {

815 vc1_decode_reset(avctx);

816 return ff_mpv_decode_close(avctx);

817 }

818

819 /** Decode a VC1/WMV3 frame

820 * @todo TODO: Handle VC-1 IDUs (Transport level?)

821 */

822 static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,

823 int *got_frame, AVPacket *avpkt)

824 {

825 const uint8_t *buf = avpkt->data;

826 int buf_size = avpkt->size, n_slices = 0, i, ret;

827 VC1Context *v = avctx->priv_data;

828 MpegEncContext *s = &v->s;

829 uint8_t *buf2 = NULL;

830 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;

831 int mb_height, n_slices1=-1;

832 struct {

833 uint8_t *buf;

834 GetBitContext gb;

835 int mby_start;

836 const uint8_t *rawbuf;

837 int raw_size;

838 } *slices = NULL, *tmp;

839 unsigned slices_allocated = 0;

840

841 v->second_field = 0;

842

843 if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)

844 s->low_delay = 1;

845

846 /* no supplementary picture */

847 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {

848 /* special case for last picture */

849 if (s->low_delay == 0 && s->next_pic.ptr) {

850 if ((ret = av_frame_ref(pict, s->next_pic.ptr->f)) < 0)

851 return ret;

852 ff_mpv_unref_picture(&s->next_pic);

853

854 *got_frame = 1;

855 }

856

857 return buf_size;

858 }

859

860 //for advanced profile we may need to parse and unescape data

861 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {

862 int buf_size2 = 0;

863 size_t next_allocated = 0;

864 buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);

865 if (!buf2)

866 return AVERROR(ENOMEM);

867

868 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */

869 const uint8_t *start, *end, *next;

870 int size;

871

872 next = buf;

873 for (start = buf, end = buf + buf_size; next < end; start = next) {

874 next = find_next_marker(start + 4, end);

875 size = next - start - 4;

876 if (size <= 0) continue;

877 switch (AV_RB32(start)) {

878 case VC1_CODE_FRAME:

879 buf_start = start;

880 buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);

881 break;

882 case VC1_CODE_FIELD: {

883 int buf_size3;

884 buf_start_second_field = start;

885 av_size_mult(sizeof(*slices), n_slices+1, &next_allocated);

886 tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL;

887 if (!tmp) {

888 ret = AVERROR(ENOMEM);

889 goto err;

890 }

891 slices = tmp;

892 slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);

893 if (!slices[n_slices].buf) {

894 ret = AVERROR(ENOMEM);

895 goto err;

896 }

897 buf_size3 = v->vc1dsp.vc1_unescape_buffer(start + 4, size,

898 slices[n_slices].buf);

899 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,

900 buf_size3 << 3);

901 slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;

902 slices[n_slices].rawbuf = start;

903 slices[n_slices].raw_size = size + 4;

904 n_slices1 = n_slices - 1; // index of the last slice of the first field

905 n_slices++;

906 break;

907 }

908 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */

909 buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);

910 init_get_bits(&s->gb, buf2, buf_size2 * 8);

911 ff_vc1_decode_entry_point(avctx, v, &s->gb);

912 break;

913 case VC1_CODE_SLICE: {

914 int buf_size3;

915 av_size_mult(sizeof(*slices), n_slices+1, &next_allocated);

916 tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL;

917 if (!tmp) {

918 ret = AVERROR(ENOMEM);

919 goto err;

920 }

921 slices = tmp;

922 slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);

923 if (!slices[n_slices].buf) {

924 ret = AVERROR(ENOMEM);

925 goto err;

926 }

927 buf_size3 = v->vc1dsp.vc1_unescape_buffer(start + 4, size,

928 slices[n_slices].buf);

929 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,

930 buf_size3 << 3);

931 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);

932 slices[n_slices].rawbuf = start;

933 slices[n_slices].raw_size = size + 4;

934 n_slices++;

935 break;

936 }

937 }

938 }

939 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */

940 const uint8_t *divider;

941 int buf_size3;

942

943 divider = find_next_marker(buf, buf + buf_size);

944 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {

945 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");

946 ret = AVERROR_INVALIDDATA;

947 goto err;

948 } else { // found field marker, unescape second field

949 buf_start_second_field = divider;

950 av_size_mult(sizeof(*slices), n_slices+1, &next_allocated);

951 tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL;

952 if (!tmp) {

953 ret = AVERROR(ENOMEM);

954 goto err;

955 }

956 slices = tmp;

957 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);

958 if (!slices[n_slices].buf) {

959 ret = AVERROR(ENOMEM);

960 goto err;

961 }

962 buf_size3 = v->vc1dsp.vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);

963 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,

964 buf_size3 << 3);

965 slices[n_slices].mby_start = s->mb_height + 1 >> 1;

966 slices[n_slices].rawbuf = divider;

967 slices[n_slices].raw_size = buf + buf_size - divider;

968 n_slices1 = n_slices - 1;

969 n_slices++;

970 }

971 buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, divider - buf, buf2);

972 } else {

973 buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, buf_size, buf2);

974 }

975 init_get_bits(&s->gb, buf2, buf_size2*8);

976 } else{

977 ret = init_get_bits8(&s->gb, buf, buf_size);

978 if (ret < 0)

979 return ret;

980 }

981

982 if (v->res_sprite) {

983 v->new_sprite = !get_bits1(&s->gb);

984 v->two_sprites = get_bits1(&s->gb);

985 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means

986 we're using the sprite compositor. These are intentionally kept separate

987 so you can get the raw sprites by using the wmv3 decoder for WMVP or

988 the vc1 one for WVP2 */

989 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {

990 if (v->new_sprite) {

991 // switch AVCodecContext parameters to those of the sprites

992 avctx->width = avctx->coded_width = v->sprite_width;

993 avctx->height = avctx->coded_height = v->sprite_height;

994 } else {

995 goto image;

996 }

997 }

998 }

999

1000 if (s->context_initialized &&

1001 (s->width != avctx->coded_width ||

1002 s->height != avctx->coded_height)) {

1003 vc1_decode_reset(avctx);

1004 }

1005

1006 if (!s->context_initialized) {

1007 ret = ff_vc1_decode_init(avctx);

1008 if (ret < 0)

1009 goto err;

1010

1011 s->low_delay = !avctx->has_b_frames || v->res_sprite;

1012

1013 if (v->profile == PROFILE_ADVANCED) {

1014 if(avctx->coded_width<=1 || avctx->coded_height<=1) {

1015 ret = AVERROR_INVALIDDATA;

1016 goto err;

1017 }

1018 s->h_edge_pos = avctx->coded_width;

1019 s->v_edge_pos = avctx->coded_height;

1020 }

1021 }

1022

1023 // do parse frame header

1024 v->pic_header_flag = 0;

1025 v->first_pic_header_flag = 1;

1026 if (v->profile < PROFILE_ADVANCED) {

1027 if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {

1028 goto err;

1029 }

1030 } else {

1031 if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {

1032 goto err;

1033 }

1034 }

1035 v->first_pic_header_flag = 0;

1036

1037 if (avctx->debug & FF_DEBUG_PICT_INFO)

1038 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));

1039

1040 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)

1041 && s->pict_type != AV_PICTURE_TYPE_I) {

1042 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");

1043 ret = AVERROR_INVALIDDATA;

1044 goto err;

1045 }

1046 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)

1047 && v->field_mode) {

1048 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");

1049 ret = AVERROR_INVALIDDATA;

1050 goto err;

1051 }

1052 if ((s->mb_height >> v->field_mode) == 0) {

1053 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");

1054 ret = AVERROR_INVALIDDATA;

1055 goto err;

1056 }

1057

1058 /* skip B-frames if we don't have reference frames */

1059 if (!s->last_pic.ptr && s->pict_type == AV_PICTURE_TYPE_B) {

1060 av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");

1061 goto end;

1062 }

1063 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||

1064 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||

1065 avctx->skip_frame >= AVDISCARD_ALL) {

1066 goto end;

1067 }

1068

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

1070 goto err;

1071 }

1072

1073 v->s.cur_pic.ptr->field_picture = v->field_mode;

1074 v->s.cur_pic.ptr->f->flags |= AV_FRAME_FLAG_INTERLACED * (v->fcm != PROGRESSIVE);

1075 v->s.cur_pic.ptr->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * !!v->tff;

1076 v->last_interlaced = v->s.last_pic.ptr ? v->s.last_pic.ptr->f->flags & AV_FRAME_FLAG_INTERLACED : 0;

1077 v->next_interlaced = v->s.next_pic.ptr ? v->s.next_pic.ptr->f->flags & AV_FRAME_FLAG_INTERLACED : 0;

1078

1079 // process pulldown flags

1080 s->cur_pic.ptr->f->repeat_pict = 0;

1081 // Pulldown flags are only valid when 'broadcast' has been set.

1082 if (v->rff) {

1083 // repeat field

1084 s->cur_pic.ptr->f->repeat_pict = 1;

1085 } else if (v->rptfrm) {

1086 // repeat frames

1087 s->cur_pic.ptr->f->repeat_pict = v->rptfrm * 2;

1088 }

1089

1090 if (avctx->hwaccel) {

1091 const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);

1092 s->mb_y = 0;

1093 if (v->field_mode && buf_start_second_field) {

1094 // decode first field

1095 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;

1096 ret = hwaccel->start_frame(avctx, buf_start,

1097 buf_start_second_field - buf_start);

1098 if (ret < 0)

1099 goto err;

1100

1101 if (n_slices1 == -1) {

1102 // no slices, decode the field as-is

1103 ret = hwaccel->decode_slice(avctx, buf_start,

1104 buf_start_second_field - buf_start);

1105 if (ret < 0)

1106 goto err;

1107 } else {

1108 ret = hwaccel->decode_slice(avctx, buf_start,

1109 slices[0].rawbuf - buf_start);

1110 if (ret < 0)

1111 goto err;

1112

1113 for (i = 0 ; i < n_slices1 + 1; i++) {

1114 s->gb = slices[i].gb;

1115 s->mb_y = slices[i].mby_start;

1116

1117 v->pic_header_flag = get_bits1(&s->gb);

1118 if (v->pic_header_flag) {

1119 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {

1120 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");

1121 ret = AVERROR_INVALIDDATA;

1122 if (avctx->err_recognition & AV_EF_EXPLODE)

1123 goto err;

1124 continue;

1125 }

1126 }

1127

1128 ret = hwaccel->decode_slice(avctx, slices[i].rawbuf,

1129 slices[i].raw_size);

1130 if (ret < 0)

1131 goto err;

1132 }

1133 }

1134

1135 if ((ret = hwaccel->end_frame(avctx)) < 0)

1136 goto err;

1137

1138 // decode second field

1139 s->gb = slices[n_slices1 + 1].gb;

1140 s->mb_y = slices[n_slices1 + 1].mby_start;

1141 s->picture_structure = PICT_TOP_FIELD + v->tff;

1142 v->second_field = 1;

1143 v->pic_header_flag = 0;

1144 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {

1145 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");

1146 ret = AVERROR_INVALIDDATA;

1147 goto err;

1148 }

1149 v->s.cur_pic.ptr->f->pict_type = v->s.pict_type;

1150

1151 ret = hwaccel->start_frame(avctx, buf_start_second_field,

1152 (buf + buf_size) - buf_start_second_field);

1153 if (ret < 0)

1154 goto err;

1155

1156 if (n_slices - n_slices1 == 2) {

1157 // no slices, decode the field as-is

1158 ret = hwaccel->decode_slice(avctx, buf_start_second_field,

1159 (buf + buf_size) - buf_start_second_field);

1160 if (ret < 0)

1161 goto err;

1162 } else {

1163 ret = hwaccel->decode_slice(avctx, buf_start_second_field,

1164 slices[n_slices1 + 2].rawbuf - buf_start_second_field);

1165 if (ret < 0)

1166 goto err;

1167

1168 for (i = n_slices1 + 2; i < n_slices; i++) {

1169 s->gb = slices[i].gb;

1170 s->mb_y = slices[i].mby_start;

1171

1172 v->pic_header_flag = get_bits1(&s->gb);

1173 if (v->pic_header_flag) {

1174 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {

1175 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");

1176 ret = AVERROR_INVALIDDATA;

1177 if (avctx->err_recognition & AV_EF_EXPLODE)

1178 goto err;

1179 continue;

1180 }

1181 }

1182

1183 ret = hwaccel->decode_slice(avctx, slices[i].rawbuf,

1184 slices[i].raw_size);

1185 if (ret < 0)

1186 goto err;

1187 }

1188 }

1189

1190 if ((ret = hwaccel->end_frame(avctx)) < 0)

1191 goto err;

1192 } else {

1193 s->picture_structure = PICT_FRAME;

1194 ret = hwaccel->start_frame(avctx, buf_start,

1195 (buf + buf_size) - buf_start);

1196 if (ret < 0)

1197 goto err;

1198

1199 if (n_slices == 0) {

1200 // no slices, decode the frame as-is

1201 ret = hwaccel->decode_slice(avctx, buf_start,

1202 (buf + buf_size) - buf_start);

1203 if (ret < 0)

1204 goto err;

1205 } else {

1206 // decode the frame part as the first slice

1207 ret = hwaccel->decode_slice(avctx, buf_start,

1208 slices[0].rawbuf - buf_start);

1209 if (ret < 0)

1210 goto err;

1211

1212 // and process the slices as additional slices afterwards

1213 for (i = 0 ; i < n_slices; i++) {

1214 s->gb = slices[i].gb;

1215 s->mb_y = slices[i].mby_start;

1216

1217 v->pic_header_flag = get_bits1(&s->gb);

1218 if (v->pic_header_flag) {

1219 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {

1220 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");

1221 ret = AVERROR_INVALIDDATA;

1222 if (avctx->err_recognition & AV_EF_EXPLODE)

1223 goto err;

1224 continue;

1225 }

1226 }

1227

1228 ret = hwaccel->decode_slice(avctx, slices[i].rawbuf,

1229 slices[i].raw_size);

1230 if (ret < 0)

1231 goto err;

1232 }

1233 }

1234 if ((ret = hwaccel->end_frame(avctx)) < 0)

1235 goto err;

1236 }

1237 } else {

1238 int header_ret = 0;

1239

1240 ff_mpeg_er_frame_start(s);

1241

1242 v->end_mb_x = s->mb_width;

1243 if (v->field_mode) {

1244 s->cur_pic.linesize[0] <<= 1;

1245 s->cur_pic.linesize[1] <<= 1;

1246 s->cur_pic.linesize[2] <<= 1;

1247 s->linesize <<= 1;

1248 s->uvlinesize <<= 1;

1249 }

1250 mb_height = s->mb_height >> v->field_mode;

1251

1252 av_assert0 (mb_height > 0);

1253

1254 for (i = 0; i <= n_slices; i++) {

1255 if (i > 0 && slices[i - 1].mby_start >= mb_height) {

1256 if (v->field_mode <= 0) {

1257 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "

1258 "picture boundary (%d >= %d)\n", i,

1259 slices[i - 1].mby_start, mb_height);

1260 continue;

1261 }

1262 v->second_field = 1;

1263 av_assert0((s->mb_height & 1) == 0);

1264 v->blocks_off = s->b8_stride * (s->mb_height&~1);

1265 v->mb_off = s->mb_stride * s->mb_height >> 1;

1266 } else {

1267 v->second_field = 0;

1268 v->blocks_off = 0;

1269 v->mb_off = 0;

1270 }

1271 if (i) {

1272 v->pic_header_flag = 0;

1273 if (v->field_mode && i == n_slices1 + 2) {

1274 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {

1275 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");

1276 ret = AVERROR_INVALIDDATA;

1277 if (avctx->err_recognition & AV_EF_EXPLODE)

1278 goto err;

1279 continue;

1280 }

1281 } else if (get_bits1(&s->gb)) {

1282 v->pic_header_flag = 1;

1283 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {

1284 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");

1285 ret = AVERROR_INVALIDDATA;

1286 if (avctx->err_recognition & AV_EF_EXPLODE)

1287 goto err;

1288 continue;

1289 }

1290 }

1291 }

1292 if (header_ret < 0)

1293 continue;

1294 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);

1295 if (!v->field_mode || v->second_field)

1296 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);

1297 else {

1298 if (i >= n_slices) {

1299 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");

1300 continue;

1301 }

1302 s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);

1303 }

1304 if (s->end_mb_y <= s->start_mb_y) {

1305 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);

1306 continue;

1307 }

1308 if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||

1309 (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&

1310 !v->cbpcy_vlc) {

1311 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");

1312 continue;

1313 }

1314 ff_vc1_decode_blocks(v);

1315 if (i != n_slices) {

1316 s->gb = slices[i].gb;

1317 }

1318 }

1319 if (v->field_mode) {

1320 v->second_field = 0;

1321 s->cur_pic.linesize[0] >>= 1;

1322 s->cur_pic.linesize[1] >>= 1;

1323 s->cur_pic.linesize[2] >>= 1;

1324 s->linesize >>= 1;

1325 s->uvlinesize >>= 1;

1326 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {

1327 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);

1328 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);

1329 }

1330 }

1331 ff_dlog(s->avctx, "Consumed %i/%i bits\n",

1332 get_bits_count(&s->gb), s->gb.size_in_bits);

1333 // if (get_bits_count(&s->gb) > buf_size * 8)

1334 // return -1;

1335 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {

1336 ret = AVERROR_INVALIDDATA;

1337 goto err;

1338 }

1339 if ( !v->field_mode

1340 && avctx->codec_id != AV_CODEC_ID_WMV3IMAGE

1341 && avctx->codec_id != AV_CODEC_ID_VC1IMAGE)

1342 ff_er_frame_end(&s->er, NULL);

1343 }

1344

1345 ff_mpv_frame_end(s);

1346

1347 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {

1348 image:

1349 avctx->width = avctx->coded_width = v->output_width;

1350 avctx->height = avctx->coded_height = v->output_height;

1351 if (avctx->skip_frame >= AVDISCARD_NONREF)

1352 goto end;

1353 if (!v->sprite_output_frame &&

1354 !(v->sprite_output_frame = av_frame_alloc())) {

1355 ret = AVERROR(ENOMEM);

1356 goto err;

1357 }

1358 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER

1359 if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)

1360 goto err;

1361 #endif

1362 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)

1363 goto err;

1364 *got_frame = 1;

1365 } else {

1366 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {

1367 if ((ret = av_frame_ref(pict, s->cur_pic.ptr->f)) < 0)

1368 goto err;

1369 if (!v->field_mode)

1370 ff_print_debug_info(s, s->cur_pic.ptr, pict);

1371 *got_frame = 1;

1372 } else if (s->last_pic.ptr) {

1373 if ((ret = av_frame_ref(pict, s->last_pic.ptr->f)) < 0)

1374 goto err;

1375 if (!v->field_mode)

1376 ff_print_debug_info(s, s->last_pic.ptr, pict);

1377 *got_frame = 1;

1378 }

1379 }

1380

1381 end:

1382 av_free(buf2);

1383 for (i = 0; i < n_slices; i++)

1384 av_free(slices[i].buf);

1385 av_free(slices);

1386 return buf_size;

1387

1388 err:

1389 av_free(buf2);

1390 for (i = 0; i < n_slices; i++)

1391 av_free(slices[i].buf);

1392 av_free(slices);

1393 return ret;

1394 }

1395

1396

1397 const FFCodec ff_vc1_decoder = {

1398 .p.name = "vc1",

1399 CODEC_LONG_NAME("SMPTE VC-1"),

1400 .p.type = AVMEDIA_TYPE_VIDEO,

1401 .p.id = AV_CODEC_ID_VC1,

1402 .priv_data_size = sizeof(VC1Context),

1403 .init = vc1_decode_init,

1404 .close = ff_vc1_decode_end,

1405 FF_CODEC_DECODE_CB(vc1_decode_frame),

1406 .flush = ff_mpeg_flush,

1407 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,

1408 .hw_configs = (const AVCodecHWConfigInternal *const []) {

1409 #if CONFIG_VC1_DXVA2_HWACCEL

1410 HWACCEL_DXVA2(vc1),

1411 #endif

1412 #if CONFIG_VC1_D3D11VA_HWACCEL

1413 HWACCEL_D3D11VA(vc1),

1414 #endif

1415 #if CONFIG_VC1_D3D11VA2_HWACCEL

1416 HWACCEL_D3D11VA2(vc1),

1417 #endif

1418 #if CONFIG_VC1_D3D12VA_HWACCEL

1419 HWACCEL_D3D12VA(vc1),

1420 #endif

1421 #if CONFIG_VC1_NVDEC_HWACCEL

1422 HWACCEL_NVDEC(vc1),

1423 #endif

1424 #if CONFIG_VC1_VAAPI_HWACCEL

1425 HWACCEL_VAAPI(vc1),

1426 #endif

1427 #if CONFIG_VC1_VDPAU_HWACCEL

1428 HWACCEL_VDPAU(vc1),

1429 #endif

1430 NULL

1431 },

1432 .p.profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)

1433 };

1434

1435 #if CONFIG_WMV3_DECODER

1436 const FFCodec ff_wmv3_decoder = {

1437 .p.name = "wmv3",

1438 CODEC_LONG_NAME("Windows Media Video 9"),

1439 .p.type = AVMEDIA_TYPE_VIDEO,

1440 .p.id = AV_CODEC_ID_WMV3,

1441 .priv_data_size = sizeof(VC1Context),

1442 .init = vc1_decode_init,

1443 .close = ff_vc1_decode_end,

1444 FF_CODEC_DECODE_CB(vc1_decode_frame),

1445 .flush = ff_mpeg_flush,

1446 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,

1447 .hw_configs = (const AVCodecHWConfigInternal *const []) {

1448 #if CONFIG_WMV3_DXVA2_HWACCEL

1449 HWACCEL_DXVA2(wmv3),

1450 #endif

1451 #if CONFIG_WMV3_D3D11VA_HWACCEL

1452 HWACCEL_D3D11VA(wmv3),

1453 #endif

1454 #if CONFIG_WMV3_D3D11VA2_HWACCEL

1455 HWACCEL_D3D11VA2(wmv3),

1456 #endif

1457 #if CONFIG_WMV3_D3D12VA_HWACCEL

1458 HWACCEL_D3D12VA(wmv3),

1459 #endif

1460 #if CONFIG_WMV3_NVDEC_HWACCEL

1461 HWACCEL_NVDEC(wmv3),

1462 #endif

1463 #if CONFIG_WMV3_VAAPI_HWACCEL

1464 HWACCEL_VAAPI(wmv3),

1465 #endif

1466 #if CONFIG_WMV3_VDPAU_HWACCEL

1467 HWACCEL_VDPAU(wmv3),

1468 #endif

1469 NULL

1470 },

1471 .p.profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)

1472 };

1473 #endif

1474

1475 #if CONFIG_WMV3IMAGE_DECODER

1476 const FFCodec ff_wmv3image_decoder = {

1477 .p.name = "wmv3image",

1478 CODEC_LONG_NAME("Windows Media Video 9 Image"),

1479 .p.type = AVMEDIA_TYPE_VIDEO,

1480 .p.id = AV_CODEC_ID_WMV3IMAGE,

1481 .priv_data_size = sizeof(VC1Context),

1482 .init = vc1_decode_init,

1483 .close = ff_vc1_decode_end,

1484 FF_CODEC_DECODE_CB(vc1_decode_frame),

1485 .p.capabilities = AV_CODEC_CAP_DR1,

1486 .flush = vc1_sprite_flush,

1487 };

1488 #endif

1489

1490 #if CONFIG_VC1IMAGE_DECODER

1491 const FFCodec ff_vc1image_decoder = {

1492 .p.name = "vc1image",

1493 CODEC_LONG_NAME("Windows Media Video 9 Image v2"),

1494 .p.type = AVMEDIA_TYPE_VIDEO,

1495 .p.id = AV_CODEC_ID_VC1IMAGE,

1496 .priv_data_size = sizeof(VC1Context),

1497 .init = vc1_decode_init,

1498 .close = ff_vc1_decode_end,

1499 FF_CODEC_DECODE_CB(vc1_decode_frame),

1500 .p.capabilities = AV_CODEC_CAP_DR1,

1501 .flush = vc1_sprite_flush,

1502 };

1503 #endif

PICT_FRAME

#define PICT_FRAME

Definition: mpegutils.h:33

HWACCEL_D3D12VA

#define HWACCEL_D3D12VA(codec)

Definition: hwconfig.h:80

av_size_mult

int av_size_mult(size_t a, size_t b, size_t *r)

Multiply two size_t values checking for overflow.

Definition: mem.c:567

ff_mpv_common_init

av_cold int ff_mpv_common_init(MpegEncContext *s)

init common structure for both encoder and decoder.

Definition: mpegvideo.c:687

VC1DSPContext::sprite_v_double_noscale

void(* sprite_v_double_noscale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src2a, int alpha, int width)

Definition: vc1dsp.h:69

hwconfig.h

AVCodecContext::hwaccel

const struct AVHWAccel * hwaccel

Hardware accelerator in use.

Definition: avcodec.h:1437

VC1Context::zz_8x8

uint8_t zz_8x8[4][64]

Zigzag table for TT_8x8, permuted for IDCT.

Definition: vc1.h:237

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

ff_simple_idct44_add

void ff_simple_idct44_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)

Definition: simple_idct.c:224

VC1Context::new_sprite

int new_sprite

Frame decoding info for sprite modes.

Definition: vc1.h:376

AV_PIX_FMT_CUDA

@ AV_PIX_FMT_CUDA

HW acceleration through CUDA.

Definition: pixfmt.h:260

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

AV_EF_EXPLODE

#define AV_EF_EXPLODE

abort decoding on minor error detection

Definition: defs.h:51

vc1_cbpcy_p_bits

static const uint8_t vc1_cbpcy_p_bits[4][64]

Definition: vc1_vlc_data.h:501

av_clip

#define av_clip

Definition: common.h:100

VC1Context::two_sprites

int two_sprites

Definition: vc1.h:377

blockdsp.h

VC1Context

The VC1 Context.

Definition: vc1.h:173

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

PROGRESSIVE

@ PROGRESSIVE

in the bitstream is reported as 00b

Definition: vc1.h:149

AVCodecContext::colorspace

enum AVColorSpace colorspace

YUV colorspace type.

Definition: avcodec.h:691

AC_VLC_BITS

#define AC_VLC_BITS

Definition: intrax8.c:42

ff_get_format

int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)

Select the (possibly hardware accelerated) pixel format.

Definition: decode.c:1272

vc1_hwaccel_pixfmt_list_420

static enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[]

Definition: vc1dec.c:55

ff_vc1image_decoder

const FFCodec ff_vc1image_decoder

VC1Context::cbp

uint32_t * cbp

Definition: vc1.h:389

vc1_intfr_non4mv_mbmode_bits

static const uint8_t vc1_intfr_non4mv_mbmode_bits[4][9]

Definition: vc1_vlc_data.h:112

VC1Context::end_mb_x

int end_mb_x

Horizontal macroblock limit (used only by mss2)

Definition: vc1.h:396

VC1Context::interlace

int interlace

Progressive/interlaced (RPTFTM syntax element)

Definition: vc1.h:199

thread.h

vc1.h

vc1_subblkpat_codes

static const uint8_t vc1_subblkpat_codes[3][15]

Definition: vc1_vlc_data.h:744

MpegEncContext::block_index

int block_index[6]

index to current MB in block based arrays with edges

Definition: mpegvideo.h:292

VC1DSPContext::vc1_inv_trans_4x4

void(* vc1_inv_trans_4x4)(uint8_t *dest, ptrdiff_t stride, int16_t *block)

Definition: vc1dsp.h:40

AVCodecContext::err_recognition

int err_recognition

Error recognition; may misdetect some more or less valid parts as errors.

Definition: avcodec.h:1430

get_bits_long

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

Read 0-32 bits.

Definition: get_bits.h:421

vc1_2ref_mvdata_bits

static const uint8_t vc1_2ref_mvdata_bits[8][126]

Definition: vc1_vlc_data.h:389

ff_qpeldsp_init

av_cold void ff_qpeldsp_init(QpelDSPContext *c)

Definition: qpeldsp.c:784

vc1_2mv_block_pattern_bits

static const uint8_t vc1_2mv_block_pattern_bits[4][4]

Definition: vc1_vlc_data.h:85

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:266

GetBitContext::size_in_bits

int size_in_bits

Definition: get_bits.h:111

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:162

VC1Context::sprite_height

int sprite_height

Definition: vc1.h:379

VC1Context::left_blk_sh

int left_blk_sh

Definition: vc1.h:238

AVFrame

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

Definition: frame.h:389

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

AVCodecContext::color_trc

enum AVColorTransferCharacteristic color_trc

Color Transfer Characteristic.

Definition: avcodec.h:684

HWACCEL_DXVA2

#define HWACCEL_DXVA2(codec)

Definition: hwconfig.h:64

ff_simple_idct84_add

void ff_simple_idct84_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)

Definition: simple_idct.c:194

AVPacket::data

uint8_t * data

Definition: packet.h:539

vc1_intfr_4mv_mbmode_bits

static const uint8_t vc1_intfr_4mv_mbmode_bits[4][15]

Definition: vc1_vlc_data.h:97

HWACCEL_D3D11VA2

#define HWACCEL_D3D11VA2(codec)

Definition: hwconfig.h:66

VC1_SUBBLKPAT_VLC_BITS

#define VC1_SUBBLKPAT_VLC_BITS

Definition: vc1data.h:79

VC1Context::cbp_base

uint32_t * cbp_base

Definition: vc1.h:389

VC1Context::mv_type_mb_plane

uint8_t * mv_type_mb_plane

bitplane for mv_type == (4MV)

Definition: vc1.h:284

VC1Context::last_interlaced

int last_interlaced

Definition: vc1.h:296

AV_PIX_FMT_D3D11VA_VLD

@ AV_PIX_FMT_D3D11VA_VLD

HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...

Definition: pixfmt.h:254

FFCodec

Definition: codec_internal.h:127

PICT_BOTTOM_FIELD

#define PICT_BOTTOM_FIELD

Definition: mpegutils.h:32

VC1_CBPCY_P_VLC_BITS

#define VC1_CBPCY_P_VLC_BITS

Definition: vc1data.h:69

VC1DSPContext::vc1_inv_trans_8x8_dc

void(* vc1_inv_trans_8x8_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)

Definition: vc1dsp.h:41

mpegvideo.h

MpegEncContext::avctx

struct AVCodecContext * avctx

Definition: mpegvideo.h:91

AVFrame::flags

int flags

Frame flags, a combination of AV_FRAME_FLAGS.

Definition: frame.h:661

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

VC1Context::next_interlaced

int next_interlaced

whether last_pic, next_pic is interlaced

Definition: vc1.h:296

VC1DSPContext::vc1_inv_trans_4x4_dc

void(* vc1_inv_trans_4x4_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)

Definition: vc1dsp.h:44

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:73

vc1_norm2_bits

static const uint8_t vc1_norm2_bits[4]

Definition: vc1_vlc_data.h:48

VC1Context::output_height

int output_height

Definition: vc1.h:379

VC1Context::luma_mv

int16_t((* luma_mv)[2]

Definition: vc1.h:391

mpegutils.h

vc1_ttmb_bits

static const uint8_t vc1_ttmb_bits[3][16]

Definition: vc1_vlc_data.h:701

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:514

vc1_intfr_4mv_mbmode_codes

static const uint16_t vc1_intfr_4mv_mbmode_codes[4][15]

Definition: vc1_vlc_data.h:90

FF_DEBUG_PICT_INFO

#define FF_DEBUG_PICT_INFO

Definition: avcodec.h:1407

VC1Context::rptfrm

uint8_t rptfrm

Definition: vc1.h:311

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:410

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

find_next_marker

static const av_always_inline uint8_t * find_next_marker(const uint8_t *src, const uint8_t *end)

Find VC-1 marker in buffer.

Definition: vc1_common.h:59

AV_FRAME_FLAG_TOP_FIELD_FIRST

#define AV_FRAME_FLAG_TOP_FIELD_FIRST

A flag to mark frames where the top field is displayed first if the content is interlaced.

Definition: frame.h:653

ff_vc1_parse_frame_header

int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)

Definition: vc1.c:624

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:381

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:335

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

MpegEncContext::pict_type

int pict_type

AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...

Definition: mpegvideo.h:206

FFHWAccel

Definition: hwaccel_internal.h:34

VC1_INTFR_NON4MV_MBMODE_VLC_BITS

#define VC1_INTFR_NON4MV_MBMODE_VLC_BITS

Definition: vc1data.h:83

AVCodecContext::skip_frame

enum AVDiscard skip_frame

Skip decoding for selected frames.

Definition: avcodec.h:1830

ff_vc1_if_1mv_mbmode_vlc

const VLCElem * ff_vc1_if_1mv_mbmode_vlc[8]

Definition: vc1data.c:120

GetBitContext

Definition: get_bits.h:108

vc1_decode_init

static av_cold int vc1_decode_init(AVCodecContext *avctx)

Initialize a VC1/WMV3 decoder.

Definition: vc1dec.c:628

VC1Context::first_pic_header_flag

int first_pic_header_flag

Definition: vc1.h:366

ff_vc1_decode_sequence_header

int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)

Decode Simple/Main Profiles sequence header.

Definition: vc1.c:274

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:508

ff_vc1_norm6_vlc

VLCElem ff_vc1_norm6_vlc[556]

Definition: vc1data.c:107

HWACCEL_VDPAU

#define HWACCEL_VDPAU(codec)

Definition: hwconfig.h:72

AV_CODEC_FLAG_LOW_DELAY

#define AV_CODEC_FLAG_LOW_DELAY

Force low delay.

Definition: avcodec.h:334

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:639

VC1Context::n_allocated_blks

int n_allocated_blks

Definition: vc1.h:388

VC1_TTMB_VLC_BITS

#define VC1_TTMB_VLC_BITS

Definition: vc1data.h:65

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:150

VC1_IF_MMV_MBMODE_VLC_BITS

#define VC1_IF_MMV_MBMODE_VLC_BITS

Definition: vc1data.h:85

ff_mpv_common_end

void ff_mpv_common_end(MpegEncContext *s)

Definition: mpegvideo.c:774

avassert.h

AVCodecContext::color_primaries

enum AVColorPrimaries color_primaries

Chromaticity coordinates of the source primaries.

Definition: avcodec.h:677

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

mpegvideodec.h

vc1_ttblk_codes

static const uint8_t vc1_ttblk_codes[3][8]

Definition: vc1_vlc_data.h:732

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

ff_wmv3_dc_scale_table

const uint8_t ff_wmv3_dc_scale_table[32]

Definition: vc1data.c:173

VC1DSPContext::vc1_inv_trans_8x4_dc

void(* vc1_inv_trans_8x4_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)

Definition: vc1dsp.h:42

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:545

vc1_1ref_mvdata_bits

static const uint8_t vc1_1ref_mvdata_bits[4][72]

Definition: vc1_vlc_data.h:214

ff_msmp4_vc1_vlcs_init_once

av_cold void ff_msmp4_vc1_vlcs_init_once(void)

Definition: msmpeg4_vc1_data.c:56

vc1_decode_reset

static void vc1_decode_reset(AVCodecContext *avctx)

Definition: vc1dec.c:781

VLCInitState

For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.

Definition: vlc.h:212

VC1DSPContext::sprite_v_double_twoscale

void(* sprite_v_double_twoscale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset1, const uint8_t *src2a, const uint8_t *src2b, int offset2, int alpha, int width)

Definition: vc1dsp.h:72

vc1_2mv_block_pattern_codes

static const uint8_t vc1_2mv_block_pattern_codes[4][4]

Definition: vc1_vlc_data.h:81

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:530

AVCodecContext::has_b_frames

int has_b_frames

Size of the frame reordering buffer in the decoder.

Definition: avcodec.h:729

ff_vc1_2mv_block_pattern_vlc

const VLCElem * ff_vc1_2mv_block_pattern_vlc[4]

Definition: vc1data.c:114

ff_er_frame_end

void ff_er_frame_end(ERContext *s, int *decode_error_flags)

Indicate that a frame has finished decoding and perform error concealment in case it has been enabled...

Definition: error_resilience.c:896

av_fast_realloc

void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)

Reallocate the given buffer if it is not large enough, otherwise do nothing.

Definition: mem.c:497

ff_vc1_decoder

const FFCodec ff_vc1_decoder

Definition: vc1dec.c:1397

VC1_CODE_SLICE

@ VC1_CODE_SLICE

Definition: vc1_common.h:36

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:311

VC1Context::mb_type

uint8_t * mb_type[3]

Definition: vc1.h:262

ff_blockdsp_init

av_cold void ff_blockdsp_init(BlockDSPContext *c)

Definition: blockdsp.c:58

AV_PIX_FMT_DXVA2_VLD

@ AV_PIX_FMT_DXVA2_VLD

HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.

Definition: pixfmt.h:134

#define s(width, name)

Definition: cbs_vp9.c:198

VC1Context::res_sprite

int res_sprite

Simple/Main Profile sequence header.

Definition: vc1.h:181

VC1Context::res_fasttx

int res_fasttx

reserved, always 1

Definition: vc1.h:185

vc1_init_static

static av_cold void vc1_init_static(void)

Definition: vc1dec.c:505

vc1_if_mmv_mbmode_codes

static const uint8_t vc1_if_mmv_mbmode_codes[8][8]

Definition: vc1_vlc_data.h:121

MPVWorkPicture::ptr

MPVPicture * ptr

RefStruct reference.

Definition: mpegpicture.h:99

VC1Context::mv_f

uint8_t * mv_f[2]

0: MV obtained from same field, 1: opposite field

Definition: vc1.h:348

vc1_ac_tables

static const uint32_t vc1_ac_tables[AC_MODES][186][2]

Definition: vc1_vlc_data.h:838

VC1DSPContext::sprite_h

void(* sprite_h)(uint8_t *dst, const uint8_t *src, int offset, int advance, int count)

Definition: vc1dsp.h:67

VC1Context::mb_type_base

uint8_t * mb_type_base

Definition: vc1.h:262

vc1_subblkpat_bits

static const uint8_t vc1_subblkpat_bits[3][15]

Definition: vc1_vlc_data.h:749

VC1Context::x8

IntraX8Context x8

Definition: vc1.h:175

VC1Context::over_flags_plane

uint8_t * over_flags_plane

Overflags bitplane.

Definition: vc1.h:323

ff_mpeg_er_frame_start

void ff_mpeg_er_frame_start(MpegEncContext *s)

Definition: mpeg_er.c:49

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

ff_simple_idct48_add

void ff_simple_idct48_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)

Definition: simple_idct.c:209

PROFILE_ADVANCED

@ PROFILE_ADVANCED

Definition: vc1_common.h:52

vc1_imode_bits

static const uint8_t vc1_imode_bits[7]

Definition: vc1_vlc_data.h:40

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

vc1_norm2_codes

static const uint8_t vc1_norm2_codes[4]

Definition: vc1_vlc_data.h:45

PICT_TOP_FIELD

#define PICT_TOP_FIELD

Definition: mpegutils.h:31

@ AV_PIX_FMT_YUV420P

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

Definition: pixfmt.h:73

AV_CODEC_ID_VC1IMAGE

@ AV_CODEC_ID_VC1IMAGE

Definition: codec_id.h:204

vc1_norm6_bits

static const uint8_t vc1_norm6_bits[64]

Definition: vc1_vlc_data.h:59

MpegEncContext::cur_pic

MPVWorkPicture cur_pic

copy of the current picture structure.

Definition: mpegvideo.h:177

ff_intrax8_common_init

av_cold int ff_intrax8_common_init(AVCodecContext *avctx, IntraX8Context *w, int16_t(*block)[64], int block_last_index[12], int mb_width, int mb_height)

Initialize IntraX8 frame decoder.

Definition: intrax8.c:689

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:296

ff_vc1_ttblk_vlc

const VLCElem * ff_vc1_ttblk_vlc[3]

Definition: vc1data.c:115

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:461

VC1Context::top_blk_sh

int top_blk_sh

Either 3 or 0, positions of l/t in blk[].

Definition: vc1.h:238

FMT_H263

@ FMT_H263

Definition: mpegvideo.h:65

ff_mpv_unref_picture

void ff_mpv_unref_picture(MPVWorkPicture *pic)

Definition: mpegpicture.c:98

VC1_INTFR_4MV_MBMODE_VLC_BITS

#define VC1_INTFR_4MV_MBMODE_VLC_BITS

Definition: vc1data.h:81

VC1Context::pq

uint8_t pq

Definition: vc1.h:236

VC1_1REF_MVDATA_VLC_BITS

#define VC1_1REF_MVDATA_VLC_BITS

Definition: vc1data.h:89

AVDISCARD_ALL

@ AVDISCARD_ALL

discard all

Definition: defs.h:221

ff_wmv3_decoder

const FFCodec ff_wmv3_decoder

AV_CODEC_ID_WMV3

@ AV_CODEC_ID_WMV3

Definition: codec_id.h:123

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

VC1Context::forward_mb_plane

uint8_t * forward_mb_plane

bitplane for "forward" MBs

Definition: vc1.h:286

NULL

#define NULL

Definition: coverity.c:32

ff_vc1_cbpcy_p_vlc

const VLCElem * ff_vc1_cbpcy_p_vlc[4]

Definition: vc1data.c:111

ff_vc1_if_mmv_mbmode_vlc

const VLCElem * ff_vc1_if_mmv_mbmode_vlc[8]

Definition: vc1data.c:119

ff_simple_idct_add_int16_8bit

void ff_simple_idct_add_int16_8bit(uint8_t *dest, ptrdiff_t line_size, int16_t *block)

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:701

VC1Context::direct_mb_plane

uint8_t * direct_mb_plane

bitplane for "direct" MBs

Definition: vc1.h:285

VC1DSPContext::vc1_inv_trans_8x4

void(* vc1_inv_trans_8x4)(uint8_t *dest, ptrdiff_t stride, int16_t *block)

Definition: vc1dsp.h:38

ff_vc1_2ref_mvdata_vlc

const VLCElem * ff_vc1_2ref_mvdata_vlc[8]

Definition: vc1data.c:122

hwaccel_internal.h

ff_vc1_init_transposed_scantables

av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)

Definition: vc1dec.c:490

MpegEncContext::next_pic

MPVWorkPicture next_pic

copy of the next picture structure.

Definition: mpegvideo.h:165

vc1_cbpcy_p_codes

static const uint16_t vc1_cbpcy_p_codes[4][64]

Definition: vc1_vlc_data.h:474

VC1Context::field_mode

int field_mode

1 for interlaced field pictures

Definition: vc1.h:350

AVCHROMA_LOC_LEFT

@ AVCHROMA_LOC_LEFT

MPEG-2/4 4:2:0, H.264 default for 4:2:0.

Definition: pixfmt.h:707

ff_vc1_decode_blocks

void ff_vc1_decode_blocks(VC1Context *v)

Definition: vc1_block.c:2981

VC1Context::blk_mv_type_base

uint8_t * blk_mv_type_base

Definition: vc1.h:347

ff_intrax8_common_end

av_cold void ff_intrax8_common_end(IntraX8Context *w)

Destroy IntraX8 frame structure.

Definition: intrax8.c:728

VC1Context::mvrange

uint8_t mvrange

Ranges:

Definition: vc1.h:280

VC1_CODE_SEQHDR

@ VC1_CODE_SEQHDR

Definition: vc1_common.h:40

MPVPicture::field_picture

int field_picture

whether or not the picture was encoded in separate fields

Definition: mpegpicture.h:82

VC1Context::block

int16_t(* block)[6][64]

Definition: vc1.h:387

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:279

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:388

profiles.h

IS_MARKER

#define IS_MARKER(state)

Definition: dca_parser.c:51

VC1_CODE_FIELD

@ VC1_CODE_FIELD

Definition: vc1_common.h:37

VC1_CODE_ENTRYPOINT

@ VC1_CODE_ENTRYPOINT

Definition: vc1_common.h:39

VC1Context::vc1dsp

VC1DSPContext vc1dsp

Definition: vc1.h:177

VC1Context::cbpcy_vlc

const VLCElem * cbpcy_vlc

CBPCY VLC table.

Definition: vc1.h:282

vc1_intfr_non4mv_mbmode_codes

static const uint8_t vc1_intfr_non4mv_mbmode_codes[4][9]

Definition: vc1_vlc_data.h:105

abs

#define abs(x)

Definition: cuda_runtime.h:35

VC1Context::luma_mv_base

int16_t(* luma_mv_base)[2]

Definition: vc1.h:391

AV_PIX_FMT_D3D12

@ AV_PIX_FMT_D3D12

Hardware surfaces for Direct3D 12.

Definition: pixfmt.h:440

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:81

VC1_ICBPCY_VLC_BITS

#define VC1_ICBPCY_VLC_BITS

Definition: vc1data.h:71

VC1_CODE_FRAME

@ VC1_CODE_FRAME

Definition: vc1_common.h:38

AVCodecContext::level

int level

Encoding level descriptor.

Definition: avcodec.h:1794

AVCOL_RANGE_UNSPECIFIED

@ AVCOL_RANGE_UNSPECIFIED

Definition: pixfmt.h:652

AVOnce

#define AVOnce

Definition: thread.h:202

VC1DSPContext::vc1_inv_trans_4x8_dc

void(* vc1_inv_trans_4x8_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)

Definition: vc1dsp.h:43

VC1Context::h264chroma

H264ChromaContext h264chroma

Definition: vc1.h:176

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

VC1Context::fieldtx_plane

uint8_t * fieldtx_plane

Definition: vc1.h:344

ff_vc1_init_common

av_cold void ff_vc1_init_common(VC1Context *v)

Init VC-1 specific tables and VC1Context members.

Definition: vc1dec.c:600

ff_vc1_adv_interlaced_8x8_zz

const uint8_t ff_vc1_adv_interlaced_8x8_zz[64]

Definition: vc1data.c:207

ff_vc1dsp_init

av_cold void ff_vc1dsp_init(VC1DSPContext *dsp)

Definition: vc1dsp.c:974

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

AVDISCARD_NONKEY

@ AVDISCARD_NONKEY

discard all frames except keyframes

Definition: defs.h:220

ff_vc1_icbpcy_vlc

const VLCElem * ff_vc1_icbpcy_vlc[8]

Definition: vc1data.c:112

VC1Context::mv_f_next

uint8_t * mv_f_next[2]

Definition: vc1.h:349

Definition: af_crystalizer.c:122

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:491

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1719

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

VC1_TTBLK_VLC_BITS

#define VC1_TTBLK_VLC_BITS

Definition: vc1data.h:77

VC1Context::is_intra

uint8_t * is_intra

Definition: vc1.h:390

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AV_CODEC_FLAG_GRAY

#define AV_CODEC_FLAG_GRAY

Only decode/encode grayscale.

Definition: avcodec.h:322

AVPacket::size

int size

Definition: packet.h:540

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:94

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:388

codec_internal.h

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:83

ff_vc1_1ref_mvdata_vlc

const VLCElem * ff_vc1_1ref_mvdata_vlc[4]

Definition: vc1data.c:121

VC1Context::ttblk_base

int * ttblk_base

Definition: vc1.h:257

VC1Context::mb_off

int mb_off

Definition: vc1.h:362

ff_wmv3image_decoder

const FFCodec ff_wmv3image_decoder

ff_vc1_mv_diff_vlc

const VLCElem * ff_vc1_mv_diff_vlc[4]

Definition: vc1data.c:110

vc1_norm6_codes

static const uint16_t vc1_norm6_codes[64]

Definition: vc1_vlc_data.h:52

size

int size

Definition: twinvq_data.h:10344

VC1Context::zzi_8x8

uint8_t zzi_8x8[64]

Definition: vc1.h:346

VLCElem

Definition: vlc.h:32

vc1_if_1mv_mbmode_codes

static const uint8_t vc1_if_1mv_mbmode_codes[8][6]

Definition: vc1_vlc_data.h:143

AV_RB32

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_RB32

Definition: bytestream.h:96

ff_vc1_intfr_4mv_mbmode_vlc

const VLCElem * ff_vc1_intfr_4mv_mbmode_vlc[4]

Definition: vc1data.c:117

VC1Context::sprite_width

int sprite_width

Definition: vc1.h:379

ff_vc1_ac_coeff_table

const VLCElem * ff_vc1_ac_coeff_table[8]

Definition: vc1data.c:124

vc1_ttblk_bits

static const uint8_t vc1_ttblk_bits[3][8]

Definition: vc1_vlc_data.h:737

AVCodecHWConfigInternal

Definition: hwconfig.h:25

vc1_icbpcy_p_bits

static const uint8_t vc1_icbpcy_p_bits[8][63]

Definition: vc1_vlc_data.h:612

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_dec.c:344

ff_mpeg_flush

void ff_mpeg_flush(AVCodecContext *avctx)

Definition: mpegvideo_dec.c:449

vc1data.h

HWACCEL_D3D11VA

#define HWACCEL_D3D11VA(codec)

Definition: hwconfig.h:78

VC1DSPContext::sprite_v_single

void(* sprite_v_single)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset, int width)

Definition: vc1dsp.h:68

attributes.h

AV_PIX_FMT_D3D11

@ AV_PIX_FMT_D3D11

Hardware surfaces for Direct3D11.

Definition: pixfmt.h:336

HWACCEL_NVDEC

#define HWACCEL_NVDEC(codec)

Definition: hwconfig.h:68

AV_PIX_FMT_VAAPI

@ AV_PIX_FMT_VAAPI

Hardware acceleration through VA-API, data[3] contains a VASurfaceID.

Definition: pixfmt.h:126

VC1DSPContext::vc1_inv_trans_8x8

void(* vc1_inv_trans_8x8)(int16_t *b)

Definition: vc1dsp.h:37

VC1Context::sr_rows

uint8_t * sr_rows[2][2]

Sprite resizer line cache.

Definition: vc1.h:380

VC1_IMODE_VLC_BITS

#define VC1_IMODE_VLC_BITS

Definition: vc1data.h:58

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

AV_CODEC_ID_MSS2

@ AV_CODEC_ID_MSS2

Definition: codec_id.h:219

VC1_IF_1MV_MBMODE_VLC_BITS

#define VC1_IF_1MV_MBMODE_VLC_BITS

Definition: vc1data.h:87

AV_PIX_FMT_VDPAU

@ AV_PIX_FMT_VDPAU

HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.

Definition: pixfmt.h:194

av_get_picture_type_char

char av_get_picture_type_char(enum AVPictureType pict_type)

Return a single letter to describe the given picture type pict_type.

Definition: utils.c:40

ff_init_scantable

av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)

Definition: mpegvideo.c:293

ff_print_debug_info

void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict)

Definition: mpegvideo_dec.c:403

vc1_get_format

static enum AVPixelFormat vc1_get_format(AVCodecContext *avctx)

Definition: vc1dec.c:434

ff_simple_idct_int16_8bit

void ff_simple_idct_int16_8bit(int16_t *block)

VC1DSPContext::sprite_v_double_onescale

void(* sprite_v_double_onescale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset1, const uint8_t *src2a, int alpha, int width)

Definition: vc1dsp.h:70

vc1_if_1mv_mbmode_bits

static const uint8_t vc1_if_1mv_mbmode_bits[8][6]

Definition: vc1_vlc_data.h:153

ff_vc1_intfr_non4mv_mbmode_vlc

const VLCElem * ff_vc1_intfr_non4mv_mbmode_vlc[4]

Definition: vc1data.c:118

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

VC1DSPContext::vc1_unescape_buffer

int(* vc1_unescape_buffer)(const uint8_t *src, int size, uint8_t *dst)

Definition: vc1dsp.h:85

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:529

vc1_4mv_block_pattern_bits

static const uint8_t vc1_4mv_block_pattern_bits[4][16]

Definition: vc1_vlc_data.h:73

VC1_4MV_BLOCK_PATTERN_VLC_BITS

#define VC1_4MV_BLOCK_PATTERN_VLC_BITS

Definition: vc1data.h:73

ff_vc1_decode_entry_point

int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)

Definition: vc1.c:501

ff_vc1_parse_frame_header_adv

int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)

Definition: vc1.c:846

VC1Context::s

MpegEncContext s

Definition: vc1.h:174

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

ff_vc1_ac_sizes

const int ff_vc1_ac_sizes[AC_MODES]

Definition: vc1_vlc_data.h:1059

av_frame_unref

void av_frame_unref(AVFrame *frame)

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

Definition: frame.c:610

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:256

VC1Context::pic_header_flag

int pic_header_flag

Definition: vc1.h:367

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

VC1Context::ttblk

int * ttblk

Transform type at the block level.

Definition: vc1.h:257

MpegEncContext::last_pic

MPVWorkPicture last_pic

copy of the previous picture structure.

Definition: mpegvideo.h:159

AV_CODEC_ID_VC1

@ AV_CODEC_ID_VC1

Definition: codec_id.h:122

VC1_NORM6_VLC_BITS

#define VC1_NORM6_VLC_BITS

Definition: vc1data.h:62

AVCodecContext::height

int height

Definition: avcodec.h:624

VC1Context::is_intra_base

uint8_t * is_intra_base

Definition: vc1.h:390

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:663

AV_FRAME_FLAG_INTERLACED

#define AV_FRAME_FLAG_INTERLACED

A flag to mark frames whose content is interlaced.

Definition: frame.h:648

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:669

avcodec.h

VC1Context::second_field

int second_field

Definition: vc1.h:352

vc1_if_mmv_mbmode_bits

static const uint8_t vc1_if_mmv_mbmode_bits[8][8]

Definition: vc1_vlc_data.h:131

ret

Definition: filter_design.txt:187

vc1_icbpcy_p_codes

static const uint16_t vc1_icbpcy_p_codes[8][63]

Definition: vc1_vlc_data.h:529

FFSWAP

#define FFSWAP(type, a, b)

Definition: macros.h:52

VC1Context::sprite_output_frame

AVFrame * sprite_output_frame

Definition: vc1.h:378

VC1Context::output_width

int output_width

Definition: vc1.h:379

ff_mpv_decode_init

int ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)

Initialize the given MpegEncContext for decoding.

Definition: mpegvideo_dec.c:46

VC1Context::color_prim

int color_prim

8 bits, chroma coordinates of the color primaries

Definition: vc1.h:204

hwaccel

static const char * hwaccel

Definition: ffplay.c:353

VC1Context::mv_f_next_base

uint8_t * mv_f_next_base

Definition: vc1.h:349

vc1_mv_diff_codes

static const uint16_t vc1_mv_diff_codes[4][73]

Definition: vc1_vlc_data.h:756

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

MPVPicture::f

struct AVFrame * f

Definition: mpegpicture.h:59

ff_vc1_subblkpat_vlc

const VLCElem * ff_vc1_subblkpat_vlc[3]

Definition: vc1data.c:116

VC1_2MV_BLOCK_PATTERN_VLC_BITS

#define VC1_2MV_BLOCK_PATTERN_VLC_BITS

Definition: vc1data.h:75

AVCodecContext

main external API structure.

Definition: avcodec.h:451

ff_vc1_imode_vlc

VLCElem ff_vc1_imode_vlc[1<< VC1_IMODE_VLC_BITS]

Definition: vc1data.c:105

VC1Context::p_frame_skipped

int p_frame_skipped

Definition: vc1.h:383

AV_PICTURE_TYPE_B

@ AV_PICTURE_TYPE_B

Bi-dir predicted.

Definition: avutil.h:281

vc1_4mv_block_pattern_codes

static const uint8_t vc1_4mv_block_pattern_codes[4][16]

Definition: vc1_vlc_data.h:67

VC1Context::tff

uint8_t tff

Definition: vc1.h:311

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

VLC_INIT_STATIC_TABLE

#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)

Definition: vlc.h:270

AVCodecContext::profile

int profile

profile

Definition: avcodec.h:1650

ffhwaccel

static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)

Definition: hwaccel_internal.h:166

VC1_NORM2_VLC_BITS

#define VC1_NORM2_VLC_BITS

Definition: vc1data.h:60

vc1_ttmb_codes

static const uint16_t vc1_ttmb_codes[3][16]

Definition: vc1_vlc_data.h:671

VC1Context::profile

int profile

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

Definition: vc1.h:216

ff_mpv_frame_end

void ff_mpv_frame_end(MpegEncContext *s)

Definition: mpegvideo_dec.c:395

AV_CODEC_CAP_DELAY

#define AV_CODEC_CAP_DELAY

Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...

Definition: codec.h:76

ff_h264chroma_init

av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)

Definition: h264chroma.c:41

ff_vc1_profiles

const AVProfile ff_vc1_profiles[]

Definition: profiles.c:147

VC1Context::matrix_coef

int matrix_coef

8 bits, Color primaries->YCbCr transform matrix

Definition: vc1.h:206

AVCodecContext::debug

int debug

debug

Definition: avcodec.h:1406

av_clip_uint16

#define av_clip_uint16

Definition: common.h:112

VC1Context::bi_type

int bi_type

Definition: vc1.h:384

VC1Context::mv_f_base

uint8_t * mv_f_base

Definition: vc1.h:348

AVCodecContext::coded_width

int coded_width

Bitstream width / height, may be different from width/height e.g.

Definition: avcodec.h:639

VC1Context::fcm

enum FrameCodingMode fcm

Frame decoding info for Advanced profile.

Definition: vc1.h:308

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:280

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

ff_vlc_init_tables

static const VLCElem * ff_vlc_init_tables(VLCInitState *state, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, int flags)

Definition: vlc.h:246

ff_vc1_ttmb_vlc

const VLCElem * ff_vc1_ttmb_vlc[3]

Definition: vc1data.c:109

vc1_2ref_mvdata_codes

static const uint32_t vc1_2ref_mvdata_codes[8][126]

Definition: vc1_vlc_data.h:242

mem.h

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:801

msmpeg4_vc1_data.h

vc1_vlc_data.h

avpriv_request_sample

#define avpriv_request_sample(...)

Definition: tableprint_vlc.h:36

MPVWorkPicture

Definition: mpegpicture.h:95

ff_vc1_norm2_vlc

VLCElem ff_vc1_norm2_vlc[1<< VC1_NORM2_VLC_BITS]

Definition: vc1data.c:106

ff_vc1_4mv_block_pattern_vlc

const VLCElem * ff_vc1_4mv_block_pattern_vlc[4]

Definition: vc1data.c:113

av_free

#define av_free(p)

Definition: tableprint_vlc.h:33

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

state

static struct @454 state

VLC_INIT_STATE

#define VLC_INIT_STATE(_table)

Definition: vlc.h:217

alpha

static const int16_t alpha[]

Definition: ilbcdata.h:55

VC1Context::level

int level

Advanced Profile.

Definition: vc1.h:195

AVPacket

This structure stores compressed data.

Definition: packet.h:516

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:478

VC1Context::acpred_plane

uint8_t * acpred_plane

AC prediction flags bitplane.

Definition: vc1.h:321

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

AV_PICTURE_TYPE_BI

@ AV_PICTURE_TYPE_BI

BI type.

Definition: avutil.h:285

VC1_2REF_MVDATA_VLC_BITS

#define VC1_2REF_MVDATA_VLC_BITS

Definition: vc1data.h:91

HWACCEL_VAAPI

#define HWACCEL_VAAPI(codec)

Definition: hwconfig.h:70

vc1_imode_codes

static const uint8_t vc1_imode_codes[7]

Definition: vc1_vlc_data.h:37

mpeg_er.h

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:624

imgutils.h

vc1_decode_init_alloc_tables

static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)

Definition: vc1dec.c:359

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, a positive or negative value, which is typically indicating the size in bytes of each pict...

Definition: frame.h:434

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

VC1Context::transfer_char

int transfer_char

8 bits, Opto-electronic transfer characteristics

Definition: vc1.h:205

ff_vc1_decode_end

av_cold int ff_vc1_decode_end(AVCodecContext *avctx)

Close a MSS2/VC1/WMV3 decoder.

Definition: vc1dec.c:813

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

vc1_decode_frame

static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)

Decode a VC1/WMV3 frame.

Definition: vc1dec.c:822

VC1Context::blk_mv_type

uint8_t * blk_mv_type

0: frame MV, 1: field MV (interlaced frame)

Definition: vc1.h:347

VC1_MV_DIFF_VLC_BITS

#define VC1_MV_DIFF_VLC_BITS

Definition: vc1data.h:67

AV_CODEC_ID_WMV3IMAGE

@ AV_CODEC_ID_WMV3IMAGE

Definition: codec_id.h:203

av_image_check_size

int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)

Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...

Definition: imgutils.c:318

width

#define width

Definition: dsp.h:85

vc1_1ref_mvdata_codes

static const uint32_t vc1_1ref_mvdata_codes[4][72]

Definition: vc1_vlc_data.h:167

transpose

#define transpose(x)

VC1DSPContext::vc1_inv_trans_4x8

void(* vc1_inv_trans_4x8)(uint8_t *dest, ptrdiff_t stride, int16_t *block)

Definition: vc1dsp.h:39

AVDISCARD_NONREF

@ AVDISCARD_NONREF

discard all non reference

Definition: defs.h:217

VC1Context::blocks_off

int blocks_off

Definition: vc1.h:362

VC1_CODE_ENDOFSEQ

@ VC1_CODE_ENDOFSEQ

Definition: vc1_common.h:35

MpegEncContext

MpegEncContext.

Definition: mpegvideo.h:73

ff_wmv1_scantable

const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]

Definition: msmpeg4_vc1_data.c:220

VC1Context::rff

uint8_t rff

Definition: vc1.h:311

ff_mpv_decode_close

int ff_mpv_decode_close(AVCodecContext *avctx)

Definition: mpegvideo_dec.c:163

ff_vc1_decode_init

av_cold int ff_vc1_decode_init(AVCodecContext *avctx)

Definition: vc1dec.c:454

vc1_mv_diff_bits

static const uint8_t vc1_mv_diff_bits[4][73]

Definition: vc1_vlc_data.h:806

Generated on Fri Aug 22 2025 13:58:55 for FFmpeg by doxygen 1.8.17