4 * Copyright (c) 2020 Paul B Mahol
6 * This file is part of FFmpeg.
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.
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.
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
27 #include "libavutil/thread.h"
30 #include "bytestream.h"
31 #include "copy_block.h"
36 #include "aandcttab.h"
38 typedef struct MV30Context {
49 unsigned int mvectors_size;
51 unsigned int coeffs_size;
53 int16_t intraq_tab[2][64];
54 int16_t interq_tab[2][64];
62 static const uint8_t luma_tab[] = {
63 12, 12, 15, 19, 25, 34, 40, 48,
64 12, 12, 18, 22, 27, 44, 47, 46,
65 17, 18, 21, 26, 35, 46, 52, 47,
66 18, 20, 24, 28, 40, 61, 59, 51,
67 20, 24, 32, 43, 50, 72, 72, 63,
68 25, 31, 42, 48, 58, 72, 81, 75,
69 38, 46, 54, 61, 71, 84, 88, 85,
70 50, 61, 65, 68, 79, 78, 86, 91,
73 static const uint8_t chroma_tab[] = {
74 12, 16, 24, 47, 99, 99, 99, 99,
75 16, 21, 26, 66, 99, 99, 99, 99,
76 24, 26, 56, 99, 99, 99, 99, 99,
77 47, 66, 99, 99, 99, 99, 99, 99,
78 99, 99, 99, 99, 99, 99, 99, 99,
79 99, 99, 99, 99, 99, 99, 99, 99,
80 99, 99, 99, 99, 99, 99, 99, 99,
81 99, 99, 99, 99, 99, 99, 99, 99,
84 static const uint8_t zigzag[] = {
85 0, 1, 8, 9, 16, 2, 3, 10,
86 17, 24, 32, 25, 18, 11, 4, 5,
87 12, 19, 26, 33, 40, 48, 41, 34,
88 27, 20, 13, 6, 7, 14, 21, 28,
89 35, 42, 49, 56, 57, 50, 43, 36,
90 29, 22, 15, 23, 30, 37, 44, 51,
91 58, 59, 52, 45, 38, 31, 39, 46,
92 53, 60, 61, 54, 47, 55, 62, 63,
95 static void get_qtable(int16_t *table, int quant, const uint8_t *quant_tab)
97 int factor = quant < 50 ? 5000 / FFMAX(quant, 1) : 200 - FFMIN(quant, 100) * 2;
99 for (int i = 0; i < 64; i++) {
100 table[i] = av_clip((quant_tab[i] * factor + 0x32) / 100, 1, 0x7fff);
101 table[i] = ((int)ff_aanscales[i] * (int)table[i] + 0x800) >> 12;
105 static inline void idct_1d(int *blk, int step)
107 const int t0 = blk[0 * step] + blk[4 * step];
108 const int t1 = blk[0 * step] - blk[4 * step];
109 const int t2 = blk[2 * step] + blk[6 * step];
110 const int t3 = (((blk[2 * step] - blk[6 * step]) * 362) >> 8) - t2;
111 const int t4 = t0 + t2;
112 const int t5 = t0 - t2;
113 const int t6 = t1 + t3;
114 const int t7 = t1 - t3;
115 const int t8 = blk[5 * step] + blk[3 * step];
116 const int t9 = blk[5 * step] - blk[3 * step];
117 const int tA = blk[1 * step] + blk[7 * step];
118 const int tB = blk[1 * step] - blk[7 * step];
119 const int tC = t8 + tA;
120 const int tD = (tB + t9) * 473 >> 8;
121 const int tE = ((t9 * -669 >> 8) - tC) + tD;
122 const int tF = ((tA - t8) * 362 >> 8) - tE;
123 const int t10 = ((tB * 277 >> 8) - tD) + tF;
125 blk[0 * step] = t4 + tC;
126 blk[1 * step] = t6 + tE;
127 blk[2 * step] = t7 + tF;
128 blk[3 * step] = t5 - t10;
129 blk[4 * step] = t5 + t10;
130 blk[5 * step] = t7 - tF;
131 blk[6 * step] = t6 - tE;
132 blk[7 * step] = t4 - tC;
135 static void idct_put(uint8_t *dst, int stride, int *block)
137 for (int i = 0; i < 8; i++) {
138 if ((block[0x08 + i] |
144 block[0x38 + i]) == 0) {
145 block[0x08 + i] = block[i];
146 block[0x10 + i] = block[i];
147 block[0x18 + i] = block[i];
148 block[0x20 + i] = block[i];
149 block[0x28 + i] = block[i];
150 block[0x30 + i] = block[i];
151 block[0x38 + i] = block[i];
153 idct_1d(block + i, 8);
157 for (int i = 0; i < 8; i++) {
159 for (int j = 0; j < 8; j++)
160 dst[j] = av_clip_uint8((block[j] >> 5) + 128);
166 static void idct_add(uint8_t *dst, int stride,
167 const uint8_t *src, int in_linesize, int *block)
169 for (int i = 0; i < 8; i++) {
170 if ((block[0x08 + i] |
176 block[0x38 + i]) == 0) {
177 block[0x08 + i] = block[i];
178 block[0x10 + i] = block[i];
179 block[0x18 + i] = block[i];
180 block[0x20 + i] = block[i];
181 block[0x28 + i] = block[i];
182 block[0x30 + i] = block[i];
183 block[0x38 + i] = block[i];
185 idct_1d(block + i, 8);
189 for (int i = 0; i < 8; i++) {
191 for (int j = 0; j < 8; j++)
192 dst[j] = av_clip_uint8((block[j] >> 5) + src[j]);
199 static inline void idct2_1d(int *blk, int step)
201 const int t0 = blk[0 * step];
202 const int t1 = blk[1 * step];
203 const int t2 = t1 * 473 >> 8;
204 const int t3 = t2 - t1;
205 const int t4 = (t1 * 362 >> 8) - t3;
206 const int t5 = ((t1 * 277 >> 8) - t2) + t4;
208 blk[0 * step] = t1 + t0;
209 blk[1 * step] = t0 + t3;
210 blk[2 * step] = t4 + t0;
211 blk[3 * step] = t0 - t5;
212 blk[4 * step] = t5 + t0;
213 blk[5 * step] = t0 - t4;
214 blk[6 * step] = t0 - t3;
215 blk[7 * step] = t0 - t1;
218 static void idct2_put(uint8_t *dst, int stride, int *block)
220 for (int i = 0; i < 2; i++) {
221 if ((block[0x08 + i]) == 0) {
222 block[0x08 + i] = block[i];
223 block[0x10 + i] = block[i];
224 block[0x18 + i] = block[i];
225 block[0x20 + i] = block[i];
226 block[0x28 + i] = block[i];
227 block[0x30 + i] = block[i];
228 block[0x38 + i] = block[i];
230 idct2_1d(block + i, 8);
234 for (int i = 0; i < 8; i++) {
236 for (int j = 0; j < 8; j++)
237 dst[j] = av_clip_uint8((block[0] >> 5) + 128);
240 for (int j = 0; j < 8; j++)
241 dst[j] = av_clip_uint8((block[j] >> 5) + 128);
248 static void idct2_add(uint8_t *dst, int stride,
249 const uint8_t *src, int in_linesize,
252 for (int i = 0; i < 2; i++) {
253 if ((block[0x08 + i]) == 0) {
254 block[0x08 + i] = block[i];
255 block[0x10 + i] = block[i];
256 block[0x18 + i] = block[i];
257 block[0x20 + i] = block[i];
258 block[0x28 + i] = block[i];
259 block[0x30 + i] = block[i];
260 block[0x38 + i] = block[i];
262 idct2_1d(block + i, 8);
266 for (int i = 0; i < 8; i++) {
268 for (int j = 0; j < 8; j++)
269 dst[j] = av_clip_uint8((block[0] >> 5) + src[j]);
272 for (int j = 0; j < 8; j++)
273 dst[j] = av_clip_uint8((block[j] >> 5) + src[j]);
281 static void update_inter_block(uint8_t *dst, int stride,
282 const uint8_t *src, int in_linesize,
285 for (int i = 0; i < 8; i++) {
286 for (int j = 0; j < 8; j++)
287 dst[j] = av_clip_uint8(block + src[j]);
293 static int decode_intra_block(AVCodecContext *avctx, int mode,
294 GetByteContext *gbyte, int16_t *qtab,
295 int *block, int *pfill,
296 uint8_t *dst, int linesize)
298 MV30Context *s = avctx->priv_data;
303 s->bdsp.fill_block_tab[1](dst, 128, linesize, 8);
306 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
308 block[0] = ((pfill[0] * qtab[0]) >> 5) + 128;
309 s->bdsp.fill_block_tab[1](dst, block[0], linesize, 8);
312 memset(block, 0, sizeof(*block) * 64);
313 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
315 block[0] = pfill[0] * qtab[0];
316 block[1] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[1];
317 block[8] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[8];
318 block[9] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[9];
319 idct2_put(dst, linesize, block);
322 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
324 block[0] = pfill[0] * qtab[0];
325 for (int i = 1; i < 64; i++)
326 block[zigzag[i]] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[zigzag[i]];
327 idct_put(dst, linesize, block);
334 static int decode_inter_block(AVCodecContext *avctx, int mode,
335 GetByteContext *gbyte, int16_t *qtab,
336 int *block, int *pfill,
337 uint8_t *dst, int linesize,
338 const uint8_t *src, int in_linesize)
344 copy_block8(dst, src, linesize, in_linesize, 8);
347 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
349 block[0] = (pfill[0] * qtab[0]) >> 5;
350 update_inter_block(dst, linesize, src, in_linesize, block[0]);
353 memset(block, 0, sizeof(*block) * 64);
354 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
356 block[0] = pfill[0] * qtab[0];
357 block[1] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[1];
358 block[8] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[8];
359 block[9] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[9];
360 idct2_add(dst, linesize, src, in_linesize, block);
363 fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
365 block[0] = pfill[0] * qtab[0];
366 for (int i = 1; i < 64; i++)
367 block[zigzag[i]] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[zigzag[i]];
368 idct_add(dst, linesize, src, in_linesize, block);
375 static int decode_coeffs(GetBitContext *gb, int16_t *coeffs, int nb_codes)
377 memset(coeffs, 0, nb_codes * sizeof(*coeffs));
379 for (int i = 0; i < nb_codes;) {
380 int value = get_vlc2(gb, cbp_tab.table, cbp_tab.bits, 1);
383 return AVERROR_INVALIDDATA;
386 int x = get_bits(gb, value);
388 if (x < (1 << value) / 2) {
389 x = (1 << (value - 1)) + (x & ((1 << value) - 1 >> 1));
391 x = -(1 << (value - 1)) - (x & ((1 << value) - 1 >> 1));
395 int flag = get_bits1(gb);
397 i += get_bits(gb, 3 + flag * 3) + 1 + flag * 8;
404 static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
406 MV30Context *s = avctx->priv_data;
413 skip_bits_long(gb, s->mode_size * 8);
415 linesize[0] = frame->linesize[0];
416 linesize[1] = frame->linesize[0];
417 linesize[2] = frame->linesize[0];
418 linesize[3] = frame->linesize[0];
419 linesize[4] = frame->linesize[1];
420 linesize[5] = frame->linesize[2];
422 for (int y = 0; y < avctx->height; y += 16) {
423 GetByteContext gbyte;
424 int pfill[3][1] = { 0 };
425 int nb_codes = get_bits(gb, 16);
427 av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));
429 return AVERROR(ENOMEM);
430 ret = decode_coeffs(gb, s->coeffs, nb_codes);
434 bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));
436 for (int x = 0; x < avctx->width; x += 16) {
437 dst[0] = frame->data[0] + linesize[0] * y + x;
438 dst[1] = frame->data[0] + linesize[0] * y + x + 8;
439 dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;
440 dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;
441 dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);
442 dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);
444 for (int b = 0; b < 6; b++) {
445 int mode = get_bits_le(&mgb, 2);
447 ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],
449 pfill[(b >= 4) + (b >= 5)],
450 dst[b], linesize[b]);
460 static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
461 AVFrame *frame, AVFrame *prev)
463 MV30Context *s = avctx->priv_data;
467 const int mask_size = ((avctx->height >> 4) * (avctx->width >> 4) * 2 + 7) / 8;
468 uint8_t *dst[6], *src[6];
474 in_linesize[0] = prev->linesize[0];
475 in_linesize[1] = prev->linesize[0];
476 in_linesize[2] = prev->linesize[0];
477 in_linesize[3] = prev->linesize[0];
478 in_linesize[4] = prev->linesize[1];
479 in_linesize[5] = prev->linesize[2];
481 linesize[0] = frame->linesize[0];
482 linesize[1] = frame->linesize[0];
483 linesize[2] = frame->linesize[0];
484 linesize[3] = frame->linesize[0];
485 linesize[4] = frame->linesize[1];
486 linesize[5] = frame->linesize[2];
488 av_fast_padded_malloc(&s->mvectors, &s->mvectors_size, 2 * s->nb_mvectors * sizeof(*s->mvectors));
490 ret = AVERROR(ENOMEM);
495 skip_bits_long(gb, mask_size * 8);
497 skip_bits_long(gb, s->mode_size * 8);
499 ret = decode_coeffs(gb, s->mvectors, 2 * s->nb_mvectors);
503 bytestream2_init(&mv, (uint8_t *)s->mvectors, 2 * s->nb_mvectors * sizeof(*s->mvectors));
505 for (int y = 0; y < avctx->height; y += 16) {
506 GetByteContext gbyte;
507 int pfill[3][1] = { 0 };
508 int nb_codes = get_bits(gb, 16);
511 if (get_bits_left(gb) < 0) {
512 ret = AVERROR_INVALIDDATA;
516 av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));
518 ret = AVERROR(ENOMEM);
522 ret = decode_coeffs(gb, s->coeffs, nb_codes);
526 bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));
528 for (int x = 0; x < avctx->width; x += 16) {
532 flags = get_bits(&mask, 8);
534 dst[0] = frame->data[0] + linesize[0] * y + x;
535 dst[1] = frame->data[0] + linesize[0] * y + x + 8;
536 dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;
537 dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;
538 dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);
539 dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);
541 if ((flags >> (cnt)) & 1) {
542 int mv_x = sign_extend(bytestream2_get_ne16(&mv), 16);
543 int mv_y = sign_extend(bytestream2_get_ne16(&mv), 16);
548 if (px < 0 || px >= avctx->width ||
549 py < 0 || py >= avctx->height)
550 return AVERROR_INVALIDDATA;
552 src[0] = prev->data[0] + in_linesize[0] * py + px;
553 src[1] = prev->data[0] + in_linesize[0] * py + px + 8;
554 src[2] = prev->data[0] + in_linesize[0] * (py + 8) + px;
555 src[3] = prev->data[0] + in_linesize[0] * (py + 8) + px + 8;
556 src[4] = prev->data[1] + in_linesize[4] * (py >> 1) + (px >> 1);
557 src[5] = prev->data[2] + in_linesize[5] * (py >> 1) + (px >> 1);
559 if ((flags >> (cnt + 4)) & 1) {
560 for (int b = 0; b < 6; b++)
561 copy_block8(dst[b], src[b], linesize[b], in_linesize[b], 8);
563 for (int b = 0; b < 6; b++) {
564 int mode = get_bits_le(&mgb, 2);
566 ret = decode_inter_block(avctx, mode, &gbyte, s->interq_tab[b >= 4],
568 pfill[(b >= 4) + (b >= 5)],
570 src[b], in_linesize[b]);
576 for (int b = 0; b < 6; b++) {
577 int mode = get_bits_le(&mgb, 2);
579 ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],
581 pfill[(b >= 4) + (b >= 5)],
582 dst[b], linesize[b]);
596 static int decode_frame(AVCodecContext *avctx, void *data,
597 int *got_frame, AVPacket *avpkt)
599 MV30Context *s = avctx->priv_data;
600 GetBitContext *gb = &s->gb;
601 AVFrame *frame = data;
604 if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
607 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
610 s->intra_quant = get_bits(gb, 8);
611 s->inter_quant = s->intra_quant + get_sbits(gb, 8);
612 s->is_inter = get_bits_le(gb, 16);
613 s->mode_size = get_bits_le(gb, 16);
615 s->nb_mvectors = get_bits_le(gb, 16);
617 get_qtable(s->intraq_tab[0], s->intra_quant, luma_tab);
618 get_qtable(s->intraq_tab[1], s->intra_quant, chroma_tab);
620 frame->key_frame = s->is_inter == 0;
622 if (frame->key_frame) {
623 ret = decode_intra(avctx, gb, frame);
627 get_qtable(s->interq_tab[0], s->inter_quant, luma_tab);
628 get_qtable(s->interq_tab[1], s->inter_quant, chroma_tab);
630 if (!s->prev_frame->data[0]) {
631 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
632 return AVERROR_INVALIDDATA;
635 ret = decode_inter(avctx, gb, frame, s->prev_frame);
640 av_frame_unref(s->prev_frame);
641 if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
649 static const uint16_t cbp_codes[] = {
650 0, 1, 4, 5, 6, 0xE, 0x1E, 0x3E, 0x7E, 0xFE, 0x1FE, 0x1FF,
653 static const uint8_t cbp_bits[] = {
654 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9, 9,
657 static av_cold void init_static_data(void)
659 INIT_VLC_SPARSE_STATIC(&cbp_tab, 9, FF_ARRAY_ELEMS(cbp_bits),
660 cbp_bits, 1, 1, cbp_codes, 2, 2, NULL, 0, 0, 512);
663 static av_cold int decode_init(AVCodecContext *avctx)
665 MV30Context *s = avctx->priv_data;
666 static AVOnce init_static_once = AV_ONCE_INIT;
668 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
669 avctx->color_range = AVCOL_RANGE_JPEG;
671 ff_blockdsp_init(&s->bdsp, avctx);
673 s->prev_frame = av_frame_alloc();
675 return AVERROR(ENOMEM);
677 ff_thread_once(&init_static_once, init_static_data);
682 static void decode_flush(AVCodecContext *avctx)
684 MV30Context *s = avctx->priv_data;
686 av_frame_unref(s->prev_frame);
689 static av_cold int decode_close(AVCodecContext *avctx)
691 MV30Context *s = avctx->priv_data;
693 av_frame_free(&s->prev_frame);
694 av_freep(&s->coeffs);
696 av_freep(&s->mvectors);
697 s->mvectors_size = 0;
702 AVCodec ff_mv30_decoder = {
704 .long_name = NULL_IF_CONFIG_SMALL("MidiVid 3.0"),
705 .type = AVMEDIA_TYPE_VIDEO,
706 .id = AV_CODEC_ID_MV30,
707 .priv_data_size = sizeof(MV30Context),
709 .close = decode_close,
710 .decode = decode_frame,
711 .flush = decode_flush,
712 .capabilities = AV_CODEC_CAP_DR1,
713 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
714 FF_CODEC_CAP_INIT_CLEANUP,