FFmpeg
mss2.c
Go to the documentation of this file.
1 /*
2  * Microsoft Screen 2 (aka Windows Media Video V9 Screen) decoder
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * Microsoft Screen 2 (aka Windows Media Video V9 Screen) decoder
24  */
25 
26 #include "libavutil/avassert.h"
27 #include "error_resilience.h"
28 #include "internal.h"
29 #include "mpeg_er.h"
30 #include "msmpeg4.h"
31 #include "qpeldsp.h"
32 #include "vc1.h"
33 #include "wmv2data.h"
34 #include "mss12.h"
35 #include "mss2dsp.h"
36 
37 typedef struct MSS2Context {
45 } MSS2Context;
46 
48 {
49  while ((c->high >> 15) - (c->low >> 15) < 2) {
50  if ((c->low ^ c->high) & 0x10000) {
51  c->high ^= 0x8000;
52  c->value ^= 0x8000;
53  c->low ^= 0x8000;
54  }
55  c->high = (uint16_t)c->high << 8 | 0xFF;
56  c->value = (uint16_t)c->value << 8 | bytestream2_get_byte(c->gbc.gB);
57  c->low = (uint16_t)c->low << 8;
58  }
59 }
60 
61 ARITH_GET_BIT(arith2)
62 
63 /* L. Stuiver and A. Moffat: "Piecewise Integer Mapping for Arithmetic Coding."
64  * In Proc. 8th Data Compression Conference (DCC '98), pp. 3-12, Mar. 1998 */
65 
66 static int arith2_get_scaled_value(int value, int n, int range)
67 {
68  int split = (n << 1) - range;
69 
70  if (value > split)
71  return split + (value - split >> 1);
72  else
73  return value;
74 }
75 
76 static void arith2_rescale_interval(ArithCoder *c, int range,
77  int low, int high, int n)
78 {
79  int split = (n << 1) - range;
80 
81  if (high > split)
82  c->high = split + (high - split << 1);
83  else
84  c->high = high;
85 
86  c->high += c->low - 1;
87 
88  if (low > split)
89  c->low += split + (low - split << 1);
90  else
91  c->low += low;
92 }
93 
94 static int arith2_get_number(ArithCoder *c, int n)
95 {
96  int range = c->high - c->low + 1;
97  int scale = av_log2(range) - av_log2(n);
98  int val;
99 
100  if (n << scale > range)
101  scale--;
102 
103  n <<= scale;
104 
105  val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale;
106 
107  arith2_rescale_interval(c, range, val << scale, (val + 1) << scale, n);
108 
109  arith2_normalise(c);
110 
111  return val;
112 }
113 
114 static int arith2_get_prob(ArithCoder *c, int16_t *probs)
115 {
116  int range = c->high - c->low + 1, n = *probs;
117  int scale = av_log2(range) - av_log2(n);
118  int i = 0, val;
119 
120  if (n << scale > range)
121  scale--;
122 
123  n <<= scale;
124 
125  val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale;
126  while (probs[++i] > val) ;
127 
128  arith2_rescale_interval(c, range,
129  probs[i] << scale, probs[i - 1] << scale, n);
130 
131  return i;
132 }
133 
134 ARITH_GET_MODEL_SYM(arith2)
135 
137 {
138  int diff = (c->high >> 16) - (c->low >> 16);
139  int bp = bytestream2_tell(c->gbc.gB) - 3 << 3;
140  int bits = 1;
141 
142  while (!(diff & 0x80)) {
143  bits++;
144  diff <<= 1;
145  }
146 
147  return (bits + bp + 7 >> 3) + ((c->low >> 16) + 1 == c->high >> 16);
148 }
149 
151 {
152  c->low = 0;
153  c->high = 0xFFFFFF;
154  c->value = bytestream2_get_be24(gB);
155  c->gbc.gB = gB;
156  c->get_model_sym = arith2_get_model_sym;
158 }
159 
160 static int decode_pal_v2(MSS12Context *ctx, const uint8_t *buf, int buf_size)
161 {
162  int i, ncol;
163  uint32_t *pal = ctx->pal + 256 - ctx->free_colours;
164 
165  if (!ctx->free_colours)
166  return 0;
167 
168  ncol = *buf++;
169  if (ncol > ctx->free_colours || buf_size < 2 + ncol * 3)
170  return AVERROR_INVALIDDATA;
171  for (i = 0; i < ncol; i++)
172  *pal++ = AV_RB24(buf + 3 * i);
173 
174  return 1 + ncol * 3;
175 }
176 
177 static int decode_555(AVCodecContext *avctx, GetByteContext *gB, uint16_t *dst, ptrdiff_t stride,
178  int keyframe, int w, int h)
179 {
180  int last_symbol = 0, repeat = 0, prev_avail = 0;
181 
182  if (!keyframe) {
183  int x, y, endx, endy, t;
184 
185 #define READ_PAIR(a, b) \
186  a = bytestream2_get_byte(gB) << 4; \
187  t = bytestream2_get_byte(gB); \
188  a |= t >> 4; \
189  b = (t & 0xF) << 8; \
190  b |= bytestream2_get_byte(gB); \
191 
192  READ_PAIR(x, endx)
193  READ_PAIR(y, endy)
194 
195  if (endx >= w || endy >= h || x > endx || y > endy)
196  return AVERROR_INVALIDDATA;
197  dst += x + stride * y;
198  w = endx - x + 1;
199  h = endy - y + 1;
200  if (y)
201  prev_avail = 1;
202  }
203 
204  do {
205  uint16_t *p = dst;
206  do {
207  if (repeat-- < 1) {
208  int b = bytestream2_get_byte(gB);
209  if (b < 128)
210  last_symbol = b << 8 | bytestream2_get_byte(gB);
211  else if (b > 129) {
212  repeat = 0;
213  while (b-- > 130) {
214  if (repeat >= (INT_MAX >> 8) - 1) {
215  av_log(avctx, AV_LOG_ERROR, "repeat overflow\n");
216  return AVERROR_INVALIDDATA;
217  }
218  repeat = (repeat << 8) + bytestream2_get_byte(gB) + 1;
219  }
220  if (last_symbol == -2) {
221  int skip = FFMIN((unsigned)repeat, dst + w - p);
222  repeat -= skip;
223  p += skip;
224  }
225  } else
226  last_symbol = 127 - b;
227  }
228  if (last_symbol >= 0)
229  *p = last_symbol;
230  else if (last_symbol == -1 && prev_avail)
231  *p = *(p - stride);
232  } while (++p < dst + w);
233  dst += stride;
234  prev_avail = 1;
235  } while (--h);
236 
237  return 0;
238 }
239 
240 static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, ptrdiff_t pal_stride,
241  uint8_t *rgb_dst, ptrdiff_t rgb_stride, uint32_t *pal,
242  int keyframe, int kf_slipt, int slice, int w, int h)
243 {
244  uint8_t bits[270] = { 0 };
245  uint32_t codes[270];
246  VLC vlc;
247 
248  int current_length = 0, read_codes = 0, next_code = 0, current_codes = 0;
249  int remaining_codes, surplus_codes, i;
250 
251  const int alphabet_size = 270 - keyframe;
252 
253  int last_symbol = 0, repeat = 0, prev_avail = 0;
254 
255  if (!keyframe) {
256  int x, y, clipw, cliph;
257 
258  x = get_bits(gb, 12);
259  y = get_bits(gb, 12);
260  clipw = get_bits(gb, 12) + 1;
261  cliph = get_bits(gb, 12) + 1;
262 
263  if (x + clipw > w || y + cliph > h)
264  return AVERROR_INVALIDDATA;
265  pal_dst += pal_stride * y + x;
266  rgb_dst += rgb_stride * y + x * 3;
267  w = clipw;
268  h = cliph;
269  if (y)
270  prev_avail = 1;
271  } else {
272  if (slice > 0) {
273  pal_dst += pal_stride * kf_slipt;
274  rgb_dst += rgb_stride * kf_slipt;
275  prev_avail = 1;
276  h -= kf_slipt;
277  } else
278  h = kf_slipt;
279  }
280 
281  /* read explicit codes */
282  do {
283  while (current_codes--) {
284  int symbol = get_bits(gb, 8);
285  if (symbol >= 204 - keyframe)
286  symbol += 14 - keyframe;
287  else if (symbol > 189)
288  symbol = get_bits1(gb) + (symbol << 1) - 190;
289  if (bits[symbol])
290  return AVERROR_INVALIDDATA;
291  bits[symbol] = current_length;
292  codes[symbol] = next_code++;
293  read_codes++;
294  }
295  current_length++;
296  next_code <<= 1;
297  remaining_codes = (1 << current_length) - next_code;
298  current_codes = get_bits(gb, av_ceil_log2(remaining_codes + 1));
299  if (current_length > 22 || current_codes > remaining_codes)
300  return AVERROR_INVALIDDATA;
301  } while (current_codes != remaining_codes);
302 
303  remaining_codes = alphabet_size - read_codes;
304 
305  /* determine the minimum length to fit the rest of the alphabet */
306  while ((surplus_codes = (2 << current_length) -
307  (next_code << 1) - remaining_codes) < 0) {
308  current_length++;
309  next_code <<= 1;
310  }
311 
312  /* add the rest of the symbols lexicographically */
313  for (i = 0; i < alphabet_size; i++)
314  if (!bits[i]) {
315  if (surplus_codes-- == 0) {
316  current_length++;
317  next_code <<= 1;
318  }
319  bits[i] = current_length;
320  codes[i] = next_code++;
321  }
322 
323  if (next_code != 1 << current_length)
324  return AVERROR_INVALIDDATA;
325 
326  if ((i = init_vlc(&vlc, 9, alphabet_size, bits, 1, 1, codes, 4, 4, 0)) < 0)
327  return i;
328 
329  /* frame decode */
330  do {
331  uint8_t *pp = pal_dst;
332  uint8_t *rp = rgb_dst;
333  do {
334  if (repeat-- < 1) {
335  int b = get_vlc2(gb, vlc.table, 9, 3);
336  if (b < 256)
337  last_symbol = b;
338  else if (b < 268) {
339  b -= 256;
340  if (b == 11)
341  b = get_bits(gb, 4) + 10;
342 
343  if (!b)
344  repeat = 0;
345  else
346  repeat = get_bits(gb, b);
347 
348  repeat += (1 << b) - 1;
349 
350  if (last_symbol == -2) {
351  int skip = FFMIN(repeat, pal_dst + w - pp);
352  repeat -= skip;
353  pp += skip;
354  rp += skip * 3;
355  }
356  } else
357  last_symbol = 267 - b;
358  }
359  if (last_symbol >= 0) {
360  *pp = last_symbol;
361  AV_WB24(rp, pal[last_symbol]);
362  } else if (last_symbol == -1 && prev_avail) {
363  *pp = *(pp - pal_stride);
364  memcpy(rp, rp - rgb_stride, 3);
365  }
366  rp += 3;
367  } while (++pp < pal_dst + w);
368  pal_dst += pal_stride;
369  rgb_dst += rgb_stride;
370  prev_avail = 1;
371  } while (--h);
372 
373  ff_free_vlc(&vlc);
374  return 0;
375 }
376 
377 static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,
378  int x, int y, int w, int h, int wmv9_mask)
379 {
380  MSS2Context *ctx = avctx->priv_data;
381  MSS12Context *c = &ctx->c;
382  VC1Context *v = avctx->priv_data;
383  MpegEncContext *s = &v->s;
384  AVFrame *f;
385  int ret;
386 
387  ff_mpeg_flush(avctx);
388 
389  if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
390  return ret;
391 
393 
394  if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
395  av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");
396  return AVERROR_INVALIDDATA;
397  }
398 
399  if (s->pict_type != AV_PICTURE_TYPE_I) {
400  av_log(v->s.avctx, AV_LOG_ERROR, "expected I-frame\n");
401  return AVERROR_INVALIDDATA;
402  }
403 
404  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
405 
406  if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
407  av_log(v->s.avctx, AV_LOG_ERROR, "ff_mpv_frame_start error\n");
408  avctx->pix_fmt = AV_PIX_FMT_RGB24;
409  return ret;
410  }
411 
413 
414  v->bits = buf_size * 8;
415 
416  v->end_mb_x = (w + 15) >> 4;
417  s->end_mb_y = (h + 15) >> 4;
418  if (v->respic & 1)
419  v->end_mb_x = v->end_mb_x + 1 >> 1;
420  if (v->respic & 2)
421  s->end_mb_y = s->end_mb_y + 1 >> 1;
422 
424 
425  if (v->end_mb_x == s->mb_width && s->end_mb_y == s->mb_height) {
426  ff_er_frame_end(&s->er);
427  } else {
429  "disabling error correction due to block count mismatch %dx%d != %dx%d\n",
430  v->end_mb_x, s->end_mb_y, s->mb_width, s->mb_height);
431  }
432 
433  ff_mpv_frame_end(s);
434 
435  f = s->current_picture.f;
436 
437  if (v->respic == 3) {
438  ctx->dsp.upsample_plane(f->data[0], f->linesize[0], w, h);
439  ctx->dsp.upsample_plane(f->data[1], f->linesize[1], w+1 >> 1, h+1 >> 1);
440  ctx->dsp.upsample_plane(f->data[2], f->linesize[2], w+1 >> 1, h+1 >> 1);
441  } else if (v->respic)
443  "Asymmetric WMV9 rectangle subsampling");
444 
445  av_assert0(f->linesize[1] == f->linesize[2]);
446 
447  if (wmv9_mask != -1)
448  ctx->dsp.mss2_blit_wmv9_masked(c->rgb_pic + y * c->rgb_stride + x * 3,
449  c->rgb_stride, wmv9_mask,
450  c->pal_pic + y * c->pal_stride + x,
451  c->pal_stride,
452  f->data[0], f->linesize[0],
453  f->data[1], f->data[2], f->linesize[1],
454  w, h);
455  else
456  ctx->dsp.mss2_blit_wmv9(c->rgb_pic + y * c->rgb_stride + x * 3,
457  c->rgb_stride,
458  f->data[0], f->linesize[0],
459  f->data[1], f->data[2], f->linesize[1],
460  w, h);
461 
462  avctx->pix_fmt = AV_PIX_FMT_RGB24;
463 
464  return 0;
465 }
466 
467 struct Rectangle {
468  int coded, x, y, w, h;
469 };
470 
471 #define MAX_WMV9_RECTANGLES 20
472 #define ARITH2_PADDING 2
473 
474 static int mss2_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
475  AVPacket *avpkt)
476 {
477  const uint8_t *buf = avpkt->data;
478  int buf_size = avpkt->size;
479  MSS2Context *ctx = avctx->priv_data;
480  MSS12Context *c = &ctx->c;
481  AVFrame *frame = data;
482  GetBitContext gb;
483  GetByteContext gB;
484  ArithCoder acoder;
485 
486  int keyframe, has_wmv9, has_mv, is_rle, is_555, ret;
487 
488  struct Rectangle wmv9rects[MAX_WMV9_RECTANGLES], *r;
489  int used_rects = 0, i, implicit_rect = 0, av_uninit(wmv9_mask);
490 
491  if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
492  return ret;
493 
494  if (keyframe = get_bits1(&gb))
495  skip_bits(&gb, 7);
496  has_wmv9 = get_bits1(&gb);
497  has_mv = keyframe ? 0 : get_bits1(&gb);
498  is_rle = get_bits1(&gb);
499  is_555 = is_rle && get_bits1(&gb);
500  if (c->slice_split > 0)
501  ctx->split_position = c->slice_split;
502  else if (c->slice_split < 0) {
503  if (get_bits1(&gb)) {
504  if (get_bits1(&gb)) {
505  if (get_bits1(&gb))
506  ctx->split_position = get_bits(&gb, 16);
507  else
508  ctx->split_position = get_bits(&gb, 12);
509  } else
510  ctx->split_position = get_bits(&gb, 8) << 4;
511  } else {
512  if (keyframe)
513  ctx->split_position = avctx->height / 2;
514  }
515  } else
516  ctx->split_position = avctx->height;
517 
518  if (c->slice_split && (ctx->split_position < 1 - is_555 ||
519  ctx->split_position > avctx->height - 1))
520  return AVERROR_INVALIDDATA;
521 
522  align_get_bits(&gb);
523  buf += get_bits_count(&gb) >> 3;
524  buf_size -= get_bits_count(&gb) >> 3;
525 
526  if (buf_size < 1)
527  return AVERROR_INVALIDDATA;
528 
529  if (is_555 && (has_wmv9 || has_mv || c->slice_split && ctx->split_position))
530  return AVERROR_INVALIDDATA;
531 
532  avctx->pix_fmt = is_555 ? AV_PIX_FMT_RGB555 : AV_PIX_FMT_RGB24;
533  if (ctx->last_pic->format != avctx->pix_fmt)
534  av_frame_unref(ctx->last_pic);
535 
536  if (has_wmv9) {
537  bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
538  arith2_init(&acoder, &gB);
539 
540  implicit_rect = !arith2_get_bit(&acoder);
541 
542  while (arith2_get_bit(&acoder)) {
543  if (used_rects == MAX_WMV9_RECTANGLES)
544  return AVERROR_INVALIDDATA;
545  r = &wmv9rects[used_rects];
546  if (!used_rects)
547  r->x = arith2_get_number(&acoder, avctx->width);
548  else
549  r->x = arith2_get_number(&acoder, avctx->width -
550  wmv9rects[used_rects - 1].x) +
551  wmv9rects[used_rects - 1].x;
552  r->y = arith2_get_number(&acoder, avctx->height);
553  r->w = arith2_get_number(&acoder, avctx->width - r->x) + 1;
554  r->h = arith2_get_number(&acoder, avctx->height - r->y) + 1;
555  used_rects++;
556  }
557 
558  if (implicit_rect && used_rects) {
559  av_log(avctx, AV_LOG_ERROR, "implicit_rect && used_rects > 0\n");
560  return AVERROR_INVALIDDATA;
561  }
562 
563  if (implicit_rect) {
564  wmv9rects[0].x = 0;
565  wmv9rects[0].y = 0;
566  wmv9rects[0].w = avctx->width;
567  wmv9rects[0].h = avctx->height;
568 
569  used_rects = 1;
570  }
571  for (i = 0; i < used_rects; i++) {
572  if (!implicit_rect && arith2_get_bit(&acoder)) {
573  av_log(avctx, AV_LOG_ERROR, "Unexpected grandchildren\n");
574  return AVERROR_INVALIDDATA;
575  }
576  if (!i) {
577  wmv9_mask = arith2_get_bit(&acoder) - 1;
578  if (!wmv9_mask)
579  wmv9_mask = arith2_get_number(&acoder, 256);
580  }
581  wmv9rects[i].coded = arith2_get_number(&acoder, 2);
582  }
583 
584  buf += arith2_get_consumed_bytes(&acoder);
585  buf_size -= arith2_get_consumed_bytes(&acoder);
586  if (buf_size < 1)
587  return AVERROR_INVALIDDATA;
588  }
589 
590  c->mvX = c->mvY = 0;
591  if (keyframe && !is_555) {
592  if ((i = decode_pal_v2(c, buf, buf_size)) < 0)
593  return AVERROR_INVALIDDATA;
594  buf += i;
595  buf_size -= i;
596  } else if (has_mv) {
597  buf += 4;
598  buf_size -= 4;
599  if (buf_size < 1)
600  return AVERROR_INVALIDDATA;
601  c->mvX = AV_RB16(buf - 4) - avctx->width;
602  c->mvY = AV_RB16(buf - 2) - avctx->height;
603  }
604 
605  if (c->mvX < 0 || c->mvY < 0) {
606  FFSWAP(uint8_t *, c->pal_pic, c->last_pal_pic);
607 
608  if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
609  return ret;
610 
611  if (ctx->last_pic->data[0]) {
612  av_assert0(frame->linesize[0] == ctx->last_pic->linesize[0]);
613  c->last_rgb_pic = ctx->last_pic->data[0] +
614  ctx->last_pic->linesize[0] * (avctx->height - 1);
615  } else {
616  av_log(avctx, AV_LOG_ERROR, "Missing keyframe\n");
617  return AVERROR_INVALIDDATA;
618  }
619  } else {
620  if ((ret = ff_reget_buffer(avctx, ctx->last_pic)) < 0)
621  return ret;
622  if ((ret = av_frame_ref(frame, ctx->last_pic)) < 0)
623  return ret;
624 
625  c->last_rgb_pic = NULL;
626  }
627  c->rgb_pic = frame->data[0] +
628  frame->linesize[0] * (avctx->height - 1);
629  c->rgb_stride = -frame->linesize[0];
630 
631  frame->key_frame = keyframe;
632  frame->pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
633 
634  if (is_555) {
635  bytestream2_init(&gB, buf, buf_size);
636 
637  if (decode_555(avctx, &gB, (uint16_t *)c->rgb_pic, c->rgb_stride >> 1,
638  keyframe, avctx->width, avctx->height))
639  return AVERROR_INVALIDDATA;
640 
641  buf_size -= bytestream2_tell(&gB);
642  } else {
643  if (keyframe) {
644  c->corrupted = 0;
646  if (c->slice_split)
648  }
649  if (is_rle) {
650  if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
651  return ret;
652  if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,
653  c->rgb_pic, c->rgb_stride, c->pal, keyframe,
654  ctx->split_position, 0,
655  avctx->width, avctx->height))
656  return ret;
657  align_get_bits(&gb);
658 
659  if (c->slice_split)
660  if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,
661  c->rgb_pic, c->rgb_stride, c->pal, keyframe,
662  ctx->split_position, 1,
663  avctx->width, avctx->height))
664  return ret;
665 
666  align_get_bits(&gb);
667  buf += get_bits_count(&gb) >> 3;
668  buf_size -= get_bits_count(&gb) >> 3;
669  } else if (!implicit_rect || wmv9_mask != -1) {
670  if (c->corrupted)
671  return AVERROR_INVALIDDATA;
672  bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
673  arith2_init(&acoder, &gB);
674  c->keyframe = keyframe;
675  if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[0], &acoder, 0, 0,
676  avctx->width,
677  ctx->split_position))
678  return AVERROR_INVALIDDATA;
679 
680  buf += arith2_get_consumed_bytes(&acoder);
681  buf_size -= arith2_get_consumed_bytes(&acoder);
682  if (c->slice_split) {
683  if (buf_size < 1)
684  return AVERROR_INVALIDDATA;
685  bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
686  arith2_init(&acoder, &gB);
687  if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[1], &acoder, 0,
688  ctx->split_position,
689  avctx->width,
690  avctx->height - ctx->split_position))
691  return AVERROR_INVALIDDATA;
692 
693  buf += arith2_get_consumed_bytes(&acoder);
694  buf_size -= arith2_get_consumed_bytes(&acoder);
695  }
696  } else
697  memset(c->pal_pic, 0, c->pal_stride * avctx->height);
698  }
699 
700  if (has_wmv9) {
701  for (i = 0; i < used_rects; i++) {
702  int x = wmv9rects[i].x;
703  int y = wmv9rects[i].y;
704  int w = wmv9rects[i].w;
705  int h = wmv9rects[i].h;
706  if (wmv9rects[i].coded) {
707  int WMV9codedFrameSize;
708  if (buf_size < 4 || !(WMV9codedFrameSize = AV_RL24(buf)))
709  return AVERROR_INVALIDDATA;
710  if (ret = decode_wmv9(avctx, buf + 3, buf_size - 3,
711  x, y, w, h, wmv9_mask))
712  return ret;
713  buf += WMV9codedFrameSize + 3;
714  buf_size -= WMV9codedFrameSize + 3;
715  } else {
716  uint8_t *dst = c->rgb_pic + y * c->rgb_stride + x * 3;
717  if (wmv9_mask != -1) {
718  ctx->dsp.mss2_gray_fill_masked(dst, c->rgb_stride,
719  wmv9_mask,
720  c->pal_pic + y * c->pal_stride + x,
721  c->pal_stride,
722  w, h);
723  } else {
724  do {
725  memset(dst, 0x80, w * 3);
726  dst += c->rgb_stride;
727  } while (--h);
728  }
729  }
730  }
731  }
732 
733  if (buf_size)
734  av_log(avctx, AV_LOG_WARNING, "buffer not fully consumed\n");
735 
736  if (c->mvX < 0 || c->mvY < 0) {
737  av_frame_unref(ctx->last_pic);
738  ret = av_frame_ref(ctx->last_pic, frame);
739  if (ret < 0)
740  return ret;
741  }
742 
743  *got_frame = 1;
744 
745  return avpkt->size;
746 }
747 
748 static av_cold int wmv9_init(AVCodecContext *avctx)
749 {
750  VC1Context *v = avctx->priv_data;
751  int ret;
752 
753  v->s.avctx = avctx;
754 
755  if ((ret = ff_vc1_init_common(v)) < 0)
756  return ret;
757  ff_vc1dsp_init(&v->vc1dsp);
758 
759  v->profile = PROFILE_MAIN;
760 
763  v->res_y411 = 0;
764  v->res_sprite = 0;
765 
766  v->frmrtq_postproc = 7;
767  v->bitrtq_postproc = 31;
768 
769  v->res_x8 = 0;
770  v->multires = 0;
771  v->res_fasttx = 1;
772 
773  v->fastuvmc = 0;
774 
775  v->extended_mv = 0;
776 
777  v->dquant = 1;
778  v->vstransform = 1;
779 
780  v->res_transtab = 0;
781 
782  v->overlap = 0;
783 
784  v->resync_marker = 0;
785  v->rangered = 0;
786 
787  v->s.max_b_frames = avctx->max_b_frames = 0;
788  v->quantizer_mode = 0;
789 
790  v->finterpflag = 0;
791 
792  v->res_rtm_flag = 1;
793 
795 
796  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0 ||
797  (ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
798  return ret;
799 
800  /* error concealment */
803 
804  return 0;
805 }
806 
808 {
809  MSS2Context *const ctx = avctx->priv_data;
810 
811  av_frame_free(&ctx->last_pic);
812 
813  ff_mss12_decode_end(&ctx->c);
814  av_freep(&ctx->c.pal_pic);
815  av_freep(&ctx->c.last_pal_pic);
816  ff_vc1_decode_end(avctx);
817 
818  return 0;
819 }
820 
822 {
823  MSS2Context * const ctx = avctx->priv_data;
824  MSS12Context *c = &ctx->c;
825  int ret;
826  c->avctx = avctx;
827  if (ret = ff_mss12_decode_init(c, 1, &ctx->sc[0], &ctx->sc[1]))
828  return ret;
829  ctx->last_pic = av_frame_alloc();
830  c->pal_stride = c->mask_stride;
831  c->pal_pic = av_mallocz(c->pal_stride * avctx->height);
832  c->last_pal_pic = av_mallocz(c->pal_stride * avctx->height);
833  if (!c->pal_pic || !c->last_pal_pic || !ctx->last_pic) {
834  mss2_decode_end(avctx);
835  return AVERROR(ENOMEM);
836  }
837  if (ret = wmv9_init(avctx)) {
838  mss2_decode_end(avctx);
839  return ret;
840  }
841  ff_mss2dsp_init(&ctx->dsp);
842  ff_qpeldsp_init(&ctx->qdsp);
843 
844  avctx->pix_fmt = c->free_colours == 127 ? AV_PIX_FMT_RGB555
846 
847 
848  return 0;
849 }
850 
852  .name = "mss2",
853  .long_name = NULL_IF_CONFIG_SMALL("MS Windows Media Video V9 Screen"),
854  .type = AVMEDIA_TYPE_VIDEO,
855  .id = AV_CODEC_ID_MSS2,
856  .priv_data_size = sizeof(MSS2Context),
858  .close = mss2_decode_end,
860  .capabilities = AV_CODEC_CAP_DR1,
861 };
static av_cold int mss2_decode_init(AVCodecContext *avctx)
Definition: mss2.c:821
#define NULL
Definition: coverity.c:32
MSS12Context c
Definition: mss2.c:41
const char const char void * val
Definition: avisynth_c.h:863
#define ARITH2_PADDING
Definition: mss2.c:472
qpel_mc_func avg_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:74
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int arith2_get_scaled_value(int value, int n, int range)
Definition: mss2.c:66
QpelDSPContext qdsp
Definition: mss2.c:43
The VC1 Context.
Definition: vc1.h:173
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int(* get_number)(struct ArithCoder *c, int n)
Definition: mss12.h:55
const uint8_t ff_wmv2_scantableB[64]
Definition: wmv2data.c:30
int high
Definition: mss12.h:49
av_cold int ff_mss12_decode_init(MSS12Context *c, int version, SliceContext *sc1, SliceContext *sc2)
Definition: mss12.c:565
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:301
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
int(* get_model_sym)(struct ArithCoder *c, Model *m)
Definition: mss12.h:54
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:154
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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:1825
#define avpriv_request_sample(...)
int extended_mv
Ext MV in P/B (not in Simple)
Definition: vc1.h:223
int value
Definition: mss12.h:49
void ff_er_frame_end(ERContext *s)
int corrupted
Definition: mss12.h:89
static void arith2_rescale_interval(ArithCoder *c, int range, int low, int high, int n)
Definition: mss2.c:76
int size
Definition: avcodec.h:1478
int av_log2(unsigned v)
Definition: intmath.c:26
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
int w
Definition: mss2.c:468
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
discard all
Definition: avcodec.h:811
int fastuvmc
Rounding of qpel vector to hpel ? (not in Simple)
Definition: vc1.h:222
int end_mb_x
Horizontal macroblock limit (used only by mss2)
Definition: vc1.h:399
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
uint8_t * rgb_pic
Definition: mss12.h:83
QpelDSPContext qdsp
Definition: mpegvideo.h:235
AVCodec.
Definition: avcodec.h:3477
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
int frmrtq_postproc
3 bits,
Definition: vc1.h:219
int ff_mss12_decode_rect(SliceContext *sc, ArithCoder *acoder, int x, int y, int width, int height)
Definition: mss12.c:529
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: decode.c:2011
int bits
Definition: vc1.h:179
int slice_split
Definition: mss12.h:90
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int res_transtab
reserved, always 0
Definition: vc1.h:188
uint32_t pal[256]
Definition: mss12.h:77
uint8_t
uint8_t * last_pal_pic
Definition: mss12.h:79
#define av_cold
Definition: attributes.h:82
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
int keyframe
Definition: mss12.h:87
av_cold int ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1.c:1577
#define f(width, name)
Definition: cbs_vp9.c:255
qpel_mc_func(* qpel_put)[16]
Definition: motion_est.h:91
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
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:443
ptrdiff_t rgb_stride
Definition: mss12.h:85
int coded
Definition: mss2.c:468
int split_position
Definition: mss2.c:39
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:180
quarterpel DSP functions
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags...
Definition: vc1.h:218
uint8_t * data
Definition: avcodec.h:1477
GetByteContext * gB
Definition: mss12.h:52
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
int ff_vc1_decode_end(AVCodecContext *avctx)
Close a VC1/WMV3 decoder.
Definition: vc1dec.c:587
#define av_log(a,...)
static int arith2_get_number(ArithCoder *c, int n)
Definition: mss2.c:94
int h
Definition: mss2.c:468
static int arith2_get_prob(ArithCoder *c, int16_t *probs)
Definition: mss2.c:114
static av_cold int wmv9_init(AVCodecContext *avctx)
Definition: mss2.c:748
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold void ff_mss2dsp_init(MSS2DSPContext *dsp)
Definition: mss2dsp.c:150
int res_y411
reserved, old interlaced mode
Definition: vc1.h:184
int overlap
overlapped transforms in use
Definition: vc1.h:226
int res_x8
reserved
Definition: vc1.h:185
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int x, int y, int w, int h, int wmv9_mask)
Definition: mss2.c:377
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
ERContext er
Definition: mpegvideo.h:566
const char * r
Definition: vf_curves.c:114
void(* upsample_plane)(uint8_t *plane, ptrdiff_t plane_stride, int w, int h)
Definition: mss2dsp.h:46
#define ARITH_GET_MODEL_SYM(prefix)
Definition: mss12.h:118
int mvY
Definition: mss12.h:88
simple assert() macros that are a bit more flexible than ISO C assert().
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:2947
const char * name
Name of the codec implementation.
Definition: avcodec.h:3484
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:87
uint8_t bits
Definition: vp3data.h:202
qpel_mc_func put_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:73
GetBitContext gb
Definition: mpegvideo.h:448
int resync_marker
could this stream contain resync markers
Definition: vc1.h:402
const uint8_t ff_wmv2_scantableA[64]
Definition: wmv2data.c:23
const uint8_t * zz_8x4
Zigzag scan table for TT_8x4 coding mode.
Definition: vc1.h:241
int res_rtm_flag
reserved, set to 1
Definition: vc1.h:191
Definition: vlc.h:26
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
static void arith2_init(ArithCoder *c, GetByteContext *gB)
Definition: mss2.c:150
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2307
AVCodecContext * avctx
Definition: mss12.h:76
const uint8_t * zz_4x8
Zigzag scan table for TT_4x8 coding mode.
Definition: vc1.h:242
#define b
Definition: input.c:41
SliceContext sc[2]
Definition: mss2.c:44
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:351
#define FFMIN(a, b)
Definition: common.h:96
int width
picture width / height.
Definition: avcodec.h:1738
uint8_t w
Definition: llviddspenc.c:38
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:622
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
ptrdiff_t pal_stride
Definition: mss12.h:80
#define s(width, name)
Definition: cbs_vp9.c:257
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
static int decode_555(AVCodecContext *avctx, GetByteContext *gB, uint16_t *dst, ptrdiff_t stride, int keyframe, int w, int h)
Definition: mss2.c:177
MotionEstContext me
Definition: mpegvideo.h:282
int n
Definition: avisynth_c.h:760
static int arith2_get_consumed_bytes(ArithCoder *c)
Definition: mss2.c:136
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
int rangered
RANGEREDFRM (range reduction) syntax element present at frame level.
Definition: vc1.h:189
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:341
int finterpflag
INTERPFRM present.
Definition: vc1.h:228
av_cold int ff_mss12_decode_end(MSS12Context *c)
Definition: mss12.c:677
int res_sprite
Simple/Main Profile sequence header.
Definition: vc1.h:183
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:87
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int multires
frame-level RESPIC syntax element present
Definition: vc1.h:186
main external API structure.
Definition: avcodec.h:1565
static av_cold int mss2_decode_end(AVCodecContext *avctx)
Definition: mss2.c:807
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
void * buf
Definition: avisynth_c.h:766
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
struct AVFrame * f
Definition: mpegpicture.h:46
uint8_t respic
Frame-level flag for resized images.
Definition: vc1.h:274
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1207
int quantizer_mode
2 bits, quantizer mode used for sequence, see QUANT_*
Definition: vc1.h:227
int max_b_frames
max number of B-frames for encoding
Definition: mpegvideo.h:115
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
quarterpel DSP context
Definition: qpeldsp.h:72
int vstransform
variable-size [48]x[48] transform type + info
Definition: vc1.h:225
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
AVCodec ff_mss2_decoder
Definition: mss2.c:851
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
qpel_mc_func(* qpel_avg)[16]
Definition: motion_est.h:92
MpegEncContext s
Definition: vc1.h:174
VC1Context v
Definition: mss2.c:38
MpegEncContext.
Definition: mpegvideo.h:81
void ff_vc1_init_transposed_scantables(VC1Context *v)
Definition: vc1dec.c:403
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
int y
Definition: mss2.c:468
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
void(* mss2_gray_fill_masked)(uint8_t *dst, ptrdiff_t dst_stride, int maskcolor, const uint8_t *mask, ptrdiff_t mask_stride, int w, int h)
Definition: mss2dsp.h:43
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
void(* mss2_blit_wmv9_masked)(uint8_t *dst, ptrdiff_t dst_stride, int maskcolor, const uint8_t *mask, ptrdiff_t mask_stride, const uint8_t *srcy, ptrdiff_t srcy_stride, const uint8_t *srcu, const uint8_t *srcv, ptrdiff_t srcuv_stride, int w, int h)
Definition: mss2dsp.h:37
common internal api header.
void ff_mss12_slicecontext_reset(SliceContext *sc)
Definition: mss12.c:429
int res_fasttx
reserved, always 1
Definition: vc1.h:187
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:375
enum AVDiscard skip_loop_filter
Skip loop filtering for selected frames.
Definition: avcodec.h:3022
Microsoft Screen 2 (aka Windows Media Video V9 Screen) decoder DSP routines.
int free_colours
Definition: mss12.h:86
ptrdiff_t mask_stride
Definition: mss12.h:82
void * priv_data
Definition: avcodec.h:1592
static av_always_inline int diff(const uint32_t a, const uint32_t b)
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1431
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int low
Definition: mss12.h:49
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:346
uint8_t * last_rgb_pic
Definition: mss12.h:84
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
int bitrtq_postproc
5 bits, quantized framerate-based postprocessing strength
Definition: vc1.h:220
AVFrame * last_pic
Definition: mss2.c:40
static int decode_pal_v2(MSS12Context *ctx, const uint8_t *buf, int buf_size)
Definition: mss2.c:160
#define av_uninit(x)
Definition: attributes.h:148
#define ARITH_GET_BIT(prefix)
Definition: mss12.h:102
int ff_vc1_decode_init_alloc_tables(VC1Context *v)
Definition: vc1dec.c:324
static void arith2_normalise(ArithCoder *c)
Definition: mss2.c:47
#define av_freep(p)
union ArithCoder::@118 gbc
#define READ_PAIR(a, b)
MSS2DSPContext dsp
Definition: mss2.c:42
static int mss2_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mss2.c:474
int dquant
How qscale varies with MBs, 2 bits (not in Simple)
Definition: vc1.h:224
int mvX
Definition: mss12.h:88
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
Definition: qpeldsp.c:783
#define FFSWAP(type, a, b)
Definition: common.h:99
#define stride
void(* mss2_blit_wmv9)(uint8_t *dst, ptrdiff_t dst_stride, const uint8_t *srcy, ptrdiff_t srcy_stride, const uint8_t *srcu, const uint8_t *srcv, ptrdiff_t srcuv_stride, int w, int h)
Definition: mss2dsp.h:33
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
This structure stores compressed data.
Definition: avcodec.h:1454
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1176
av_cold void ff_vc1dsp_init(VC1DSPContext *dsp)
Definition: vc1dsp.c:971
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
uint8_t * pal_pic
Definition: mss12.h:78
static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, ptrdiff_t pal_stride, uint8_t *rgb_dst, ptrdiff_t rgb_stride, uint32_t *pal, int keyframe, int kf_slipt, int slice, int w, int h)
Definition: mss2.c:240
VC1DSPContext vc1dsp
Definition: vc1.h:177
Predicted.
Definition: avutil.h:275
Common header for Microsoft Screen 1 and 2.
int x
Definition: mss2.c:468