Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/mss2.c |
Date: | 2022-07-07 01:21:54 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 424 | 502 | 84.5% |
Branches: | 232 | 312 | 74.4% |
Line | Branch | Exec | Source |
---|---|---|---|
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 "codec_internal.h" | ||
28 | #include "error_resilience.h" | ||
29 | #include "internal.h" | ||
30 | #include "mpeg_er.h" | ||
31 | #include "mpegvideodec.h" | ||
32 | #include "msmpeg4dec.h" | ||
33 | #include "qpeldsp.h" | ||
34 | #include "vc1.h" | ||
35 | #include "wmv2data.h" | ||
36 | #include "mss12.h" | ||
37 | #include "mss2dsp.h" | ||
38 | |||
39 | typedef struct MSS2Context { | ||
40 | VC1Context v; | ||
41 | int split_position; | ||
42 | AVFrame *last_pic; | ||
43 | MSS12Context c; | ||
44 | MSS2DSPContext dsp; | ||
45 | SliceContext sc[2]; | ||
46 | } MSS2Context; | ||
47 | |||
48 | 3080857 | static void arith2_normalise(ArithCoder *c) | |
49 | { | ||
50 |
2/2✓ Branch 0 taken 39282 times.
✓ Branch 1 taken 3080857 times.
|
3120139 | while ((c->high >> 15) - (c->low >> 15) < 2) { |
51 |
2/2✓ Branch 0 taken 8424 times.
✓ Branch 1 taken 30858 times.
|
39282 | if ((c->low ^ c->high) & 0x10000) { |
52 | 8424 | c->high ^= 0x8000; | |
53 | 8424 | c->value ^= 0x8000; | |
54 | 8424 | c->low ^= 0x8000; | |
55 | } | ||
56 | 39282 | c->high = (uint16_t)c->high << 8 | 0xFF; | |
57 | 39282 | c->value = (uint16_t)c->value << 8 | bytestream2_get_byte(c->gbc.gB); | |
58 | 39282 | c->low = (uint16_t)c->low << 8; | |
59 | } | ||
60 | 3080857 | } | |
61 | |||
62 |
2/2✓ Branch 0 taken 85 times.
✓ Branch 1 taken 158 times.
|
243 | ARITH_GET_BIT(arith2) |
63 | |||
64 | /* L. Stuiver and A. Moffat: "Piecewise Integer Mapping for Arithmetic Coding." | ||
65 | * In Proc. 8th Data Compression Conference (DCC '98), pp. 3-12, Mar. 1998 */ | ||
66 | |||
67 | 3080614 | static int arith2_get_scaled_value(int value, int n, int range) | |
68 | { | ||
69 | 3080614 | int split = (n << 1) - range; | |
70 | |||
71 |
2/2✓ Branch 0 taken 1706480 times.
✓ Branch 1 taken 1374134 times.
|
3080614 | if (value > split) |
72 | 1706480 | return split + (value - split >> 1); | |
73 | else | ||
74 | 1374134 | return value; | |
75 | } | ||
76 | |||
77 | 3080614 | static void arith2_rescale_interval(ArithCoder *c, int range, | |
78 | int low, int high, int n) | ||
79 | { | ||
80 | 3080614 | int split = (n << 1) - range; | |
81 | |||
82 |
2/2✓ Branch 0 taken 3008013 times.
✓ Branch 1 taken 72601 times.
|
3080614 | if (high > split) |
83 | 3008013 | c->high = split + (high - split << 1); | |
84 | else | ||
85 | 72601 | c->high = high; | |
86 | |||
87 | 3080614 | c->high += c->low - 1; | |
88 | |||
89 |
2/2✓ Branch 0 taken 28986 times.
✓ Branch 1 taken 3051628 times.
|
3080614 | if (low > split) |
90 | 28986 | c->low += split + (low - split << 1); | |
91 | else | ||
92 | 3051628 | c->low += low; | |
93 | 3080614 | } | |
94 | |||
95 | 806 | static int arith2_get_number(ArithCoder *c, int n) | |
96 | { | ||
97 | 806 | int range = c->high - c->low + 1; | |
98 | 806 | int scale = av_log2(range) - av_log2(n); | |
99 | int val; | ||
100 | |||
101 |
2/2✓ Branch 0 taken 368 times.
✓ Branch 1 taken 438 times.
|
806 | if (n << scale > range) |
102 | 368 | scale--; | |
103 | |||
104 | 806 | n <<= scale; | |
105 | |||
106 | 806 | val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale; | |
107 | |||
108 | 806 | arith2_rescale_interval(c, range, val << scale, (val + 1) << scale, n); | |
109 | |||
110 | 806 | arith2_normalise(c); | |
111 | |||
112 | 806 | return val; | |
113 | } | ||
114 | |||
115 | 3079808 | static int arith2_get_prob(ArithCoder *c, int16_t *probs) | |
116 | { | ||
117 | 3079808 | int range = c->high - c->low + 1, n = *probs; | |
118 | 3079808 | int scale = av_log2(range) - av_log2(n); | |
119 | 3079808 | int i = 0, val; | |
120 | |||
121 |
2/2✓ Branch 0 taken 1611522 times.
✓ Branch 1 taken 1468286 times.
|
3079808 | if (n << scale > range) |
122 | 1611522 | scale--; | |
123 | |||
124 | 3079808 | n <<= scale; | |
125 | |||
126 | 3079808 | val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale; | |
127 |
2/2✓ Branch 0 taken 85108 times.
✓ Branch 1 taken 3079808 times.
|
3164916 | while (probs[++i] > val) ; |
128 | |||
129 | 3079808 | arith2_rescale_interval(c, range, | |
130 | 3079808 | probs[i] << scale, probs[i - 1] << scale, n); | |
131 | |||
132 | 3079808 | return i; | |
133 | } | ||
134 | |||
135 | 3079808 | ARITH_GET_MODEL_SYM(arith2) | |
136 | |||
137 | 358 | static int arith2_get_consumed_bytes(ArithCoder *c) | |
138 | { | ||
139 | 358 | int diff = (c->high >> 16) - (c->low >> 16); | |
140 | 358 | int bp = bytestream2_tell(c->gbc.gB) - 3 << 3; | |
141 | 358 | int bits = 1; | |
142 | |||
143 |
2/2✓ Branch 0 taken 1440 times.
✓ Branch 1 taken 358 times.
|
1798 | while (!(diff & 0x80)) { |
144 | 1440 | bits++; | |
145 | 1440 | diff <<= 1; | |
146 | } | ||
147 | |||
148 | 358 | return (bits + bp + 7 >> 3) + ((c->low >> 16) + 1 == c->high >> 16); | |
149 | } | ||
150 | |||
151 | 179 | static void arith2_init(ArithCoder *c, GetByteContext *gB) | |
152 | { | ||
153 | 179 | c->low = 0; | |
154 | 179 | c->high = 0xFFFFFF; | |
155 | 179 | c->value = bytestream2_get_be24(gB); | |
156 | 179 | c->overread = 0; | |
157 | 179 | c->gbc.gB = gB; | |
158 | 179 | c->get_model_sym = arith2_get_model_sym; | |
159 | 179 | c->get_number = arith2_get_number; | |
160 | 179 | } | |
161 | |||
162 | 4 | static int decode_pal_v2(MSS12Context *ctx, const uint8_t *buf, int buf_size) | |
163 | { | ||
164 | int i, ncol; | ||
165 | 4 | uint32_t *pal = ctx->pal + 256 - ctx->free_colours; | |
166 | |||
167 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (!ctx->free_colours) |
168 | ✗ | return 0; | |
169 | |||
170 | 4 | ncol = *buf++; | |
171 |
2/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
|
4 | if (ncol > ctx->free_colours || buf_size < 2 + ncol * 3) |
172 | ✗ | return AVERROR_INVALIDDATA; | |
173 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 4 times.
|
21 | for (i = 0; i < ncol; i++) |
174 | 17 | *pal++ = AV_RB24(buf + 3 * i); | |
175 | |||
176 | 4 | return 1 + ncol * 3; | |
177 | } | ||
178 | |||
179 | 4 | static int decode_555(AVCodecContext *avctx, GetByteContext *gB, uint16_t *dst, ptrdiff_t stride, | |
180 | int keyframe, int w, int h) | ||
181 | { | ||
182 | 4 | int last_symbol = 0, repeat = 0, prev_avail = 0; | |
183 | |||
184 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
|
4 | if (!keyframe) { |
185 | int x, y, endx, endy, t; | ||
186 | |||
187 | #define READ_PAIR(a, b) \ | ||
188 | a = bytestream2_get_byte(gB) << 4; \ | ||
189 | t = bytestream2_get_byte(gB); \ | ||
190 | a |= t >> 4; \ | ||
191 | b = (t & 0xF) << 8; \ | ||
192 | b |= bytestream2_get_byte(gB); \ | ||
193 | |||
194 | 2 | READ_PAIR(x, endx) | |
195 | 2 | READ_PAIR(y, endy) | |
196 | |||
197 |
4/8✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
2 | if (endx >= w || endy >= h || x > endx || y > endy) |
198 | ✗ | return AVERROR_INVALIDDATA; | |
199 | 2 | dst += x + stride * y; | |
200 | 2 | w = endx - x + 1; | |
201 | 2 | h = endy - y + 1; | |
202 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | if (y) |
203 | 2 | prev_avail = 1; | |
204 | } | ||
205 | |||
206 | do { | ||
207 | 146 | uint16_t *p = dst; | |
208 | do { | ||
209 |
2/2✓ Branch 0 taken 5320 times.
✓ Branch 1 taken 3880 times.
|
9200 | if (repeat-- < 1) { |
210 | 5320 | int b = bytestream2_get_byte(gB); | |
211 |
2/2✓ Branch 0 taken 2920 times.
✓ Branch 1 taken 2400 times.
|
5320 | if (b < 128) |
212 | 2920 | last_symbol = b << 8 | bytestream2_get_byte(gB); | |
213 |
2/2✓ Branch 0 taken 1440 times.
✓ Branch 1 taken 960 times.
|
2400 | else if (b > 129) { |
214 | 1440 | repeat = 0; | |
215 |
2/2✓ Branch 0 taken 398 times.
✓ Branch 1 taken 1440 times.
|
1838 | while (b-- > 130) { |
216 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 398 times.
|
398 | if (repeat >= (INT_MAX >> 8) - 1) { |
217 | ✗ | av_log(avctx, AV_LOG_ERROR, "repeat overflow\n"); | |
218 | ✗ | return AVERROR_INVALIDDATA; | |
219 | } | ||
220 | 398 | repeat = (repeat << 8) + bytestream2_get_byte(gB) + 1; | |
221 | } | ||
222 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 1430 times.
|
1440 | if (last_symbol == -2) { |
223 | 10 | int skip = FFMIN((unsigned)repeat, dst + w - p); | |
224 | 10 | repeat -= skip; | |
225 | 10 | p += skip; | |
226 | } | ||
227 | } else | ||
228 | 960 | last_symbol = 127 - b; | |
229 | } | ||
230 |
2/2✓ Branch 0 taken 4414 times.
✓ Branch 1 taken 4786 times.
|
9200 | if (last_symbol >= 0) |
231 | 4414 | *p = last_symbol; | |
232 |
3/4✓ Branch 0 taken 4764 times.
✓ Branch 1 taken 22 times.
✓ Branch 2 taken 4764 times.
✗ Branch 3 not taken.
|
4786 | else if (last_symbol == -1 && prev_avail) |
233 | 4764 | *p = *(p - stride); | |
234 |
2/2✓ Branch 0 taken 9054 times.
✓ Branch 1 taken 146 times.
|
9200 | } while (++p < dst + w); |
235 | 146 | dst += stride; | |
236 | 146 | prev_avail = 1; | |
237 |
2/2✓ Branch 0 taken 142 times.
✓ Branch 1 taken 4 times.
|
146 | } while (--h); |
238 | |||
239 | 4 | return 0; | |
240 | } | ||
241 | |||
242 | 6 | static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, ptrdiff_t pal_stride, | |
243 | uint8_t *rgb_dst, ptrdiff_t rgb_stride, uint32_t *pal, | ||
244 | int keyframe, int kf_slipt, int slice, int w, int h) | ||
245 | { | ||
246 | 6 | uint8_t bits[270] = { 0 }; | |
247 | uint32_t codes[270]; | ||
248 | VLC vlc; | ||
249 | |||
250 | 6 | int current_length = 0, read_codes = 0, next_code = 0, current_codes = 0; | |
251 | int remaining_codes, surplus_codes, i; | ||
252 | |||
253 | 6 | const int alphabet_size = 270 - keyframe; | |
254 | |||
255 | 6 | int last_symbol = 0, repeat = 0, prev_avail = 0; | |
256 | |||
257 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
|
6 | if (!keyframe) { |
258 | int x, y, clipw, cliph; | ||
259 | |||
260 | 3 | x = get_bits(gb, 12); | |
261 | 3 | y = get_bits(gb, 12); | |
262 | 3 | clipw = get_bits(gb, 12) + 1; | |
263 | 3 | cliph = get_bits(gb, 12) + 1; | |
264 | |||
265 |
2/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
|
3 | if (x + clipw > w || y + cliph > h) |
266 | ✗ | return AVERROR_INVALIDDATA; | |
267 | 3 | pal_dst += pal_stride * y + x; | |
268 | 3 | rgb_dst += rgb_stride * y + x * 3; | |
269 | 3 | w = clipw; | |
270 | 3 | h = cliph; | |
271 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | if (y) |
272 | 3 | prev_avail = 1; | |
273 | } else { | ||
274 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
|
3 | if (slice > 0) { |
275 | 1 | pal_dst += pal_stride * kf_slipt; | |
276 | 1 | rgb_dst += rgb_stride * kf_slipt; | |
277 | 1 | prev_avail = 1; | |
278 | 1 | h -= kf_slipt; | |
279 | } else | ||
280 | 2 | h = kf_slipt; | |
281 | } | ||
282 | |||
283 | /* read explicit codes */ | ||
284 | do { | ||
285 |
2/2✓ Branch 0 taken 153 times.
✓ Branch 1 taken 78 times.
|
231 | while (current_codes--) { |
286 | 153 | int symbol = get_bits(gb, 8); | |
287 |
2/2✓ Branch 0 taken 52 times.
✓ Branch 1 taken 101 times.
|
153 | if (symbol >= 204 - keyframe) |
288 | 52 | symbol += 14 - keyframe; | |
289 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 90 times.
|
101 | else if (symbol > 189) |
290 | 11 | symbol = get_bits1(gb) + (symbol << 1) - 190; | |
291 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 153 times.
|
153 | if (bits[symbol]) |
292 | ✗ | return AVERROR_INVALIDDATA; | |
293 | 153 | bits[symbol] = current_length; | |
294 | 153 | codes[symbol] = next_code++; | |
295 | 153 | read_codes++; | |
296 | } | ||
297 | 78 | current_length++; | |
298 | 78 | next_code <<= 1; | |
299 | 78 | remaining_codes = (1 << current_length) - next_code; | |
300 | 78 | current_codes = get_bits(gb, av_ceil_log2(remaining_codes + 1)); | |
301 |
2/4✓ Branch 0 taken 78 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78 times.
|
78 | if (current_length > 22 || current_codes > remaining_codes) |
302 | ✗ | return AVERROR_INVALIDDATA; | |
303 |
2/2✓ Branch 0 taken 72 times.
✓ Branch 1 taken 6 times.
|
78 | } while (current_codes != remaining_codes); |
304 | |||
305 | 6 | remaining_codes = alphabet_size - read_codes; | |
306 | |||
307 | /* determine the minimum length to fit the rest of the alphabet */ | ||
308 | 6 | while ((surplus_codes = (2 << current_length) - | |
309 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 6 times.
|
19 | (next_code << 1) - remaining_codes) < 0) { |
310 | 13 | current_length++; | |
311 | 13 | next_code <<= 1; | |
312 | } | ||
313 | |||
314 | /* add the rest of the symbols lexicographically */ | ||
315 |
2/2✓ Branch 0 taken 1617 times.
✓ Branch 1 taken 6 times.
|
1623 | for (i = 0; i < alphabet_size; i++) |
316 |
2/2✓ Branch 0 taken 1464 times.
✓ Branch 1 taken 153 times.
|
1617 | if (!bits[i]) { |
317 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1458 times.
|
1464 | if (surplus_codes-- == 0) { |
318 | 6 | current_length++; | |
319 | 6 | next_code <<= 1; | |
320 | } | ||
321 | 1464 | bits[i] = current_length; | |
322 | 1464 | codes[i] = next_code++; | |
323 | } | ||
324 | |||
325 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (next_code != 1 << current_length) |
326 | ✗ | return AVERROR_INVALIDDATA; | |
327 | |||
328 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
|
6 | if ((i = init_vlc(&vlc, 9, alphabet_size, bits, 1, 1, codes, 4, 4, 0)) < 0) |
329 | ✗ | return i; | |
330 | |||
331 | /* frame decode */ | ||
332 | do { | ||
333 | 146 | uint8_t *pp = pal_dst; | |
334 | 146 | uint8_t *rp = rgb_dst; | |
335 | do { | ||
336 |
2/2✓ Branch 0 taken 1908 times.
✓ Branch 1 taken 7240 times.
|
9148 | if (repeat-- < 1) { |
337 | 1908 | int b = get_vlc2(gb, vlc.table, 9, 3); | |
338 |
2/2✓ Branch 0 taken 686 times.
✓ Branch 1 taken 1222 times.
|
1908 | if (b < 256) |
339 | 686 | last_symbol = b; | |
340 |
2/2✓ Branch 0 taken 828 times.
✓ Branch 1 taken 394 times.
|
1222 | else if (b < 268) { |
341 | 828 | b -= 256; | |
342 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 828 times.
|
828 | if (b == 11) |
343 | ✗ | b = get_bits(gb, 4) + 10; | |
344 | |||
345 |
2/2✓ Branch 0 taken 84 times.
✓ Branch 1 taken 744 times.
|
828 | if (!b) |
346 | 84 | repeat = 0; | |
347 | else | ||
348 | 744 | repeat = get_bits(gb, b); | |
349 | |||
350 | 828 | repeat += (1 << b) - 1; | |
351 | |||
352 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 796 times.
|
828 | if (last_symbol == -2) { |
353 | 32 | int skip = FFMIN(repeat, pal_dst + w - pp); | |
354 | 32 | repeat -= skip; | |
355 | 32 | pp += skip; | |
356 | 32 | rp += skip * 3; | |
357 | } | ||
358 | } else | ||
359 | 394 | last_symbol = 267 - b; | |
360 | } | ||
361 |
2/2✓ Branch 0 taken 3616 times.
✓ Branch 1 taken 5532 times.
|
9148 | if (last_symbol >= 0) { |
362 | 3616 | *pp = last_symbol; | |
363 | 3616 | AV_WB24(rp, pal[last_symbol]); | |
364 |
3/4✓ Branch 0 taken 5466 times.
✓ Branch 1 taken 66 times.
✓ Branch 2 taken 5466 times.
✗ Branch 3 not taken.
|
5532 | } else if (last_symbol == -1 && prev_avail) { |
365 | 5466 | *pp = *(pp - pal_stride); | |
366 | 5466 | memcpy(rp, rp - rgb_stride, 3); | |
367 | } | ||
368 | 9148 | rp += 3; | |
369 |
2/2✓ Branch 0 taken 9002 times.
✓ Branch 1 taken 146 times.
|
9148 | } while (++pp < pal_dst + w); |
370 | 146 | pal_dst += pal_stride; | |
371 | 146 | rgb_dst += rgb_stride; | |
372 | 146 | prev_avail = 1; | |
373 |
2/2✓ Branch 0 taken 140 times.
✓ Branch 1 taken 6 times.
|
146 | } while (--h); |
374 | |||
375 | 6 | ff_free_vlc(&vlc); | |
376 | 6 | return 0; | |
377 | } | ||
378 | |||
379 | 79 | static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size, | |
380 | int x, int y, int w, int h, int wmv9_mask) | ||
381 | { | ||
382 | 79 | MSS2Context *ctx = avctx->priv_data; | |
383 | 79 | MSS12Context *c = &ctx->c; | |
384 | 79 | VC1Context *v = avctx->priv_data; | |
385 | 79 | MpegEncContext *s = &v->s; | |
386 | AVFrame *f; | ||
387 | int ret; | ||
388 | |||
389 | 79 | ff_mpeg_flush(avctx); | |
390 | |||
391 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 79 times.
|
79 | if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0) |
392 | ✗ | return ret; | |
393 | |||
394 | 79 | s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL; | |
395 | |||
396 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 79 times.
|
79 | if (ff_vc1_parse_frame_header(v, &s->gb) < 0) { |
397 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "header error\n"); | |
398 | ✗ | return AVERROR_INVALIDDATA; | |
399 | } | ||
400 | |||
401 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 79 times.
|
79 | if (s->pict_type != AV_PICTURE_TYPE_I) { |
402 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "expected I-frame\n"); | |
403 | ✗ | return AVERROR_INVALIDDATA; | |
404 | } | ||
405 | |||
406 | 79 | avctx->pix_fmt = AV_PIX_FMT_YUV420P; | |
407 | |||
408 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 79 times.
|
79 | if ((ret = ff_mpv_frame_start(s, avctx)) < 0) { |
409 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "ff_mpv_frame_start error\n"); | |
410 | ✗ | avctx->pix_fmt = AV_PIX_FMT_RGB24; | |
411 | ✗ | return ret; | |
412 | } | ||
413 | |||
414 | 79 | ff_mpeg_er_frame_start(s); | |
415 | |||
416 | 79 | v->end_mb_x = (w + 15) >> 4; | |
417 | 79 | s->end_mb_y = (h + 15) >> 4; | |
418 |
2/2✓ Branch 0 taken 53 times.
✓ Branch 1 taken 26 times.
|
79 | if (v->respic & 1) |
419 | 53 | v->end_mb_x = v->end_mb_x + 1 >> 1; | |
420 |
2/2✓ Branch 0 taken 53 times.
✓ Branch 1 taken 26 times.
|
79 | if (v->respic & 2) |
421 | 53 | s->end_mb_y = s->end_mb_y + 1 >> 1; | |
422 | |||
423 | 79 | ff_vc1_decode_blocks(v); | |
424 | |||
425 |
3/4✓ Branch 0 taken 26 times.
✓ Branch 1 taken 53 times.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
|
79 | if (v->end_mb_x == s->mb_width && s->end_mb_y == s->mb_height) { |
426 | 26 | ff_er_frame_end(&s->er); | |
427 | } else { | ||
428 | 53 | av_log(v->s.avctx, AV_LOG_WARNING, | |
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 | 79 | ff_mpv_frame_end(s); | |
434 | |||
435 | 79 | f = s->current_picture.f; | |
436 | |||
437 |
2/2✓ Branch 0 taken 53 times.
✓ Branch 1 taken 26 times.
|
79 | if (v->respic == 3) { |
438 | 53 | ctx->dsp.upsample_plane(f->data[0], f->linesize[0], w, h); | |
439 | 53 | ctx->dsp.upsample_plane(f->data[1], f->linesize[1], w+1 >> 1, h+1 >> 1); | |
440 | 53 | ctx->dsp.upsample_plane(f->data[2], f->linesize[2], w+1 >> 1, h+1 >> 1); | |
441 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
|
26 | } else if (v->respic) |
442 | ✗ | avpriv_request_sample(v->s.avctx, | |
443 | "Asymmetric WMV9 rectangle subsampling"); | ||
444 | |||
445 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 79 times.
|
79 | av_assert0(f->linesize[1] == f->linesize[2]); |
446 | |||
447 |
1/2✓ Branch 0 taken 79 times.
✗ Branch 1 not taken.
|
79 | if (wmv9_mask != -1) |
448 | 79 | ctx->dsp.mss2_blit_wmv9_masked(c->rgb_pic + y * c->rgb_stride + x * 3, | |
449 | c->rgb_stride, wmv9_mask, | ||
450 | 79 | c->pal_pic + y * c->pal_stride + x, | |
451 | c->pal_stride, | ||
452 | 79 | f->data[0], f->linesize[0], | |
453 | 79 | 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 | 79 | avctx->pix_fmt = AV_PIX_FMT_RGB24; | |
463 | |||
464 | 79 | 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 | 108 | static int mss2_decode_frame(AVCodecContext *avctx, AVFrame *frame, | |
475 | int *got_frame, AVPacket *avpkt) | ||
476 | { | ||
477 | 108 | const uint8_t *buf = avpkt->data; | |
478 | 108 | int buf_size = avpkt->size; | |
479 | 108 | MSS2Context *ctx = avctx->priv_data; | |
480 | 108 | MSS12Context *c = &ctx->c; | |
481 | GetBitContext gb; | ||
482 | GetByteContext gB; | ||
483 | ArithCoder acoder; | ||
484 | |||
485 | int keyframe, has_wmv9, has_mv, is_rle, is_555, ret; | ||
486 | |||
487 | struct Rectangle wmv9rects[MAX_WMV9_RECTANGLES], *r; | ||
488 | 108 | int used_rects = 0, i, implicit_rect = 0, av_uninit(wmv9_mask); | |
489 | |||
490 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 108 times.
|
108 | if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0) |
491 | ✗ | return ret; | |
492 | |||
493 |
2/2✓ Branch 1 taken 6 times.
✓ Branch 2 taken 102 times.
|
108 | if (keyframe = get_bits1(&gb)) |
494 | 6 | skip_bits(&gb, 7); | |
495 | 108 | has_wmv9 = get_bits1(&gb); | |
496 |
2/2✓ Branch 0 taken 102 times.
✓ Branch 1 taken 6 times.
|
108 | has_mv = keyframe ? 0 : get_bits1(&gb); |
497 | 108 | is_rle = get_bits1(&gb); | |
498 |
4/4✓ Branch 0 taken 8 times.
✓ Branch 1 taken 100 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 4 times.
|
108 | is_555 = is_rle && get_bits1(&gb); |
499 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 108 times.
|
108 | if (c->slice_split > 0) |
500 | ✗ | ctx->split_position = c->slice_split; | |
501 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 104 times.
|
108 | else if (c->slice_split < 0) { |
502 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 2 times.
|
4 | if (get_bits1(&gb)) { |
503 |
2/2✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
|
2 | if (get_bits1(&gb)) { |
504 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
|
1 | if (get_bits1(&gb)) |
505 | ✗ | ctx->split_position = get_bits(&gb, 16); | |
506 | else | ||
507 | 1 | ctx->split_position = get_bits(&gb, 12); | |
508 | } else | ||
509 | 1 | ctx->split_position = get_bits(&gb, 8) << 4; | |
510 | } else { | ||
511 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | if (keyframe) |
512 | 1 | ctx->split_position = avctx->height / 2; | |
513 | } | ||
514 | } else | ||
515 | 104 | ctx->split_position = avctx->height; | |
516 | |||
517 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 104 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
108 | if (c->slice_split && (ctx->split_position < 1 - is_555 || |
518 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | ctx->split_position > avctx->height - 1)) |
519 | ✗ | return AVERROR_INVALIDDATA; | |
520 | |||
521 | 108 | align_get_bits(&gb); | |
522 | 108 | buf += get_bits_count(&gb) >> 3; | |
523 | 108 | buf_size -= get_bits_count(&gb) >> 3; | |
524 | |||
525 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 108 times.
|
108 | if (buf_size < 1) |
526 | ✗ | return AVERROR_INVALIDDATA; | |
527 | |||
528 |
7/10✓ Branch 0 taken 4 times.
✓ Branch 1 taken 104 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 2 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 2 times.
|
108 | if (is_555 && (has_wmv9 || has_mv || c->slice_split && ctx->split_position)) |
529 | ✗ | return AVERROR_INVALIDDATA; | |
530 | |||
531 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 104 times.
|
108 | avctx->pix_fmt = is_555 ? AV_PIX_FMT_RGB555 : AV_PIX_FMT_RGB24; |
532 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 103 times.
|
108 | if (ctx->last_pic->format != avctx->pix_fmt) |
533 | 5 | av_frame_unref(ctx->last_pic); | |
534 | |||
535 |
2/2✓ Branch 0 taken 79 times.
✓ Branch 1 taken 29 times.
|
108 | if (has_wmv9) { |
536 | 79 | bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING); | |
537 | 79 | arith2_init(&acoder, &gB); | |
538 | |||
539 | 79 | implicit_rect = !arith2_get_bit(&acoder); | |
540 | |||
541 |
2/2✓ Branch 1 taken 3 times.
✓ Branch 2 taken 79 times.
|
82 | while (arith2_get_bit(&acoder)) { |
542 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
|
3 | if (used_rects == MAX_WMV9_RECTANGLES) |
543 | ✗ | return AVERROR_INVALIDDATA; | |
544 | 3 | r = &wmv9rects[used_rects]; | |
545 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | if (!used_rects) |
546 | 3 | r->x = arith2_get_number(&acoder, avctx->width); | |
547 | else | ||
548 | ✗ | r->x = arith2_get_number(&acoder, avctx->width - | |
549 | ✗ | wmv9rects[used_rects - 1].x) + | |
550 | ✗ | wmv9rects[used_rects - 1].x; | |
551 | 3 | r->y = arith2_get_number(&acoder, avctx->height); | |
552 | 3 | r->w = arith2_get_number(&acoder, avctx->width - r->x) + 1; | |
553 | 3 | r->h = arith2_get_number(&acoder, avctx->height - r->y) + 1; | |
554 | 3 | used_rects++; | |
555 | } | ||
556 | |||
557 |
3/4✓ Branch 0 taken 76 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 76 times.
|
79 | if (implicit_rect && used_rects) { |
558 | ✗ | av_log(avctx, AV_LOG_ERROR, "implicit_rect && used_rects > 0\n"); | |
559 | ✗ | return AVERROR_INVALIDDATA; | |
560 | } | ||
561 | |||
562 |
2/2✓ Branch 0 taken 76 times.
✓ Branch 1 taken 3 times.
|
79 | if (implicit_rect) { |
563 | 76 | wmv9rects[0].x = 0; | |
564 | 76 | wmv9rects[0].y = 0; | |
565 | 76 | wmv9rects[0].w = avctx->width; | |
566 | 76 | wmv9rects[0].h = avctx->height; | |
567 | |||
568 | 76 | used_rects = 1; | |
569 | } | ||
570 |
2/2✓ Branch 0 taken 79 times.
✓ Branch 1 taken 79 times.
|
158 | for (i = 0; i < used_rects; i++) { |
571 |
3/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 76 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
|
79 | if (!implicit_rect && arith2_get_bit(&acoder)) { |
572 | ✗ | av_log(avctx, AV_LOG_ERROR, "Unexpected grandchildren\n"); | |
573 | ✗ | return AVERROR_INVALIDDATA; | |
574 | } | ||
575 |
1/2✓ Branch 0 taken 79 times.
✗ Branch 1 not taken.
|
79 | if (!i) { |
576 | 79 | wmv9_mask = arith2_get_bit(&acoder) - 1; | |
577 |
1/2✓ Branch 0 taken 79 times.
✗ Branch 1 not taken.
|
79 | if (!wmv9_mask) |
578 | 79 | wmv9_mask = arith2_get_number(&acoder, 256); | |
579 | } | ||
580 | 79 | wmv9rects[i].coded = arith2_get_number(&acoder, 2); | |
581 | } | ||
582 | |||
583 | 79 | buf += arith2_get_consumed_bytes(&acoder); | |
584 | 79 | buf_size -= arith2_get_consumed_bytes(&acoder); | |
585 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 79 times.
|
79 | if (buf_size < 1) |
586 | ✗ | return AVERROR_INVALIDDATA; | |
587 | } | ||
588 | |||
589 | 108 | c->mvX = c->mvY = 0; | |
590 |
4/4✓ Branch 0 taken 6 times.
✓ Branch 1 taken 102 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2 times.
|
108 | if (keyframe && !is_555) { |
591 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
|
4 | if ((i = decode_pal_v2(c, buf, buf_size)) < 0) |
592 | ✗ | return AVERROR_INVALIDDATA; | |
593 | 4 | buf += i; | |
594 | 4 | buf_size -= i; | |
595 |
2/2✓ Branch 0 taken 78 times.
✓ Branch 1 taken 26 times.
|
104 | } else if (has_mv) { |
596 | 78 | buf += 4; | |
597 | 78 | buf_size -= 4; | |
598 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 78 times.
|
78 | if (buf_size < 1) |
599 | ✗ | return AVERROR_INVALIDDATA; | |
600 | 78 | c->mvX = AV_RB16(buf - 4) - avctx->width; | |
601 | 78 | c->mvY = AV_RB16(buf - 2) - avctx->height; | |
602 | } | ||
603 | |||
604 |
4/4✓ Branch 0 taken 88 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 22 times.
✓ Branch 3 taken 66 times.
|
108 | if (c->mvX < 0 || c->mvY < 0) { |
605 | 42 | FFSWAP(uint8_t *, c->pal_pic, c->last_pal_pic); | |
606 | |||
607 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
|
42 | if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0) |
608 | ✗ | return ret; | |
609 | |||
610 |
1/2✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
|
42 | if (ctx->last_pic->data[0]) { |
611 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
|
42 | av_assert0(frame->linesize[0] == ctx->last_pic->linesize[0]); |
612 | 42 | c->last_rgb_pic = ctx->last_pic->data[0] + | |
613 | 42 | ctx->last_pic->linesize[0] * (avctx->height - 1); | |
614 | } else { | ||
615 | ✗ | av_log(avctx, AV_LOG_ERROR, "Missing keyframe\n"); | |
616 | ✗ | return AVERROR_INVALIDDATA; | |
617 | } | ||
618 | } else { | ||
619 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 66 times.
|
66 | if ((ret = ff_reget_buffer(avctx, ctx->last_pic, 0)) < 0) |
620 | ✗ | return ret; | |
621 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 66 times.
|
66 | if ((ret = av_frame_ref(frame, ctx->last_pic)) < 0) |
622 | ✗ | return ret; | |
623 | |||
624 | 66 | c->last_rgb_pic = NULL; | |
625 | } | ||
626 | 108 | c->rgb_pic = frame->data[0] + | |
627 | 108 | frame->linesize[0] * (avctx->height - 1); | |
628 | 108 | c->rgb_stride = -frame->linesize[0]; | |
629 | |||
630 | 108 | frame->key_frame = keyframe; | |
631 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 102 times.
|
108 | frame->pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P; |
632 | |||
633 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 104 times.
|
108 | if (is_555) { |
634 | 4 | bytestream2_init(&gB, buf, buf_size); | |
635 | |||
636 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
|
4 | if (decode_555(avctx, &gB, (uint16_t *)c->rgb_pic, c->rgb_stride >> 1, |
637 | keyframe, avctx->width, avctx->height)) | ||
638 | ✗ | return AVERROR_INVALIDDATA; | |
639 | |||
640 | 4 | buf_size -= bytestream2_tell(&gB); | |
641 | } else { | ||
642 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 100 times.
|
104 | if (keyframe) { |
643 | 4 | c->corrupted = 0; | |
644 | 4 | ff_mss12_slicecontext_reset(&ctx->sc[0]); | |
645 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
|
4 | if (c->slice_split) |
646 | 1 | ff_mss12_slicecontext_reset(&ctx->sc[1]); | |
647 | } | ||
648 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 100 times.
|
104 | if (is_rle) { |
649 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
|
4 | if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0) |
650 | ✗ | return ret; | |
651 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride, |
652 | 4 | c->rgb_pic, c->rgb_stride, c->pal, keyframe, | |
653 | ctx->split_position, 0, | ||
654 | avctx->width, avctx->height)) | ||
655 | ✗ | return ret; | |
656 | 4 | align_get_bits(&gb); | |
657 | |||
658 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
|
4 | if (c->slice_split) |
659 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride, |
660 | 2 | c->rgb_pic, c->rgb_stride, c->pal, keyframe, | |
661 | ctx->split_position, 1, | ||
662 | avctx->width, avctx->height)) | ||
663 | ✗ | return ret; | |
664 | |||
665 | 4 | align_get_bits(&gb); | |
666 | 4 | buf += get_bits_count(&gb) >> 3; | |
667 | 4 | buf_size -= get_bits_count(&gb) >> 3; | |
668 |
3/4✓ Branch 0 taken 76 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 76 times.
✗ Branch 3 not taken.
|
100 | } else if (!implicit_rect || wmv9_mask != -1) { |
669 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
|
100 | if (c->corrupted) |
670 | ✗ | return AVERROR_INVALIDDATA; | |
671 | 100 | bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING); | |
672 | 100 | arith2_init(&acoder, &gB); | |
673 | 100 | c->keyframe = keyframe; | |
674 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 100 times.
|
100 | if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[0], &acoder, 0, 0, |
675 | avctx->width, | ||
676 | ctx->split_position)) | ||
677 | ✗ | return AVERROR_INVALIDDATA; | |
678 | |||
679 | 100 | buf += arith2_get_consumed_bytes(&acoder); | |
680 | 100 | buf_size -= arith2_get_consumed_bytes(&acoder); | |
681 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
|
100 | if (c->slice_split) { |
682 | ✗ | if (buf_size < 1) | |
683 | ✗ | return AVERROR_INVALIDDATA; | |
684 | ✗ | bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING); | |
685 | ✗ | arith2_init(&acoder, &gB); | |
686 | ✗ | if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[1], &acoder, 0, | |
687 | ctx->split_position, | ||
688 | avctx->width, | ||
689 | ✗ | avctx->height - ctx->split_position)) | |
690 | ✗ | return AVERROR_INVALIDDATA; | |
691 | |||
692 | ✗ | buf += arith2_get_consumed_bytes(&acoder); | |
693 | ✗ | buf_size -= arith2_get_consumed_bytes(&acoder); | |
694 | } | ||
695 | } else | ||
696 | ✗ | memset(c->pal_pic, 0, c->pal_stride * avctx->height); | |
697 | } | ||
698 | |||
699 |
2/2✓ Branch 0 taken 79 times.
✓ Branch 1 taken 29 times.
|
108 | if (has_wmv9) { |
700 |
2/2✓ Branch 0 taken 79 times.
✓ Branch 1 taken 79 times.
|
158 | for (i = 0; i < used_rects; i++) { |
701 | 79 | int x = wmv9rects[i].x; | |
702 | 79 | int y = wmv9rects[i].y; | |
703 | 79 | int w = wmv9rects[i].w; | |
704 | 79 | int h = wmv9rects[i].h; | |
705 |
1/2✓ Branch 0 taken 79 times.
✗ Branch 1 not taken.
|
79 | if (wmv9rects[i].coded) { |
706 | int WMV9codedFrameSize; | ||
707 |
2/4✓ Branch 0 taken 79 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 79 times.
|
79 | if (buf_size < 4 || !(WMV9codedFrameSize = AV_RL24(buf))) |
708 | ✗ | return AVERROR_INVALIDDATA; | |
709 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 79 times.
|
79 | if (ret = decode_wmv9(avctx, buf + 3, buf_size - 3, |
710 | x, y, w, h, wmv9_mask)) | ||
711 | ✗ | return ret; | |
712 | 79 | buf += WMV9codedFrameSize + 3; | |
713 | 79 | buf_size -= WMV9codedFrameSize + 3; | |
714 | } else { | ||
715 | ✗ | uint8_t *dst = c->rgb_pic + y * c->rgb_stride + x * 3; | |
716 | ✗ | if (wmv9_mask != -1) { | |
717 | ✗ | ctx->dsp.mss2_gray_fill_masked(dst, c->rgb_stride, | |
718 | wmv9_mask, | ||
719 | ✗ | c->pal_pic + y * c->pal_stride + x, | |
720 | c->pal_stride, | ||
721 | w, h); | ||
722 | } else { | ||
723 | do { | ||
724 | ✗ | memset(dst, 0x80, w * 3); | |
725 | ✗ | dst += c->rgb_stride; | |
726 | ✗ | } while (--h); | |
727 | } | ||
728 | } | ||
729 | } | ||
730 | } | ||
731 | |||
732 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 108 times.
|
108 | if (buf_size) |
733 | ✗ | av_log(avctx, AV_LOG_WARNING, "buffer not fully consumed\n"); | |
734 | |||
735 |
4/4✓ Branch 0 taken 88 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 22 times.
✓ Branch 3 taken 66 times.
|
108 | if (c->mvX < 0 || c->mvY < 0) { |
736 | 42 | av_frame_unref(ctx->last_pic); | |
737 | 42 | ret = av_frame_ref(ctx->last_pic, frame); | |
738 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
|
42 | if (ret < 0) |
739 | ✗ | return ret; | |
740 | } | ||
741 | |||
742 | 108 | *got_frame = 1; | |
743 | |||
744 | 108 | return avpkt->size; | |
745 | } | ||
746 | |||
747 | 10 | static av_cold int wmv9_init(AVCodecContext *avctx) | |
748 | { | ||
749 | 10 | VC1Context *v = avctx->priv_data; | |
750 | int ret; | ||
751 | |||
752 | 10 | v->s.avctx = avctx; | |
753 | |||
754 | 10 | ff_vc1_init_common(v); | |
755 | |||
756 | 10 | v->profile = PROFILE_MAIN; | |
757 | |||
758 | 10 | v->zz_8x4 = ff_wmv2_scantableA; | |
759 | 10 | v->zz_4x8 = ff_wmv2_scantableB; | |
760 | 10 | v->res_y411 = 0; | |
761 | 10 | v->res_sprite = 0; | |
762 | |||
763 | 10 | v->frmrtq_postproc = 7; | |
764 | 10 | v->bitrtq_postproc = 31; | |
765 | |||
766 | 10 | v->res_x8 = 0; | |
767 | 10 | v->multires = 0; | |
768 | 10 | v->res_fasttx = 1; | |
769 | |||
770 | 10 | v->fastuvmc = 0; | |
771 | |||
772 | 10 | v->extended_mv = 0; | |
773 | |||
774 | 10 | v->dquant = 1; | |
775 | 10 | v->vstransform = 1; | |
776 | |||
777 | 10 | v->res_transtab = 0; | |
778 | |||
779 | 10 | v->overlap = 0; | |
780 | |||
781 | 10 | v->resync_marker = 0; | |
782 | 10 | v->rangered = 0; | |
783 | |||
784 | 10 | v->s.max_b_frames = avctx->max_b_frames = 0; | |
785 | 10 | v->quantizer_mode = 0; | |
786 | |||
787 | 10 | v->finterpflag = 0; | |
788 | |||
789 | 10 | v->res_rtm_flag = 1; | |
790 | |||
791 | 10 | ff_vc1_init_transposed_scantables(v); | |
792 | |||
793 |
2/4✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 10 times.
|
20 | if ((ret = ff_msmpeg4_decode_init(avctx)) < 0 || |
794 | 10 | (ret = ff_vc1_decode_init_alloc_tables(v)) < 0) | |
795 | ✗ | return ret; | |
796 | |||
797 | /* error concealment */ | ||
798 | 10 | v->s.me.qpel_put = v->s.qdsp.put_qpel_pixels_tab; | |
799 | 10 | v->s.me.qpel_avg = v->s.qdsp.avg_qpel_pixels_tab; | |
800 | |||
801 | 10 | return 0; | |
802 | } | ||
803 | |||
804 | 10 | static av_cold int mss2_decode_end(AVCodecContext *avctx) | |
805 | { | ||
806 | 10 | MSS2Context *const ctx = avctx->priv_data; | |
807 | |||
808 | 10 | av_frame_free(&ctx->last_pic); | |
809 | |||
810 | 10 | ff_mss12_decode_end(&ctx->c); | |
811 | 10 | av_freep(&ctx->c.pal_pic); | |
812 | 10 | av_freep(&ctx->c.last_pal_pic); | |
813 | 10 | ff_vc1_decode_end(avctx); | |
814 | |||
815 | 10 | return 0; | |
816 | } | ||
817 | |||
818 | 10 | static av_cold int mss2_decode_init(AVCodecContext *avctx) | |
819 | { | ||
820 | 10 | MSS2Context * const ctx = avctx->priv_data; | |
821 | 10 | MSS12Context *c = &ctx->c; | |
822 | int ret; | ||
823 | 10 | c->avctx = avctx; | |
824 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
|
10 | if (ret = ff_mss12_decode_init(c, 1, &ctx->sc[0], &ctx->sc[1])) |
825 | ✗ | return ret; | |
826 | 10 | ctx->last_pic = av_frame_alloc(); | |
827 | 10 | c->pal_stride = c->mask_stride; | |
828 | 10 | c->pal_pic = av_mallocz(c->pal_stride * avctx->height); | |
829 | 10 | c->last_pal_pic = av_mallocz(c->pal_stride * avctx->height); | |
830 |
3/6✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 10 times.
|
10 | if (!c->pal_pic || !c->last_pal_pic || !ctx->last_pic) { |
831 | ✗ | mss2_decode_end(avctx); | |
832 | ✗ | return AVERROR(ENOMEM); | |
833 | } | ||
834 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
|
10 | if (ret = wmv9_init(avctx)) { |
835 | ✗ | mss2_decode_end(avctx); | |
836 | ✗ | return ret; | |
837 | } | ||
838 | 10 | ff_mss2dsp_init(&ctx->dsp); | |
839 | |||
840 | 20 | avctx->pix_fmt = c->free_colours == 127 ? AV_PIX_FMT_RGB555 | |
841 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 6 times.
|
10 | : AV_PIX_FMT_RGB24; |
842 | |||
843 | |||
844 | 10 | return 0; | |
845 | } | ||
846 | |||
847 | const FFCodec ff_mss2_decoder = { | ||
848 | .p.name = "mss2", | ||
849 | .p.long_name = NULL_IF_CONFIG_SMALL("MS Windows Media Video V9 Screen"), | ||
850 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
851 | .p.id = AV_CODEC_ID_MSS2, | ||
852 | .priv_data_size = sizeof(MSS2Context), | ||
853 | .init = mss2_decode_init, | ||
854 | .close = mss2_decode_end, | ||
855 | FF_CODEC_DECODE_CB(mss2_decode_frame), | ||
856 | .p.capabilities = AV_CODEC_CAP_DR1, | ||
857 | .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, | ||
858 | }; | ||
859 |