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 "msmpeg4.h"
31 #include "msmpeg4_vc1_data.h"
32 #include "msmpeg4dec.h"
33 #include "simple_idct.h"
34 #include "wmv2.h"
35 #include "wmv2data.h"
36 #include "wmv2dec.h"
37 
38 typedef struct WMV2DecContext {
43  int j_type;
44  int abt_flag;
45  int abt_type;
49  int mspel_bit;
53  int skip_type;
54 
55  DECLARE_ALIGNED(32, int16_t, abt_block2)[6][64];
57 
58 static void wmv2_add_block(WMV2DecContext *w, int16_t *block1,
59  uint8_t *dst, int stride, int n)
60 {
61  MpegEncContext *const s = &w->s;
62 
63  if (s->block_last_index[n] >= 0) {
64  switch (w->abt_type_table[n]) {
65  case 0:
66  w->common.wdsp.idct_add(dst, stride, block1);
67  break;
68  case 1:
70  ff_simple_idct84_add(dst + 4 * stride, stride, w->abt_block2[n]);
71  s->bdsp.clear_block(w->abt_block2[n]);
72  break;
73  case 2:
75  ff_simple_idct48_add(dst + 4, stride, w->abt_block2[n]);
76  s->bdsp.clear_block(w->abt_block2[n]);
77  break;
78  default:
79  av_log(s->avctx, AV_LOG_ERROR, "internal error in WMV2 abt\n");
80  }
81  }
82 }
83 
84 void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64],
85  uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
86 {
87  WMV2DecContext *const w = (WMV2DecContext *) s;
88 
89  wmv2_add_block(w, block1[0], dest_y, s->linesize, 0);
90  wmv2_add_block(w, block1[1], dest_y + 8, s->linesize, 1);
91  wmv2_add_block(w, block1[2], dest_y + 8 * s->linesize, s->linesize, 2);
92  wmv2_add_block(w, block1[3], dest_y + 8 + 8 * s->linesize, s->linesize, 3);
93 
94  if (s->avctx->flags & AV_CODEC_FLAG_GRAY)
95  return;
96 
97  wmv2_add_block(w, block1[4], dest_cb, s->uvlinesize, 4);
98  wmv2_add_block(w, block1[5], dest_cr, s->uvlinesize, 5);
99 }
100 
102 {
103  int mb_x, mb_y;
104  int coded_mb_count = 0;
105  MpegEncContext *const s = &w->s;
106  uint32_t *const mb_type = s->current_picture_ptr->mb_type;
107 
108  w->skip_type = get_bits(&s->gb, 2);
109  switch (w->skip_type) {
110  case SKIP_TYPE_NONE:
111  for (mb_y = 0; mb_y < s->mb_height; mb_y++)
112  for (mb_x = 0; mb_x < s->mb_width; mb_x++)
113  mb_type[mb_y * s->mb_stride + mb_x] =
115  break;
116  case SKIP_TYPE_MPEG:
117  if (get_bits_left(&s->gb) < s->mb_height * s->mb_width)
118  return AVERROR_INVALIDDATA;
119  for (mb_y = 0; mb_y < s->mb_height; mb_y++)
120  for (mb_x = 0; mb_x < s->mb_width; mb_x++)
121  mb_type[mb_y * s->mb_stride + mb_x] =
122  (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
123  break;
124  case SKIP_TYPE_ROW:
125  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
126  if (get_bits_left(&s->gb) < 1)
127  return AVERROR_INVALIDDATA;
128  if (get_bits1(&s->gb)) {
129  for (mb_x = 0; mb_x < s->mb_width; mb_x++)
130  mb_type[mb_y * s->mb_stride + mb_x] =
132  } else {
133  for (mb_x = 0; mb_x < s->mb_width; mb_x++)
134  mb_type[mb_y * s->mb_stride + mb_x] =
135  (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
136  }
137  }
138  break;
139  case SKIP_TYPE_COL:
140  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
141  if (get_bits_left(&s->gb) < 1)
142  return AVERROR_INVALIDDATA;
143  if (get_bits1(&s->gb)) {
144  for (mb_y = 0; mb_y < s->mb_height; mb_y++)
145  mb_type[mb_y * s->mb_stride + mb_x] =
147  } else {
148  for (mb_y = 0; mb_y < s->mb_height; mb_y++)
149  mb_type[mb_y * s->mb_stride + mb_x] =
150  (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
151  }
152  }
153  break;
154  }
155 
156  for (mb_y = 0; mb_y < s->mb_height; mb_y++)
157  for (mb_x = 0; mb_x < s->mb_width; mb_x++)
158  coded_mb_count += !IS_SKIP(mb_type[mb_y * s->mb_stride + mb_x]);
159 
160  if (coded_mb_count > get_bits_left(&s->gb))
161  return AVERROR_INVALIDDATA;
162 
163  return 0;
164 }
165 
167 {
168  MpegEncContext *const s = &w->s;
169  GetBitContext gb;
170  int fps;
171  int code;
172 
173  if (s->avctx->extradata_size < 4)
174  return AVERROR_INVALIDDATA;
175 
176  init_get_bits(&gb, s->avctx->extradata, 32);
177 
178  fps = get_bits(&gb, 5);
179  s->bit_rate = get_bits(&gb, 11) * 1024;
180  w->mspel_bit = get_bits1(&gb);
181  s->loop_filter = get_bits1(&gb);
182  w->abt_flag = get_bits1(&gb);
183  w->j_type_bit = get_bits1(&gb);
184  w->top_left_mv_flag = get_bits1(&gb);
185  w->per_mb_rl_bit = get_bits1(&gb);
186  code = get_bits(&gb, 3);
187 
188  if (code == 0)
189  return AVERROR_INVALIDDATA;
190 
191  s->slice_height = s->mb_height / code;
192 
193  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
194  av_log(s->avctx, AV_LOG_DEBUG,
195  "fps:%d, br:%"PRId64", qpbit:%d, abt_flag:%d, j_type_bit:%d, "
196  "tl_mv_flag:%d, mbrl_bit:%d, code:%d, loop_filter:%d, "
197  "slices:%d\n",
198  fps, s->bit_rate, w->mspel_bit, w->abt_flag, w->j_type_bit,
199  w->top_left_mv_flag, w->per_mb_rl_bit, code, s->loop_filter,
200  code);
201  return 0;
202 }
203 
205 {
206  WMV2DecContext *const w = (WMV2DecContext *) s;
207  int code;
208 
209  if (s->picture_number == 0)
211 
212  s->pict_type = get_bits1(&s->gb) + 1;
213  if (s->pict_type == AV_PICTURE_TYPE_I) {
214  code = get_bits(&s->gb, 7);
215  av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code);
216  }
217  s->chroma_qscale = s->qscale = get_bits(&s->gb, 5);
218  if (s->qscale <= 0)
219  return AVERROR_INVALIDDATA;
220 
221  if (s->pict_type != AV_PICTURE_TYPE_I && show_bits(&s->gb, 1)) {
222  GetBitContext gb = s->gb;
223  int skip_type = get_bits(&gb, 2);
224  int run = skip_type == SKIP_TYPE_COL ? s->mb_width : s->mb_height;
225 
226  while (run > 0) {
227  int block = FFMIN(run, 25);
228  if (get_bits(&gb, block) + 1 != 1<<block)
229  break;
230  run -= block;
231  }
232  if (!run)
233  return FRAME_SKIPPED;
234  }
235 
236  return 0;
237 }
238 
240 {
241  WMV2DecContext *const w = (WMV2DecContext *) s;
242 
243  if (s->pict_type == AV_PICTURE_TYPE_I) {
244  /* Is filling with zeroes really the right thing to do? */
245  memset(s->current_picture_ptr->mb_type, 0,
246  sizeof(*s->current_picture_ptr->mb_type) *
247  s->mb_height * s->mb_stride);
248  if (w->j_type_bit)
249  w->j_type = get_bits1(&s->gb);
250  else
251  w->j_type = 0; // FIXME check
252 
253  if (!w->j_type) {
254  if (w->per_mb_rl_bit)
255  s->per_mb_rl_table = get_bits1(&s->gb);
256  else
257  s->per_mb_rl_table = 0;
258 
259  if (!s->per_mb_rl_table) {
260  s->rl_chroma_table_index = decode012(&s->gb);
261  s->rl_table_index = decode012(&s->gb);
262  }
263 
264  s->dc_table_index = get_bits1(&s->gb);
265 
266  // at minimum one bit per macroblock is required at least in a valid frame,
267  // we discard frames much smaller than this. Frames smaller than 1/8 of the
268  // smallest "black/skip" frame generally contain not much recoverable content
269  // while at the same time they have the highest computational requirements
270  // per byte
271  if (get_bits_left(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16))
272  return AVERROR_INVALIDDATA;
273  }
274  s->inter_intra_pred = 0;
275  s->no_rounding = 1;
276  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
277  av_log(s->avctx, AV_LOG_DEBUG,
278  "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d j_type:%d \n",
279  s->qscale, s->rl_chroma_table_index, s->rl_table_index,
280  s->dc_table_index, s->per_mb_rl_table, w->j_type);
281  }
282  } else {
283  int cbp_index;
284  int ret;
285  w->j_type = 0;
286 
287  ret = parse_mb_skip(w);
288  if (ret < 0)
289  return ret;
290  cbp_index = decode012(&s->gb);
291  w->cbp_table_index = wmv2_get_cbp_table_index(s, cbp_index);
292 
293  if (w->mspel_bit)
294  s->mspel = get_bits1(&s->gb);
295  else
296  s->mspel = 0; // FIXME check
297 
298  if (w->abt_flag) {
299  w->per_mb_abt = get_bits1(&s->gb) ^ 1;
300  if (!w->per_mb_abt)
301  w->abt_type = decode012(&s->gb);
302  }
303 
304  if (w->per_mb_rl_bit)
305  s->per_mb_rl_table = get_bits1(&s->gb);
306  else
307  s->per_mb_rl_table = 0;
308 
309  if (!s->per_mb_rl_table) {
310  s->rl_table_index = decode012(&s->gb);
311  s->rl_chroma_table_index = s->rl_table_index;
312  }
313 
314  if (get_bits_left(&s->gb) < 2)
315  return AVERROR_INVALIDDATA;
316 
317  s->dc_table_index = get_bits1(&s->gb);
318  s->mv_table_index = get_bits1(&s->gb);
319 
320  s->inter_intra_pred = 0; // (s->width * s->height < 320 * 240 && s->bit_rate <= II_BITRATE);
321  s->no_rounding ^= 1;
322 
323  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
324  av_log(s->avctx, AV_LOG_DEBUG,
325  "rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d mspel:%d "
326  "per_mb_abt:%d abt_type:%d cbp:%d ii:%d\n",
327  s->rl_table_index, s->rl_chroma_table_index,
328  s->dc_table_index, s->mv_table_index,
329  s->per_mb_rl_table, s->qscale, s->mspel,
330  w->per_mb_abt, w->abt_type, w->cbp_table_index,
331  s->inter_intra_pred);
332  }
333  }
334  s->esc3_level_length = 0;
335  s->esc3_run_length = 0;
336  s->picture_number++; // FIXME ?
337 
338  if (w->j_type) {
339  ff_intrax8_decode_picture(&w->x8, &s->current_picture,
340  &s->gb, &s->mb_x, &s->mb_y,
341  2 * s->qscale, (s->qscale - 1) | 1,
342  s->loop_filter, s->low_delay);
343 
344  ff_er_add_slice(&w->s.er, 0, 0,
345  (w->s.mb_x >> 1) - 1, (w->s.mb_y >> 1) - 1,
346  ER_MB_END);
347  return 1;
348  }
349 
350  return 0;
351 }
352 
353 static inline void wmv2_decode_motion(WMV2DecContext *w, int *mx_ptr, int *my_ptr)
354 {
355  MpegEncContext *const s = &w->s;
356 
357  ff_msmpeg4_decode_motion(s, mx_ptr, my_ptr);
358 
359  if ((((*mx_ptr) | (*my_ptr)) & 1) && s->mspel)
360  w->common.hshift = get_bits1(&s->gb);
361  else
362  w->common.hshift = 0;
363 }
364 
365 static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py)
366 {
367  MpegEncContext *const s = &w->s;
368  int xy, wrap, diff, type;
369  int16_t *A, *B, *C, *mot_val;
370 
371  wrap = s->b8_stride;
372  xy = s->block_index[0];
373 
374  mot_val = s->current_picture.motion_val[0][xy];
375 
376  A = s->current_picture.motion_val[0][xy - 1];
377  B = s->current_picture.motion_val[0][xy - wrap];
378  C = s->current_picture.motion_val[0][xy + 2 - wrap];
379 
380  if (s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag)
381  diff = FFMAX(FFABS(A[0] - B[0]), FFABS(A[1] - B[1]));
382  else
383  diff = 0;
384 
385  if (diff >= 8)
386  type = get_bits1(&s->gb);
387  else
388  type = 2;
389 
390  if (type == 0) {
391  *px = A[0];
392  *py = A[1];
393  } else if (type == 1) {
394  *px = B[0];
395  *py = B[1];
396  } else {
397  /* special case for first (slice) line */
398  if (s->first_slice_line) {
399  *px = A[0];
400  *py = A[1];
401  } else {
402  *px = mid_pred(A[0], B[0], C[0]);
403  *py = mid_pred(A[1], B[1], C[1]);
404  }
405  }
406 
407  return mot_val;
408 }
409 
410 static inline int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block,
411  int n, int cbp)
412 {
413  MpegEncContext *const s = &w->s;
414  static const int sub_cbp_table[3] = { 2, 3, 1 };
415  int sub_cbp, ret;
416 
417  if (!cbp) {
418  s->block_last_index[n] = -1;
419  return 0;
420  }
421 
422  if (w->per_block_abt)
423  w->abt_type = decode012(&s->gb);
424  w->abt_type_table[n] = w->abt_type;
425 
426  if (w->abt_type) {
427  const uint8_t *scantable = w->abt_type == 1 ? ff_wmv2_scantableA : ff_wmv2_scantableB;
428 
429  sub_cbp = sub_cbp_table[decode012(&s->gb)];
430 
431  if (sub_cbp & 1)
432  if ((ret = ff_msmpeg4_decode_block(s, block, n, 1, scantable)) < 0)
433  return ret;
434 
435  if (sub_cbp & 2)
436  if ((ret = ff_msmpeg4_decode_block(s, w->abt_block2[n], n, 1, scantable)) < 0)
437  return ret;
438 
439  s->block_last_index[n] = 63;
440 
441  return 0;
442  } else {
443  return ff_msmpeg4_decode_block(s, block, n, 1,
444  s->inter_scantable.permutated);
445  }
446 }
447 
448 static int wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
449 {
450  /* The following is only allowed because this encoder
451  * does not use slice threading. */
452  WMV2DecContext *const w = (WMV2DecContext *) s;
453  int cbp, code, i, ret;
454  uint8_t *coded_val;
455 
456  if (w->j_type)
457  return 0;
458 
459  if (s->pict_type == AV_PICTURE_TYPE_P) {
460  if (IS_SKIP(s->current_picture.mb_type[s->mb_y * s->mb_stride + s->mb_x])) {
461  /* skip mb */
462  s->mb_intra = 0;
463  for (i = 0; i < 6; i++)
464  s->block_last_index[i] = -1;
465  s->mv_dir = MV_DIR_FORWARD;
466  s->mv_type = MV_TYPE_16X16;
467  s->mv[0][0][0] = 0;
468  s->mv[0][0][1] = 0;
469  s->mb_skipped = 1;
470  w->common.hshift = 0;
471  return 0;
472  }
473  if (get_bits_left(&s->gb) <= 0)
474  return AVERROR_INVALIDDATA;
475 
476  code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[w->cbp_table_index].table,
478  s->mb_intra = (~code & 0x40) >> 6;
479 
480  cbp = code & 0x3f;
481  } else {
482  s->mb_intra = 1;
483  if (get_bits_left(&s->gb) <= 0)
484  return AVERROR_INVALIDDATA;
487  /* predict coded block pattern */
488  cbp = 0;
489  for (i = 0; i < 6; i++) {
490  int val = ((code >> (5 - i)) & 1);
491  if (i < 4) {
492  int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
493  val = val ^ pred;
494  *coded_val = val;
495  }
496  cbp |= val << (5 - i);
497  }
498  }
499 
500  if (!s->mb_intra) {
501  int mx, my;
502  wmv2_pred_motion(w, &mx, &my);
503 
504  if (cbp) {
505  s->bdsp.clear_blocks(s->block[0]);
506  if (s->per_mb_rl_table) {
507  s->rl_table_index = decode012(&s->gb);
508  s->rl_chroma_table_index = s->rl_table_index;
509  }
510 
511  if (w->abt_flag && w->per_mb_abt) {
512  w->per_block_abt = get_bits1(&s->gb);
513  if (!w->per_block_abt)
514  w->abt_type = decode012(&s->gb);
515  } else
516  w->per_block_abt = 0;
517  }
518 
519  wmv2_decode_motion(w, &mx, &my);
520 
521  s->mv_dir = MV_DIR_FORWARD;
522  s->mv_type = MV_TYPE_16X16;
523  s->mv[0][0][0] = mx;
524  s->mv[0][0][1] = my;
525 
526  for (i = 0; i < 6; i++) {
527  if ((ret = wmv2_decode_inter_block(w, block[i], i, (cbp >> (5 - i)) & 1)) < 0) {
528  av_log(s->avctx, AV_LOG_ERROR,
529  "\nerror while decoding inter block: %d x %d (%d)\n",
530  s->mb_x, s->mb_y, i);
531  return ret;
532  }
533  }
534  } else {
535  if (s->pict_type == AV_PICTURE_TYPE_P)
536  ff_dlog(s->avctx, "%d%d ", s->inter_intra_pred, cbp);
537  ff_dlog(s->avctx, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
538  ((cbp & 3) ? 1 : 0) + ((cbp & 0x3C) ? 2 : 0),
539  show_bits(&s->gb, 24));
540  s->ac_pred = get_bits1(&s->gb);
541  if (s->inter_intra_pred) {
542  s->h263_aic_dir = get_vlc2(&s->gb, ff_inter_intra_vlc.table,
544  ff_dlog(s->avctx, "%d%d %d %d/",
545  s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
546  }
547  if (s->per_mb_rl_table && cbp) {
548  s->rl_table_index = decode012(&s->gb);
549  s->rl_chroma_table_index = s->rl_table_index;
550  }
551 
552  s->bdsp.clear_blocks(s->block[0]);
553  for (i = 0; i < 6; i++) {
554  if ((ret = ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL)) < 0) {
555  av_log(s->avctx, AV_LOG_ERROR,
556  "\nerror while decoding intra block: %d x %d (%d)\n",
557  s->mb_x, s->mb_y, i);
558  return ret;
559  }
560  }
561  }
562 
563  return 0;
564 }
565 
567 {
568  WMV2DecContext *const w = avctx->priv_data;
569  MpegEncContext *const s = &w->s;
570  int ret;
571 
572  s->private_ctx = &w->common;
573 
574  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
575  return ret;
576 
577  s->decode_mb = wmv2_decode_mb;
578 
580 
581  return ff_intrax8_common_init(avctx, &w->x8,
582  w->s.block, w->s.block_last_index,
583  w->s.mb_width, w->s.mb_height);
584 }
585 
587 {
588  WMV2DecContext *const w = avctx->priv_data;
589 
590  ff_intrax8_common_end(&w->x8);
591  return ff_h263_decode_end(avctx);
592 }
593 
595  .p.name = "wmv2",
596  CODEC_LONG_NAME("Windows Media Video 8"),
597  .p.type = AVMEDIA_TYPE_VIDEO,
598  .p.id = AV_CODEC_ID_WMV2,
599  .priv_data_size = sizeof(WMV2DecContext),
601  .close = wmv2_decode_end,
604  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
605  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
606  AV_PIX_FMT_NONE },
607 };
WMV2DecContext::abt_type_table
int abt_type_table[6]
Definition: wmv2dec.c:46
A
#define A(x)
Definition: vpx_arith.h:28
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:60
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:264
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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:42
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
wmv2_decode_inter_block
static int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block, int n, int cbp)
Definition: wmv2dec.c:410
mem_internal.h
WMV2DecContext::abt_block2
int16_t abt_block2[6][64]
Definition: wmv2dec.c:55
WMV2DecContext::skip_type
int skip_type
Definition: wmv2dec.c:53
ff_wmv2_decoder
const FFCodec ff_wmv2_decoder
Definition: wmv2dec.c:594
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
ff_msmp4_mb_i_vlc
VLC ff_msmp4_mb_i_vlc
Definition: msmpeg4_vc1_data.c:35
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:365
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:47
WMV2DecContext::mspel_bit
int mspel_bit
Definition: wmv2dec.c:49
WMV2DecContext::cbp_table_index
int cbp_table_index
Definition: wmv2dec.c:50
FFCodec
Definition: codec_internal.h:119
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:822
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:84
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
mpegutils.h
WMV2DecContext::top_left_mv_flag
int top_left_mv_flag
Definition: wmv2dec.c:51
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
wmv2_decode_end
static av_cold int wmv2_decode_end(AVCodecContext *avctx)
Definition: wmv2dec.c:586
WMV2Context
Definition: wmv2.h:33
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1328
ff_wmv2_decode_secondary_picture_header
int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
Definition: wmv2dec.c:239
WMV2DecContext::per_block_abt
int per_block_abt
Definition: wmv2dec.c:48
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
WMV2DecContext
Definition: wmv2dec.c:38
wrap
#define wrap(func)
Definition: neontest.h:65
ff_intrax8_decode_picture
int ff_intrax8_decode_picture(IntraX8Context *w, Picture *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:738
WMV2DecContext::x8
IntraX8Context x8
Definition: wmv2dec.c:41
WMV2DecContext::per_mb_rl_bit
int per_mb_rl_bit
Definition: wmv2dec.c:52
GetBitContext
Definition: get_bits.h:61
ff_mb_non_intra_vlc
VLC ff_mb_non_intra_vlc[4]
Definition: msmpeg4dec.c:66
ff_msmpeg4_decode_motion
void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
Definition: msmpeg4dec.c:814
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:45
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
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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:204
wmv2_get_cbp_table_index
static av_always_inline int wmv2_get_cbp_table_index(MpegEncContext *s, int cbp_index)
Definition: wmv2.h:46
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
s
#define s(width, name)
Definition: cbs_vp9.c:256
WMV2DecContext::per_mb_abt
int per_mb_abt
Definition: wmv2dec.c:47
WMV2DecContext::common
WMV2Context common
Definition: wmv2dec.c:40
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
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:43
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:201
IS_SKIP
#define IS_SKIP(a)
Definition: mpegutils.h:74
simple_idct.h
SKIP_TYPE_NONE
#define SKIP_TYPE_NONE
Definition: wmv2.h:27
decode012
static int decode012(GetBitContext *gb)
Definition: get_bits.h:821
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
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:694
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
IntraX8Context
Definition: intrax8.h:28
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
if
if(ret)
Definition: filter_design.txt:179
FRAME_SKIPPED
#define FRAME_SKIPPED
Return value for header parsers if frame is not coded.
Definition: mpegutils.h:33
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:448
run
uint8_t run
Definition: svq3.c:203
parse_mb_skip
static int parse_mb_skip(WMV2DecContext *w)
Definition: wmv2dec.c:101
ff_intrax8_common_end
av_cold void ff_intrax8_common_end(IntraX8Context *w)
Destroy IntraX8 frame structure.
Definition: intrax8.c:733
decode_ext_header
static int decode_ext_header(WMV2DecContext *w)
Definition: wmv2dec.c:166
SKIP_TYPE_MPEG
#define SKIP_TYPE_MPEG
Definition: wmv2.h:28
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
INTER_INTRA_VLC_BITS
#define INTER_INTRA_VLC_BITS
Definition: msmpeg4dec.h:28
WMV2DecContext::s
MpegEncContext s
Definition: wmv2dec.c:39
mathops.h
ff_h263_decode_frame
int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:416
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:787
wmv2.h
ff_h263_decode_end
av_cold int ff_h263_decode_end(AVCodecContext *avctx)
Definition: h263dec.c:147
intrax8.h
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
wmv2_add_block
static void wmv2_add_block(WMV2DecContext *w, int16_t *block1, uint8_t *dst, int stride, int n)
Definition: wmv2dec.c:58
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:259
codec_internal.h
ff_wmv2_scantableB
const uint8_t ff_wmv2_scantableB[64]
Definition: wmv2data.c:30
ff_inter_intra_vlc
VLC ff_inter_intra_vlc
Definition: msmpeg4dec.c:71
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:55
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:353
msmpeg4dec.h
SKIP_TYPE_ROW
#define SKIP_TYPE_ROW
Definition: wmv2.h:29
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:446
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
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
WMV2DecContext::j_type_bit
int j_type_bit
Definition: wmv2dec.c:42
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
msmpeg4.h
mid_pred
#define mid_pred
Definition: mathops.h:98
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:398
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
WMV2DecContext::abt_flag
int abt_flag
Definition: wmv2dec.c:44
VLC::table
VLCElem * table
Definition: vlc.h:33
wmv2_decode_init
static av_cold int wmv2_decode_init(AVCodecContext *avctx)
Definition: wmv2dec.c:566
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
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:39
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:260
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
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:351
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:70
block1
static int16_t block1[64]
Definition: dct.c:118
ff_wmv2_common_init
av_cold void ff_wmv2_common_init(MpegEncContext *s)
Definition: wmv2.c:28
ff_msmpeg4_coded_block_pred
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:154