FFmpeg
wmv2dec.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2002 The FFmpeg Project
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  */
20 
21 #include "libavutil/mem_internal.h"
22 
23 #include "avcodec.h"
24 #include "codec_internal.h"
25 #include "h263dec.h"
26 #include "intrax8.h"
27 #include "mathops.h"
28 #include "mpegutils.h"
29 #include "mpegvideo.h"
30 #include "mpegvideodec.h"
31 #include "msmpeg4.h"
32 #include "msmpeg4_vc1_data.h"
33 #include "msmpeg4dec.h"
34 #include "simple_idct.h"
35 #include "wmv2.h"
36 #include "wmv2data.h"
37 #include "wmv2dec.h"
38 
39 typedef struct WMV2DecContext {
44  int j_type;
45  int abt_flag;
46  int abt_type;
50  int mspel_bit;
54  int skip_type;
55 
56  DECLARE_ALIGNED(32, int16_t, abt_block2)[6][64];
58 
59 static void wmv2_add_block(WMV2DecContext *w, int16_t *block1,
60  uint8_t *dst, int stride, int n)
61 {
62  MpegEncContext *const s = &w->s;
63 
64  if (s->block_last_index[n] >= 0) {
65  switch (w->abt_type_table[n]) {
66  case 0:
67  w->common.wdsp.idct_add(dst, stride, block1);
68  break;
69  case 1:
71  ff_simple_idct84_add(dst + 4 * stride, stride, w->abt_block2[n]);
72  s->bdsp.clear_block(w->abt_block2[n]);
73  break;
74  case 2:
76  ff_simple_idct48_add(dst + 4, stride, w->abt_block2[n]);
77  s->bdsp.clear_block(w->abt_block2[n]);
78  break;
79  default:
80  av_log(s->avctx, AV_LOG_ERROR, "internal error in WMV2 abt\n");
81  }
82  }
83 }
84 
85 void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64],
86  uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
87 {
88  WMV2DecContext *const w = (WMV2DecContext *) s;
89 
90  wmv2_add_block(w, block1[0], dest_y, s->linesize, 0);
91  wmv2_add_block(w, block1[1], dest_y + 8, s->linesize, 1);
92  wmv2_add_block(w, block1[2], dest_y + 8 * s->linesize, s->linesize, 2);
93  wmv2_add_block(w, block1[3], dest_y + 8 + 8 * s->linesize, s->linesize, 3);
94 
95  if (s->avctx->flags & AV_CODEC_FLAG_GRAY)
96  return;
97 
98  wmv2_add_block(w, block1[4], dest_cb, s->uvlinesize, 4);
99  wmv2_add_block(w, block1[5], dest_cr, s->uvlinesize, 5);
100 }
101 
103 {
104  int mb_x, mb_y;
105  int coded_mb_count = 0;
106  MpegEncContext *const s = &w->s;
107  uint32_t *const mb_type = s->cur_pic.mb_type;
108 
109  w->skip_type = get_bits(&s->gb, 2);
110  switch (w->skip_type) {
111  case SKIP_TYPE_NONE:
112  for (mb_y = 0; mb_y < s->mb_height; mb_y++)
113  for (mb_x = 0; mb_x < s->mb_width; mb_x++)
114  mb_type[mb_y * s->mb_stride + mb_x] =
116  break;
117  case SKIP_TYPE_MPEG:
118  if (get_bits_left(&s->gb) < s->mb_height * s->mb_width)
119  return AVERROR_INVALIDDATA;
120  for (mb_y = 0; mb_y < s->mb_height; mb_y++)
121  for (mb_x = 0; mb_x < s->mb_width; mb_x++)
122  mb_type[mb_y * s->mb_stride + mb_x] =
124  break;
125  case SKIP_TYPE_ROW:
126  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
127  if (get_bits_left(&s->gb) < 1)
128  return AVERROR_INVALIDDATA;
129  if (get_bits1(&s->gb)) {
130  for (mb_x = 0; mb_x < s->mb_width; mb_x++)
131  mb_type[mb_y * s->mb_stride + mb_x] =
133  } else {
134  for (mb_x = 0; mb_x < s->mb_width; mb_x++)
135  mb_type[mb_y * s->mb_stride + mb_x] =
137  }
138  }
139  break;
140  case SKIP_TYPE_COL:
141  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
142  if (get_bits_left(&s->gb) < 1)
143  return AVERROR_INVALIDDATA;
144  if (get_bits1(&s->gb)) {
145  for (mb_y = 0; mb_y < s->mb_height; mb_y++)
146  mb_type[mb_y * s->mb_stride + mb_x] =
148  } else {
149  for (mb_y = 0; mb_y < s->mb_height; mb_y++)
150  mb_type[mb_y * s->mb_stride + mb_x] =
152  }
153  }
154  break;
155  }
156 
157  for (mb_y = 0; mb_y < s->mb_height; mb_y++)
158  for (mb_x = 0; mb_x < s->mb_width; mb_x++)
159  coded_mb_count += !IS_SKIP(mb_type[mb_y * s->mb_stride + mb_x]);
160 
161  if (coded_mb_count > get_bits_left(&s->gb))
162  return AVERROR_INVALIDDATA;
163 
164  return 0;
165 }
166 
168 {
169  MpegEncContext *const s = &w->s;
170  GetBitContext gb;
171  int fps;
172  int code;
173 
174  if (s->avctx->extradata_size < 4)
175  return AVERROR_INVALIDDATA;
176 
177  init_get_bits(&gb, s->avctx->extradata, 32);
178 
179  fps = get_bits(&gb, 5);
180  s->bit_rate = get_bits(&gb, 11) * 1024;
181  w->mspel_bit = get_bits1(&gb);
182  s->loop_filter = get_bits1(&gb);
183  w->abt_flag = get_bits1(&gb);
184  w->j_type_bit = get_bits1(&gb);
185  w->top_left_mv_flag = get_bits1(&gb);
186  w->per_mb_rl_bit = get_bits1(&gb);
187  code = get_bits(&gb, 3);
188 
189  if (code == 0)
190  return AVERROR_INVALIDDATA;
191 
192  s->slice_height = s->mb_height / code;
193 
194  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
195  av_log(s->avctx, AV_LOG_DEBUG,
196  "fps:%d, br:%"PRId64", qpbit:%d, abt_flag:%d, j_type_bit:%d, "
197  "tl_mv_flag:%d, mbrl_bit:%d, code:%d, loop_filter:%d, "
198  "slices:%d\n",
199  fps, s->bit_rate, w->mspel_bit, w->abt_flag, w->j_type_bit,
200  w->top_left_mv_flag, w->per_mb_rl_bit, code, s->loop_filter,
201  code);
202  return 0;
203 }
204 
206 {
207  int code;
208 
209  s->pict_type = get_bits1(&s->gb) + 1;
210  if (s->pict_type == AV_PICTURE_TYPE_I) {
211  code = get_bits(&s->gb, 7);
212  av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code);
213  }
214  s->chroma_qscale = s->qscale = get_bits(&s->gb, 5);
215  if (s->qscale <= 0)
216  return AVERROR_INVALIDDATA;
217 
218  if (s->pict_type != AV_PICTURE_TYPE_I && show_bits(&s->gb, 1)) {
219  GetBitContext gb = s->gb;
220  int skip_type = get_bits(&gb, 2);
221  int run = skip_type == SKIP_TYPE_COL ? s->mb_width : s->mb_height;
222 
223  while (run > 0) {
224  int block = FFMIN(run, 25);
225  if (get_bits(&gb, block) + 1 != 1<<block)
226  break;
227  run -= block;
228  }
229  if (!run)
230  return FRAME_SKIPPED;
231  }
232 
233  return 0;
234 }
235 
237 {
238  WMV2DecContext *const w = (WMV2DecContext *) s;
239 
240  if (s->pict_type == AV_PICTURE_TYPE_I) {
241  /* Is filling with zeroes really the right thing to do? */
242  memset(s->cur_pic.mb_type, 0,
243  sizeof(*s->cur_pic.mb_type) * s->mb_height * s->mb_stride);
244  if (w->j_type_bit)
245  w->j_type = get_bits1(&s->gb);
246  else
247  w->j_type = 0; // FIXME check
248 
249  if (!w->j_type) {
250  if (w->per_mb_rl_bit)
251  s->per_mb_rl_table = get_bits1(&s->gb);
252  else
253  s->per_mb_rl_table = 0;
254 
255  if (!s->per_mb_rl_table) {
256  s->rl_chroma_table_index = decode012(&s->gb);
257  s->rl_table_index = decode012(&s->gb);
258  }
259 
260  s->dc_table_index = get_bits1(&s->gb);
261 
262  // at minimum one bit per macroblock is required at least in a valid frame,
263  // we discard frames much smaller than this. Frames smaller than 1/8 of the
264  // smallest "black/skip" frame generally contain not much recoverable content
265  // while at the same time they have the highest computational requirements
266  // per byte
267  if (get_bits_left(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16))
268  return AVERROR_INVALIDDATA;
269  }
270  s->inter_intra_pred = 0;
271  s->no_rounding = 1;
272  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
273  av_log(s->avctx, AV_LOG_DEBUG,
274  "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d j_type:%d \n",
275  s->qscale, s->rl_chroma_table_index, s->rl_table_index,
276  s->dc_table_index, s->per_mb_rl_table, w->j_type);
277  }
278  } else {
279  int cbp_index;
280  int ret;
281  w->j_type = 0;
282 
283  ret = parse_mb_skip(w);
284  if (ret < 0)
285  return ret;
286  cbp_index = decode012(&s->gb);
287  w->cbp_table_index = wmv2_get_cbp_table_index(s, cbp_index);
288 
289  if (w->mspel_bit)
290  s->mspel = get_bits1(&s->gb);
291  else
292  s->mspel = 0; // FIXME check
293 
294  if (w->abt_flag) {
295  w->per_mb_abt = get_bits1(&s->gb) ^ 1;
296  if (!w->per_mb_abt)
297  w->abt_type = decode012(&s->gb);
298  }
299 
300  if (w->per_mb_rl_bit)
301  s->per_mb_rl_table = get_bits1(&s->gb);
302  else
303  s->per_mb_rl_table = 0;
304 
305  if (!s->per_mb_rl_table) {
306  s->rl_table_index = decode012(&s->gb);
307  s->rl_chroma_table_index = s->rl_table_index;
308  }
309 
310  if (get_bits_left(&s->gb) < 2)
311  return AVERROR_INVALIDDATA;
312 
313  s->dc_table_index = get_bits1(&s->gb);
314  s->mv_table_index = get_bits1(&s->gb);
315 
316  s->inter_intra_pred = 0; // (s->width * s->height < 320 * 240 && s->bit_rate <= II_BITRATE);
317  s->no_rounding ^= 1;
318 
319  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
320  av_log(s->avctx, AV_LOG_DEBUG,
321  "rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d mspel:%d "
322  "per_mb_abt:%d abt_type:%d cbp:%d ii:%d\n",
323  s->rl_table_index, s->rl_chroma_table_index,
324  s->dc_table_index, s->mv_table_index,
325  s->per_mb_rl_table, s->qscale, s->mspel,
326  w->per_mb_abt, w->abt_type, w->cbp_table_index,
327  s->inter_intra_pred);
328  }
329  }
330  s->esc3_level_length = 0;
331  s->esc3_run_length = 0;
332 
333  if (w->j_type) {
334  ff_intrax8_decode_picture(&w->x8, s->cur_pic.ptr,
335  &s->gb, &s->mb_x, &s->mb_y,
336  2 * s->qscale, (s->qscale - 1) | 1,
337  s->loop_filter, s->low_delay);
338 
339  ff_er_add_slice(&w->s.er, 0, 0,
340  (w->s.mb_x >> 1) - 1, (w->s.mb_y >> 1) - 1,
341  ER_MB_END);
342  return 1;
343  }
344 
345  return 0;
346 }
347 
348 static inline void wmv2_decode_motion(WMV2DecContext *w, int *mx_ptr, int *my_ptr)
349 {
350  MpegEncContext *const s = &w->s;
351 
352  ff_msmpeg4_decode_motion(s, mx_ptr, my_ptr);
353 
354  if ((((*mx_ptr) | (*my_ptr)) & 1) && s->mspel)
355  w->common.hshift = get_bits1(&s->gb);
356  else
357  w->common.hshift = 0;
358 }
359 
360 static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py)
361 {
362  MpegEncContext *const s = &w->s;
363  int xy, wrap, diff, type;
364  int16_t *A, *B, *C, *mot_val;
365 
366  wrap = s->b8_stride;
367  xy = s->block_index[0];
368 
369  mot_val = s->cur_pic.motion_val[0][xy];
370 
371  A = s->cur_pic.motion_val[0][xy - 1];
372  B = s->cur_pic.motion_val[0][xy - wrap];
373  C = s->cur_pic.motion_val[0][xy + 2 - wrap];
374 
375  if (s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag)
376  diff = FFMAX(FFABS(A[0] - B[0]), FFABS(A[1] - B[1]));
377  else
378  diff = 0;
379 
380  if (diff >= 8)
381  type = get_bits1(&s->gb);
382  else
383  type = 2;
384 
385  if (type == 0) {
386  *px = A[0];
387  *py = A[1];
388  } else if (type == 1) {
389  *px = B[0];
390  *py = B[1];
391  } else {
392  /* special case for first (slice) line */
393  if (s->first_slice_line) {
394  *px = A[0];
395  *py = A[1];
396  } else {
397  *px = mid_pred(A[0], B[0], C[0]);
398  *py = mid_pred(A[1], B[1], C[1]);
399  }
400  }
401 
402  return mot_val;
403 }
404 
405 static inline int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block,
406  int n, int cbp)
407 {
408  MpegEncContext *const s = &w->s;
409  static const int sub_cbp_table[3] = { 2, 3, 1 };
410  int sub_cbp, ret;
411 
412  if (!cbp) {
413  s->block_last_index[n] = -1;
414  return 0;
415  }
416 
417  if (w->per_block_abt)
418  w->abt_type = decode012(&s->gb);
419  w->abt_type_table[n] = w->abt_type;
420 
421  if (w->abt_type) {
422  const uint8_t *scantable = w->abt_type == 1 ? ff_wmv2_scantableA : ff_wmv2_scantableB;
423 
424  sub_cbp = sub_cbp_table[decode012(&s->gb)];
425 
426  if (sub_cbp & 1)
427  if ((ret = ff_msmpeg4_decode_block(s, block, n, 1, scantable)) < 0)
428  return ret;
429 
430  if (sub_cbp & 2)
431  if ((ret = ff_msmpeg4_decode_block(s, w->abt_block2[n], n, 1, scantable)) < 0)
432  return ret;
433 
434  s->block_last_index[n] = 63;
435 
436  return 0;
437  } else {
438  return ff_msmpeg4_decode_block(s, block, n, 1,
439  s->inter_scantable.permutated);
440  }
441 }
442 
443 static int wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
444 {
445  /* The following is only allowed because this encoder
446  * does not use slice threading. */
447  WMV2DecContext *const w = (WMV2DecContext *) s;
448  int cbp, code, i, ret;
449  uint8_t *coded_val;
450 
451  if (w->j_type)
452  return 0;
453 
454  if (s->pict_type == AV_PICTURE_TYPE_P) {
455  if (IS_SKIP(s->cur_pic.mb_type[s->mb_y * s->mb_stride + s->mb_x])) {
456  /* skip mb */
457  s->mb_intra = 0;
458  for (i = 0; i < 6; i++)
459  s->block_last_index[i] = -1;
460  s->mv_dir = MV_DIR_FORWARD;
461  s->mv_type = MV_TYPE_16X16;
462  s->mv[0][0][0] = 0;
463  s->mv[0][0][1] = 0;
464  s->mb_skipped = 1;
465  w->common.hshift = 0;
466  return 0;
467  }
468  if (get_bits_left(&s->gb) <= 0)
469  return AVERROR_INVALIDDATA;
470 
471  code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[w->cbp_table_index],
473  s->mb_intra = (~code & 0x40) >> 6;
474 
475  cbp = code & 0x3f;
476  } else {
477  s->mb_intra = 1;
478  if (get_bits_left(&s->gb) <= 0)
479  return AVERROR_INVALIDDATA;
482  /* predict coded block pattern */
483  cbp = 0;
484  for (i = 0; i < 6; i++) {
485  int val = ((code >> (5 - i)) & 1);
486  if (i < 4) {
487  int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
488  val = val ^ pred;
489  *coded_val = val;
490  }
491  cbp |= val << (5 - i);
492  }
493  }
494 
495  if (!s->mb_intra) {
496  int mx, my;
497  wmv2_pred_motion(w, &mx, &my);
498 
499  if (cbp) {
500  s->bdsp.clear_blocks(s->block[0]);
501  if (s->per_mb_rl_table) {
502  s->rl_table_index = decode012(&s->gb);
503  s->rl_chroma_table_index = s->rl_table_index;
504  }
505 
506  if (w->abt_flag && w->per_mb_abt) {
507  w->per_block_abt = get_bits1(&s->gb);
508  if (!w->per_block_abt)
509  w->abt_type = decode012(&s->gb);
510  } else
511  w->per_block_abt = 0;
512  }
513 
514  wmv2_decode_motion(w, &mx, &my);
515 
516  s->mv_dir = MV_DIR_FORWARD;
517  s->mv_type = MV_TYPE_16X16;
518  s->mv[0][0][0] = mx;
519  s->mv[0][0][1] = my;
520 
521  for (i = 0; i < 6; i++) {
522  if ((ret = wmv2_decode_inter_block(w, block[i], i, (cbp >> (5 - i)) & 1)) < 0) {
523  av_log(s->avctx, AV_LOG_ERROR,
524  "\nerror while decoding inter block: %d x %d (%d)\n",
525  s->mb_x, s->mb_y, i);
526  return ret;
527  }
528  }
529  } else {
530  if (s->pict_type == AV_PICTURE_TYPE_P)
531  ff_dlog(s->avctx, "%d%d ", s->inter_intra_pred, cbp);
532  ff_dlog(s->avctx, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
533  ((cbp & 3) ? 1 : 0) + ((cbp & 0x3C) ? 2 : 0),
534  show_bits(&s->gb, 24));
535  s->ac_pred = get_bits1(&s->gb);
536  if (s->inter_intra_pred) {
537  s->h263_aic_dir = get_vlc2(&s->gb, ff_inter_intra_vlc,
539  ff_dlog(s->avctx, "%d%d %d %d/",
540  s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
541  }
542  if (s->per_mb_rl_table && cbp) {
543  s->rl_table_index = decode012(&s->gb);
544  s->rl_chroma_table_index = s->rl_table_index;
545  }
546 
547  s->bdsp.clear_blocks(s->block[0]);
548  for (i = 0; i < 6; i++) {
549  if ((ret = ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL)) < 0) {
550  av_log(s->avctx, AV_LOG_ERROR,
551  "\nerror while decoding intra block: %d x %d (%d)\n",
552  s->mb_x, s->mb_y, i);
553  return ret;
554  }
555  }
556  }
557 
558  return 0;
559 }
560 
562 {
563  WMV2DecContext *const w = avctx->priv_data;
564  MpegEncContext *const s = &w->s;
565  int ret;
566 
567  s->private_ctx = &w->common;
568 
569  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
570  return ret;
571 
572  s->decode_mb = wmv2_decode_mb;
573 
575 
577 
578  return ff_intrax8_common_init(avctx, &w->x8,
579  w->s.block, w->s.block_last_index,
580  w->s.mb_width, w->s.mb_height);
581 }
582 
584 {
585  WMV2DecContext *const w = avctx->priv_data;
586 
587  ff_intrax8_common_end(&w->x8);
588  return ff_mpv_decode_close(avctx);
589 }
590 
592  .p.name = "wmv2",
593  CODEC_LONG_NAME("Windows Media Video 8"),
594  .p.type = AVMEDIA_TYPE_VIDEO,
595  .p.id = AV_CODEC_ID_WMV2,
596  .priv_data_size = sizeof(WMV2DecContext),
598  .close = wmv2_decode_end,
601  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
602 };
WMV2DecContext::abt_type_table
int abt_type_table[6]
Definition: wmv2dec.c:47
A
#define A(x)
Definition: vpx_arith.h:28
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:265
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
wmv2_decode_inter_block
static int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block, int n, int cbp)
Definition: wmv2dec.c:405
mem_internal.h
ff_intrax8_decode_picture
int ff_intrax8_decode_picture(IntraX8Context *w, MPVPicture *pict, GetBitContext *gb, int *mb_x, int *mb_y, int dquant, int quant_offset, int loopfilter, int lowdelay)
Decode single IntraX8 frame.
Definition: intrax8.c:733
WMV2DecContext::abt_block2
int16_t abt_block2[6][64]
Definition: wmv2dec.c:56
WMV2DecContext::skip_type
int skip_type
Definition: wmv2dec.c:54
ff_wmv2_decoder
const FFCodec ff_wmv2_decoder
Definition: wmv2dec.c:591
w
uint8_t w
Definition: llviddspenc.c:38
ff_simple_idct84_add
void ff_simple_idct84_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
Definition: simple_idct.c:194
MSMP4_MB_INTRA_VLC_BITS
#define MSMP4_MB_INTRA_VLC_BITS
Definition: msmpeg4_vc1_data.h:36
wmv2_pred_motion
static int16_t * wmv2_pred_motion(WMV2DecContext *w, int *px, int *py)
Definition: wmv2dec.c:360
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:42
WMV2DecContext::mspel_bit
int mspel_bit
Definition: wmv2dec.c:50
WMV2DecContext::cbp_table_index
int cbp_table_index
Definition: wmv2dec.c:51
FFCodec
Definition: codec_internal.h:127
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:826
mpegvideo.h
ff_wmv2_add_mb
void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
Definition: wmv2dec.c:85
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
mpegutils.h
WMV2DecContext::top_left_mv_flag
int top_left_mv_flag
Definition: wmv2dec.c:52
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
wmv2_decode_end
static av_cold int wmv2_decode_end(AVCodecContext *avctx)
Definition: wmv2dec.c:583
WMV2Context
Definition: wmv2.h:33
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1407
ff_wmv2_decode_secondary_picture_header
int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
Definition: wmv2dec.c:236
WMV2DecContext::per_block_abt
int per_block_abt
Definition: wmv2dec.c:49
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition: dsp.h:53
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
WMV2DecContext
Definition: wmv2dec.c:39
wrap
#define wrap(func)
Definition: neontest.h:65
WMV2DecContext::x8
IntraX8Context x8
Definition: wmv2dec.c:42
WMV2DecContext::per_mb_rl_bit
int per_mb_rl_bit
Definition: wmv2dec.c:53
GetBitContext
Definition: get_bits.h:108
ff_msmpeg4_decode_motion
void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
Definition: msmpeg4dec.c:815
val
static double val(void *priv, double ch)
Definition: aeval.c:77
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
WMV2DecContext::abt_type
int abt_type
Definition: wmv2dec.c:46
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
mpegvideodec.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
h263dec.h
av_cold
#define av_cold
Definition: attributes.h:90
SKIP_TYPE_COL
#define SKIP_TYPE_COL
Definition: wmv2.h:30
ff_wmv2_decode_picture_header
int ff_wmv2_decode_picture_header(MpegEncContext *s)
Definition: wmv2dec.c:205
wmv2_get_cbp_table_index
static av_always_inline int wmv2_get_cbp_table_index(MpegEncContext *s, int cbp_index)
Definition: wmv2.h:47
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
s
#define s(width, name)
Definition: cbs_vp9.c:198
WMV2DecContext::per_mb_abt
int per_mb_abt
Definition: wmv2dec.c:48
ff_mb_non_intra_vlc
const VLCElem * ff_mb_non_intra_vlc[4]
Definition: msmpeg4dec.c:67
WMV2DecContext::common
WMV2Context common
Definition: wmv2dec.c:41
AV_CODEC_ID_WMV2
@ AV_CODEC_ID_WMV2
Definition: codec_id.h:70
wmv2data.h
ff_simple_idct48_add
void ff_simple_idct48_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
Definition: simple_idct.c:209
WMV2DecContext::j_type
int j_type
Definition: wmv2dec.c:44
B
#define B
Definition: huffyuv.h:42
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
IS_SKIP
#define IS_SKIP(a)
Definition: mpegutils.h:76
simple_idct.h
SKIP_TYPE_NONE
#define SKIP_TYPE_NONE
Definition: wmv2.h:27
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
IntraX8Context
Definition: intrax8.h:28
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition: dsp.h:53
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
NULL
#define NULL
Definition: coverity.c:32
wmv2_decode_mb
static int wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: wmv2dec.c:443
run
uint8_t run
Definition: svq3.c:204
parse_mb_skip
static int parse_mb_skip(WMV2DecContext *w)
Definition: wmv2dec.c:102
ff_intrax8_common_end
av_cold void ff_intrax8_common_end(IntraX8Context *w)
Destroy IntraX8 frame structure.
Definition: intrax8.c:728
decode_ext_header
static int decode_ext_header(WMV2DecContext *w)
Definition: wmv2dec.c:167
SKIP_TYPE_MPEG
#define SKIP_TYPE_MPEG
Definition: wmv2.h:28
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
INTER_INTRA_VLC_BITS
#define INTER_INTRA_VLC_BITS
Definition: msmpeg4dec.h:28
WMV2DecContext::s
MpegEncContext s
Definition: wmv2dec.c:40
mathops.h
ff_h263_decode_frame
int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:426
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
wmv2.h
ff_inter_intra_vlc
VLCElem ff_inter_intra_vlc[8]
Definition: msmpeg4dec.c:72
intrax8.h
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
ff_msmp4_mb_i_vlc
VLCElem ff_msmp4_mb_i_vlc[536]
Definition: msmpeg4_vc1_data.c:35
wmv2_add_block
static void wmv2_add_block(WMV2DecContext *w, int16_t *block1, uint8_t *dst, int stride, int n)
Definition: wmv2dec.c:59
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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
MB_NON_INTRA_VLC_BITS
#define MB_NON_INTRA_VLC_BITS
Definition: msmpeg4dec.h:29
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:102
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
ff_wmv2_scantableB
const uint8_t ff_wmv2_scantableB[64]
Definition: wmv2data.c:30
FRAME_SKIPPED
#define FRAME_SKIPPED
Return value for header parsers if frame is not coded.
Definition: h263dec.h:29
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:62
ff_wmv2_scantableA
const uint8_t ff_wmv2_scantableA[64]
Definition: wmv2data.c:23
wmv2_decode_motion
static void wmv2_decode_motion(WMV2DecContext *w, int *mx_ptr, int *my_ptr)
Definition: wmv2dec.c:348
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
block1
static int16_t block1[64]
Definition: dct.c:120
msmpeg4dec.h
SKIP_TYPE_ROW
#define SKIP_TYPE_ROW
Definition: wmv2.h:29
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
ff_msmpeg4_decode_block
int ff_msmpeg4_decode_block(MpegEncContext *s, int16_t *block, int n, int coded, const uint8_t *scan_table)
Definition: msmpeg4dec.c:627
decode012
static int BS_FUNC() decode012(BSCTX *bc)
Return decoded truncated unary code for the values 0, 1, 2.
Definition: bitstream_template.h:436
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
WMV2DecContext::j_type_bit
int j_type_bit
Definition: wmv2dec.c:43
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
msmpeg4.h
mid_pred
#define mid_pred
Definition: mathops.h:96
ret
ret
Definition: filter_design.txt:187
wmv2dec.h
pred
static const float pred[4]
Definition: siprdata.h:259
AVCodecContext
main external API structure.
Definition: avcodec.h:451
WMV2DecContext::abt_flag
int abt_flag
Definition: wmv2dec.c:45
wmv2_decode_init
static av_cold int wmv2_decode_init(AVCodecContext *avctx)
Definition: wmv2dec.c:561
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
msmpeg4_vc1_data.h
ER_MB_END
#define ER_MB_END
Definition: error_resilience.h:38
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:261
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_msmpeg4_decode_init
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:356
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
ff_wmv2_common_init
av_cold void ff_wmv2_common_init(MpegEncContext *s)
Definition: wmv2.c:28
MB_TYPE_FORWARD_MV
#define MB_TYPE_FORWARD_MV
Definition: mpegutils.h:50
ff_msmpeg4_coded_block_pred
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:156
ff_mpv_decode_close
int ff_mpv_decode_close(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:163