FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/mv30.c
Date: 2021-09-22 05:58:22
Exec Total Coverage
Lines: 0 401 0.0%
Branches: 0 142 0.0%

Line Branch Exec Source
1 /*
2 * MidiVid MV30 decoder
3 *
4 * Copyright (c) 2020 Paul B Mahol
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "libavutil/thread.h"
28
29 #include "avcodec.h"
30 #include "bytestream.h"
31 #include "copy_block.h"
32 #include "mathops.h"
33 #include "blockdsp.h"
34 #include "get_bits.h"
35 #include "internal.h"
36 #include "aandcttab.h"
37
38 #define CBP_VLC_BITS 9
39
40 typedef struct MV30Context {
41 GetBitContext gb;
42
43 int intra_quant;
44 int inter_quant;
45 int is_inter;
46 int mode_size;
47 int nb_mvectors;
48
49 int block[6][64];
50 int16_t *mvectors;
51 unsigned int mvectors_size;
52 int16_t *coeffs;
53 unsigned int coeffs_size;
54
55 int16_t intraq_tab[2][64];
56 int16_t interq_tab[2][64];
57
58 BlockDSPContext bdsp;
59 AVFrame *prev_frame;
60 } MV30Context;
61
62 static VLC cbp_tab;
63
64 static const uint8_t luma_tab[] = {
65 12, 12, 15, 19, 25, 34, 40, 48,
66 12, 12, 18, 22, 27, 44, 47, 46,
67 17, 18, 21, 26, 35, 46, 52, 47,
68 18, 20, 24, 28, 40, 61, 59, 51,
69 20, 24, 32, 43, 50, 72, 72, 63,
70 25, 31, 42, 48, 58, 72, 81, 75,
71 38, 46, 54, 61, 71, 84, 88, 85,
72 50, 61, 65, 68, 79, 78, 86, 91,
73 };
74
75 static const uint8_t chroma_tab[] = {
76 12, 16, 24, 47, 99, 99, 99, 99,
77 16, 21, 26, 66, 99, 99, 99, 99,
78 24, 26, 56, 99, 99, 99, 99, 99,
79 47, 66, 99, 99, 99, 99, 99, 99,
80 99, 99, 99, 99, 99, 99, 99, 99,
81 99, 99, 99, 99, 99, 99, 99, 99,
82 99, 99, 99, 99, 99, 99, 99, 99,
83 99, 99, 99, 99, 99, 99, 99, 99,
84 };
85
86 static const uint8_t zigzag[] = {
87 0, 1, 8, 9, 16, 2, 3, 10,
88 17, 24, 32, 25, 18, 11, 4, 5,
89 12, 19, 26, 33, 40, 48, 41, 34,
90 27, 20, 13, 6, 7, 14, 21, 28,
91 35, 42, 49, 56, 57, 50, 43, 36,
92 29, 22, 15, 23, 30, 37, 44, 51,
93 58, 59, 52, 45, 38, 31, 39, 46,
94 53, 60, 61, 54, 47, 55, 62, 63,
95 };
96
97 static void get_qtable(int16_t *table, int quant, const uint8_t *quant_tab)
98 {
99 int factor = quant < 50 ? 5000 / FFMAX(quant, 1) : 200 - FFMIN(quant, 100) * 2;
100
101 for (int i = 0; i < 64; i++) {
102 table[i] = av_clip((quant_tab[i] * factor + 0x32) / 100, 1, 0x7fff);
103 table[i] = ((int)ff_aanscales[i] * (int)table[i] + 0x800) >> 12;
104 }
105 }
106
107 static inline void idct_1d(unsigned *blk, int step)
108 {
109 const unsigned t0 = blk[0 * step] + blk[4 * step];
110 const unsigned t1 = blk[0 * step] - blk[4 * step];
111 const unsigned t2 = blk[2 * step] + blk[6 * step];
112 const unsigned t3 = ((int)((blk[2 * step] - blk[6 * step]) * 362U) >> 8) - t2;
113 const unsigned t4 = t0 + t2;
114 const unsigned t5 = t0 - t2;
115 const unsigned t6 = t1 + t3;
116 const unsigned t7 = t1 - t3;
117 const unsigned t8 = blk[5 * step] + blk[3 * step];
118 const unsigned t9 = blk[5 * step] - blk[3 * step];
119 const unsigned tA = blk[1 * step] + blk[7 * step];
120 const unsigned tB = blk[1 * step] - blk[7 * step];
121 const unsigned tC = t8 + tA;
122 const unsigned tD = (int)((tB + t9) * 473U) >> 8;
123 const unsigned tE = (((int)(t9 * -669U) >> 8) - tC) + tD;
124 const unsigned tF = ((int)((tA - t8) * 362U) >> 8) - tE;
125 const unsigned t10 = (((int)(tB * 277U) >> 8) - tD) + tF;
126
127 blk[0 * step] = t4 + tC;
128 blk[1 * step] = t6 + tE;
129 blk[2 * step] = t7 + tF;
130 blk[3 * step] = t5 - t10;
131 blk[4 * step] = t5 + t10;
132 blk[5 * step] = t7 - tF;
133 blk[6 * step] = t6 - tE;
134 blk[7 * step] = t4 - tC;
135 }
136
137 static void idct_put(uint8_t *dst, int stride, int *block)
138 {
139 for (int i = 0; i < 8; i++) {
140 if ((block[0x08 + i] |
141 block[0x10 + i] |
142 block[0x18 + i] |
143 block[0x20 + i] |
144 block[0x28 + i] |
145 block[0x30 + i] |
146 block[0x38 + i]) == 0) {
147 block[0x08 + i] = block[i];
148 block[0x10 + i] = block[i];
149 block[0x18 + i] = block[i];
150 block[0x20 + i] = block[i];
151 block[0x28 + i] = block[i];
152 block[0x30 + i] = block[i];
153 block[0x38 + i] = block[i];
154 } else {
155 idct_1d(block + i, 8);
156 }
157 }
158
159 for (int i = 0; i < 8; i++) {
160 idct_1d(block, 1);
161 for (int j = 0; j < 8; j++)
162 dst[j] = av_clip_uint8((block[j] >> 5) + 128);
163 block += 8;
164 dst += stride;
165 }
166 }
167
168 static void idct_add(uint8_t *dst, int stride,
169 const uint8_t *src, int in_linesize, int *block)
170 {
171 for (int i = 0; i < 8; i++) {
172 if ((block[0x08 + i] |
173 block[0x10 + i] |
174 block[0x18 + i] |
175 block[0x20 + i] |
176 block[0x28 + i] |
177 block[0x30 + i] |
178 block[0x38 + i]) == 0) {
179 block[0x08 + i] = block[i];
180 block[0x10 + i] = block[i];
181 block[0x18 + i] = block[i];
182 block[0x20 + i] = block[i];
183 block[0x28 + i] = block[i];
184 block[0x30 + i] = block[i];
185 block[0x38 + i] = block[i];
186 } else {
187 idct_1d(block + i, 8);
188 }
189 }
190
191 for (int i = 0; i < 8; i++) {
192 idct_1d(block, 1);
193 for (int j = 0; j < 8; j++)
194 dst[j] = av_clip_uint8((block[j] >> 5) + src[j]);
195 block += 8;
196 dst += stride;
197 src += in_linesize;
198 }
199 }
200
201 static inline void idct2_1d(int *blk, int step)
202 {
203 const unsigned int t0 = blk[0 * step];
204 const unsigned int t1 = blk[1 * step];
205 const unsigned int t2 = (int)(t1 * 473U) >> 8;
206 const unsigned int t3 = t2 - t1;
207 const unsigned int t4 = ((int)(t1 * 362U) >> 8) - t3;
208 const unsigned int t5 = (((int)(t1 * 277U) >> 8) - t2) + t4;
209
210 blk[0 * step] = t1 + t0;
211 blk[1 * step] = t0 + t3;
212 blk[2 * step] = t4 + t0;
213 blk[3 * step] = t0 - t5;
214 blk[4 * step] = t5 + t0;
215 blk[5 * step] = t0 - t4;
216 blk[6 * step] = t0 - t3;
217 blk[7 * step] = t0 - t1;
218 }
219
220 static void idct2_put(uint8_t *dst, int stride, int *block)
221 {
222 for (int i = 0; i < 2; i++) {
223 if ((block[0x08 + i]) == 0) {
224 block[0x08 + i] = block[i];
225 block[0x10 + i] = block[i];
226 block[0x18 + i] = block[i];
227 block[0x20 + i] = block[i];
228 block[0x28 + i] = block[i];
229 block[0x30 + i] = block[i];
230 block[0x38 + i] = block[i];
231 } else {
232 idct2_1d(block + i, 8);
233 }
234 }
235
236 for (int i = 0; i < 8; i++) {
237 if (block[1] == 0) {
238 for (int j = 0; j < 8; j++)
239 dst[j] = av_clip_uint8((block[0] >> 5) + 128);
240 } else {
241 idct2_1d(block, 1);
242 for (int j = 0; j < 8; j++)
243 dst[j] = av_clip_uint8((block[j] >> 5) + 128);
244 }
245 block += 8;
246 dst += stride;
247 }
248 }
249
250 static void idct2_add(uint8_t *dst, int stride,
251 const uint8_t *src, int in_linesize,
252 int *block)
253 {
254 for (int i = 0; i < 2; i++) {
255 if ((block[0x08 + i]) == 0) {
256 block[0x08 + i] = block[i];
257 block[0x10 + i] = block[i];
258 block[0x18 + i] = block[i];
259 block[0x20 + i] = block[i];
260 block[0x28 + i] = block[i];
261 block[0x30 + i] = block[i];
262 block[0x38 + i] = block[i];
263 } else {
264 idct2_1d(block + i, 8);
265 }
266 }
267
268 for (int i = 0; i < 8; i++) {
269 if (block[1] == 0) {
270 for (int j = 0; j < 8; j++)
271 dst[j] = av_clip_uint8((block[0] >> 5) + src[j]);
272 } else {
273 idct2_1d(block, 1);
274 for (int j = 0; j < 8; j++)
275 dst[j] = av_clip_uint8((block[j] >> 5) + src[j]);
276 }
277 block += 8;
278 dst += stride;
279 src += in_linesize;
280 }
281 }
282
283 static void update_inter_block(uint8_t *dst, int stride,
284 const uint8_t *src, int in_linesize,
285 int block)
286 {
287 for (int i = 0; i < 8; i++) {
288 for (int j = 0; j < 8; j++)
289 dst[j] = av_clip_uint8(block + src[j]);
290 dst += stride;
291 src += in_linesize;
292 }
293 }
294
295 static int decode_intra_block(AVCodecContext *avctx, int mode,
296 GetByteContext *gbyte, int16_t *qtab,
297 int *block, int *pfill,
298 uint8_t *dst, int linesize)
299 {
300 MV30Context *s = avctx->priv_data;
301 int fill;
302
303 switch (mode) {
304 case 0:
305 s->bdsp.fill_block_tab[1](dst, 128, linesize, 8);
306 break;
307 case 1:
308 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
309 pfill[0] += fill;
310 block[0] = ((int)((unsigned)pfill[0] * qtab[0]) >> 5) + 128;
311 s->bdsp.fill_block_tab[1](dst, block[0], linesize, 8);
312 break;
313 case 2:
314 memset(block, 0, sizeof(*block) * 64);
315 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
316 pfill[0] += fill;
317 block[0] = (unsigned)pfill[0] * qtab[0];
318 block[1] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[1];
319 block[8] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[8];
320 block[9] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[9];
321 idct2_put(dst, linesize, block);
322 break;
323 case 3:
324 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
325 pfill[0] += fill;
326 block[0] = (unsigned)pfill[0] * qtab[0];
327 for (int i = 1; i < 64; i++)
328 block[zigzag[i]] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[zigzag[i]];
329 idct_put(dst, linesize, block);
330 break;
331 }
332
333 return 0;
334 }
335
336 static int decode_inter_block(AVCodecContext *avctx, int mode,
337 GetByteContext *gbyte, int16_t *qtab,
338 int *block, int *pfill,
339 uint8_t *dst, int linesize,
340 const uint8_t *src, int in_linesize)
341 {
342 int fill;
343
344 switch (mode) {
345 case 0:
346 copy_block8(dst, src, linesize, in_linesize, 8);
347 break;
348 case 1:
349 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
350 pfill[0] += fill;
351 block[0] = (int)((unsigned)pfill[0] * qtab[0]) >> 5;
352 update_inter_block(dst, linesize, src, in_linesize, block[0]);
353 break;
354 case 2:
355 memset(block, 0, sizeof(*block) * 64);
356 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
357 pfill[0] += fill;
358 block[0] = (unsigned)pfill[0] * qtab[0];
359 block[1] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[1];
360 block[8] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[8];
361 block[9] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[9];
362 idct2_add(dst, linesize, src, in_linesize, block);
363 break;
364 case 3:
365 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
366 pfill[0] += fill;
367 block[0] = (unsigned)pfill[0] * qtab[0];
368 for (int i = 1; i < 64; i++)
369 block[zigzag[i]] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[zigzag[i]];
370 idct_add(dst, linesize, src, in_linesize, block);
371 break;
372 }
373
374 return 0;
375 }
376
377 static int decode_coeffs(GetBitContext *gb, int16_t *coeffs, int nb_codes)
378 {
379 memset(coeffs, 0, nb_codes * sizeof(*coeffs));
380
381 for (int i = 0; i < nb_codes;) {
382 int value = get_vlc2(gb, cbp_tab.table, CBP_VLC_BITS, 1);
383
384 if (value > 0) {
385 int x = get_bits(gb, value);
386
387 if (x < (1 << value) / 2) {
388 x = (1 << (value - 1)) + (x & ((1 << value) - 1 >> 1));
389 } else {
390 x = -(1 << (value - 1)) - (x & ((1 << value) - 1 >> 1));
391 }
392 coeffs[i++] = x;
393 } else {
394 int flag = get_bits1(gb);
395
396 i += get_bits(gb, 3 + flag * 3) + 1 + flag * 8;
397 }
398 }
399
400 return 0;
401 }
402
403 static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
404 {
405 MV30Context *s = avctx->priv_data;
406 GetBitContext mgb;
407 uint8_t *dst[6];
408 int linesize[6];
409 int ret;
410
411 mgb = *gb;
412 if (get_bits_left(gb) < s->mode_size * 8)
413 return AVERROR_INVALIDDATA;
414
415 skip_bits_long(gb, s->mode_size * 8);
416
417 linesize[0] = frame->linesize[0];
418 linesize[1] = frame->linesize[0];
419 linesize[2] = frame->linesize[0];
420 linesize[3] = frame->linesize[0];
421 linesize[4] = frame->linesize[1];
422 linesize[5] = frame->linesize[2];
423
424 for (int y = 0; y < avctx->height; y += 16) {
425 GetByteContext gbyte;
426 int pfill[3][1] = { {0} };
427 int nb_codes = get_bits(gb, 16);
428
429 av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));
430 if (!s->coeffs)
431 return AVERROR(ENOMEM);
432 ret = decode_coeffs(gb, s->coeffs, nb_codes);
433 if (ret < 0)
434 return ret;
435
436 bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));
437
438 for (int x = 0; x < avctx->width; x += 16) {
439 dst[0] = frame->data[0] + linesize[0] * y + x;
440 dst[1] = frame->data[0] + linesize[0] * y + x + 8;
441 dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;
442 dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;
443 dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);
444 dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);
445
446 for (int b = 0; b < 6; b++) {
447 int mode = get_bits_le(&mgb, 2);
448
449 ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],
450 s->block[b],
451 pfill[(b >= 4) + (b >= 5)],
452 dst[b], linesize[b]);
453 if (ret < 0)
454 return ret;
455 }
456 }
457 }
458
459 return 0;
460 }
461
462 static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
463 AVFrame *frame, AVFrame *prev)
464 {
465 MV30Context *s = avctx->priv_data;
466 GetBitContext mask;
467 GetBitContext mgb;
468 GetByteContext mv;
469 const int mask_size = ((avctx->height >> 4) * (avctx->width >> 4) * 2 + 7) / 8;
470 uint8_t *dst[6], *src[6];
471 int in_linesize[6];
472 int linesize[6];
473 int ret, cnt = 0;
474 int flags = 0;
475
476 in_linesize[0] = prev->linesize[0];
477 in_linesize[1] = prev->linesize[0];
478 in_linesize[2] = prev->linesize[0];
479 in_linesize[3] = prev->linesize[0];
480 in_linesize[4] = prev->linesize[1];
481 in_linesize[5] = prev->linesize[2];
482
483 linesize[0] = frame->linesize[0];
484 linesize[1] = frame->linesize[0];
485 linesize[2] = frame->linesize[0];
486 linesize[3] = frame->linesize[0];
487 linesize[4] = frame->linesize[1];
488 linesize[5] = frame->linesize[2];
489
490 av_fast_padded_malloc(&s->mvectors, &s->mvectors_size, 2 * s->nb_mvectors * sizeof(*s->mvectors));
491 if (!s->mvectors) {
492 ret = AVERROR(ENOMEM);
493 goto fail;
494 }
495
496 mask = *gb;
497 skip_bits_long(gb, mask_size * 8);
498 mgb = *gb;
499 skip_bits_long(gb, s->mode_size * 8);
500
501 ret = decode_coeffs(gb, s->mvectors, 2 * s->nb_mvectors);
502 if (ret < 0)
503 goto fail;
504
505 bytestream2_init(&mv, (uint8_t *)s->mvectors, 2 * s->nb_mvectors * sizeof(*s->mvectors));
506
507 for (int y = 0; y < avctx->height; y += 16) {
508 GetByteContext gbyte;
509 int pfill[3][1] = { {0} };
510 int nb_codes = get_bits(gb, 16);
511
512 skip_bits(gb, 8);
513 if (get_bits_left(gb) < 0) {
514 ret = AVERROR_INVALIDDATA;
515 goto fail;
516 }
517
518 av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));
519 if (!s->coeffs) {
520 ret = AVERROR(ENOMEM);
521 goto fail;
522 }
523
524 ret = decode_coeffs(gb, s->coeffs, nb_codes);
525 if (ret < 0)
526 goto fail;
527
528 bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));
529
530 for (int x = 0; x < avctx->width; x += 16) {
531 if (cnt >= 4)
532 cnt = 0;
533 if (cnt == 0) {
534 if (get_bits_left(&mask) < 8) {
535 ret = AVERROR_INVALIDDATA;
536 goto fail;
537 }
538 flags = get_bits(&mask, 8);
539 }
540
541 dst[0] = frame->data[0] + linesize[0] * y + x;
542 dst[1] = frame->data[0] + linesize[0] * y + x + 8;
543 dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;
544 dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;
545 dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);
546 dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);
547
548 if ((flags >> (cnt)) & 1) {
549 int mv_x = sign_extend(bytestream2_get_ne16(&mv), 16);
550 int mv_y = sign_extend(bytestream2_get_ne16(&mv), 16);
551
552 int px = x + mv_x;
553 int py = y + mv_y;
554
555 if (px < 0 || px > FFALIGN(avctx->width , 16) - 16 ||
556 py < 0 || py > FFALIGN(avctx->height, 16) - 16)
557 return AVERROR_INVALIDDATA;
558
559 src[0] = prev->data[0] + in_linesize[0] * py + px;
560 src[1] = prev->data[0] + in_linesize[0] * py + px + 8;
561 src[2] = prev->data[0] + in_linesize[0] * (py + 8) + px;
562 src[3] = prev->data[0] + in_linesize[0] * (py + 8) + px + 8;
563 src[4] = prev->data[1] + in_linesize[4] * (py >> 1) + (px >> 1);
564 src[5] = prev->data[2] + in_linesize[5] * (py >> 1) + (px >> 1);
565
566 if ((flags >> (cnt + 4)) & 1) {
567 for (int b = 0; b < 6; b++)
568 copy_block8(dst[b], src[b], linesize[b], in_linesize[b], 8);
569 } else {
570 for (int b = 0; b < 6; b++) {
571 int mode = get_bits_le(&mgb, 2);
572
573 ret = decode_inter_block(avctx, mode, &gbyte, s->interq_tab[b >= 4],
574 s->block[b],
575 pfill[(b >= 4) + (b >= 5)],
576 dst[b], linesize[b],
577 src[b], in_linesize[b]);
578 if (ret < 0)
579 goto fail;
580 }
581 }
582 } else {
583 for (int b = 0; b < 6; b++) {
584 int mode = get_bits_le(&mgb, 2);
585
586 ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],
587 s->block[b],
588 pfill[(b >= 4) + (b >= 5)],
589 dst[b], linesize[b]);
590 if (ret < 0)
591 goto fail;
592 }
593 }
594
595 cnt++;
596 }
597 }
598
599 fail:
600 return ret;
601 }
602
603 static int decode_frame(AVCodecContext *avctx, void *data,
604 int *got_frame, AVPacket *avpkt)
605 {
606 MV30Context *s = avctx->priv_data;
607 GetBitContext *gb = &s->gb;
608 AVFrame *frame = data;
609 int ret;
610
611 if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
612 return ret;
613
614 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
615 return ret;
616
617 s->intra_quant = get_bits(gb, 8);
618 s->inter_quant = s->intra_quant + get_sbits(gb, 8);
619 s->is_inter = get_bits_le(gb, 16);
620 s->mode_size = get_bits_le(gb, 16);
621 if (s->is_inter)
622 s->nb_mvectors = get_bits_le(gb, 16);
623
624 get_qtable(s->intraq_tab[0], s->intra_quant, luma_tab);
625 get_qtable(s->intraq_tab[1], s->intra_quant, chroma_tab);
626
627 frame->key_frame = s->is_inter == 0;
628
629 if (frame->key_frame) {
630 ret = decode_intra(avctx, gb, frame);
631 if (ret < 0)
632 return ret;
633 } else {
634 get_qtable(s->interq_tab[0], s->inter_quant, luma_tab);
635 get_qtable(s->interq_tab[1], s->inter_quant, chroma_tab);
636
637 if (!s->prev_frame->data[0]) {
638 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
639 return AVERROR_INVALIDDATA;
640 }
641
642 ret = decode_inter(avctx, gb, frame, s->prev_frame);
643 if (ret < 0)
644 return ret;
645 }
646
647 av_frame_unref(s->prev_frame);
648 if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
649 return ret;
650
651 *got_frame = 1;
652
653 return avpkt->size;
654 }
655
656 static const uint8_t cbp_bits[] = {
657 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9, 9,
658 };
659
660 static av_cold void init_static_data(void)
661 {
662 INIT_VLC_STATIC_FROM_LENGTHS(&cbp_tab, CBP_VLC_BITS, FF_ARRAY_ELEMS(cbp_bits),
663 cbp_bits, 1, NULL, 0, 0, 0, 0, 1 << CBP_VLC_BITS);
664 }
665
666 static av_cold int decode_init(AVCodecContext *avctx)
667 {
668 MV30Context *s = avctx->priv_data;
669 static AVOnce init_static_once = AV_ONCE_INIT;
670
671 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
672 avctx->color_range = AVCOL_RANGE_JPEG;
673
674 ff_blockdsp_init(&s->bdsp, avctx);
675
676 s->prev_frame = av_frame_alloc();
677 if (!s->prev_frame)
678 return AVERROR(ENOMEM);
679
680 ff_thread_once(&init_static_once, init_static_data);
681
682 return 0;
683 }
684
685 static void decode_flush(AVCodecContext *avctx)
686 {
687 MV30Context *s = avctx->priv_data;
688
689 av_frame_unref(s->prev_frame);
690 }
691
692 static av_cold int decode_close(AVCodecContext *avctx)
693 {
694 MV30Context *s = avctx->priv_data;
695
696 av_frame_free(&s->prev_frame);
697 av_freep(&s->coeffs);
698 s->coeffs_size = 0;
699 av_freep(&s->mvectors);
700 s->mvectors_size = 0;
701
702 return 0;
703 }
704
705 const AVCodec ff_mv30_decoder = {
706 .name = "mv30",
707 .long_name = NULL_IF_CONFIG_SMALL("MidiVid 3.0"),
708 .type = AVMEDIA_TYPE_VIDEO,
709 .id = AV_CODEC_ID_MV30,
710 .priv_data_size = sizeof(MV30Context),
711 .init = decode_init,
712 .close = decode_close,
713 .decode = decode_frame,
714 .flush = decode_flush,
715 .capabilities = AV_CODEC_CAP_DR1,
716 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
717 FF_CODEC_CAP_INIT_CLEANUP,
718 };
719