| @@ -0,0 +1,749 @@ |
| | 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 | |
| | 37 | typedef struct MV30Context { |
| | 38 | GetBitContext gb; |
| | 39 | |
| | 40 | int intra_quant; |
| | 41 | int inter_quant; |
| | 42 | int is_inter; |
| | 43 | int mode_size; |
| | 44 | int nb_mvectors; |
| | 45 | |
| | 46 | int block[6][64]; |
| | 47 | int16_t *mvectors; |
| | 48 | unsigned int mvectors_size; |
| | 49 | int16_t *coeffs; |
| | 50 | unsigned int coeffs_size; |
| | 51 | |
| | 52 | int16_t intraq_tab[2][64]; |
| | 53 | int16_t interq_tab[2][64]; |
| | 54 | |
| | 55 | BlockDSPContext bdsp; |
| | 56 | AVFrame *prev_frame; |
| | 57 | } MV30Context; |
| | 58 | |
| | 59 | static VLC cbp_tab; |
| | 60 | |
| | 61 | static const int16_t scale_tab[] = { |
| | 62 | 16384, 22725, 21407, 19266, |
| | 63 | 16384, 12873, 8867, 4520, |
| | 64 | 22725, 31521, 29692, 26722, |
| | 65 | 22725, 17855, 12299, 6270, |
| | 66 | 21407, 29692, 27969, 25172, |
| | 67 | 21407, 16819, 11585, 5906, |
| | 68 | 19266, 26722, 25172, 22654, |
| | 69 | 19266, 15137, 10426, 5315, |
| | 70 | 16384, 22725, 21407, 19266, |
| | 71 | 16384, 12873, 8867, 4520, |
| | 72 | 12873, 17855, 16819, 15137, |
| | 73 | 12873, 10114, 6967, 3552, |
| | 74 | 8867, 12299, 11585, 10426, |
| | 75 | 8867, 6967, 4799, 2446, |
| | 76 | 4520, 6270, 5906, 5315, |
| | 77 | 4520, 3552, 2446, 1247, |
| | 78 | }; |
| | 79 | |
| | 80 | static const uint8_t luma_tab[] = { |
| | 81 | 12, 12, 15, 19, 25, 34, 40, 48, |
| | 82 | 12, 12, 18, 22, 27, 44, 47, 46, |
| | 83 | 17, 18, 21, 26, 35, 46, 52, 47, |
| | 84 | 18, 20, 24, 28, 40, 61, 59, 51, |
| | 85 | 20, 24, 32, 43, 50, 72, 72, 63, |
| | 86 | 25, 31, 42, 48, 58, 72, 81, 75, |
| | 87 | 38, 46, 54, 61, 71, 84, 88, 85, |
| | 88 | 50, 61, 65, 68, 79, 78, 86, 91, |
| | 89 | 12, 12, 16, 18, 20, 30, 40, 45, |
| | 90 | 12, 12, 16, 18, 30, 40, 45, 50, |
| | 91 | 16, 16, 20, 30, 40, 45, 50, 55, |
| | 92 | 18, 18, 35, 40, 45, 50, 55, 60, |
| | 93 | 20, 30, 40, 45, 50, 55, 60, 65, |
| | 94 | 30, 40, 45, 50, 55, 60, 65, 70, |
| | 95 | 40, 45, 50, 55, 60, 65, 70, 75, |
| | 96 | 45, 50, 55, 60, 65, 70, 75, 80, |
| | 97 | }; |
| | 98 | |
| | 99 | static const uint8_t chroma_tab[] = { |
| | 100 | 12, 16, 24, 47, 99, 99, 99, 99, |
| | 101 | 16, 21, 26, 66, 99, 99, 99, 99, |
| | 102 | 24, 26, 56, 99, 99, 99, 99, 99, |
| | 103 | 47, 66, 99, 99, 99, 99, 99, 99, |
| | 104 | 99, 99, 99, 99, 99, 99, 99, 99, |
| | 105 | 99, 99, 99, 99, 99, 99, 99, 99, |
| | 106 | 99, 99, 99, 99, 99, 99, 99, 99, |
| | 107 | 99, 99, 99, 99, 99, 99, 99, 99, |
| | 108 | 12, 16, 20, 24, 28, 36, 40, 44, |
| | 109 | 16, 20, 24, 28, 36, 40, 44, 50, |
| | 110 | 20, 24, 28, 36, 40, 44, 50, 60, |
| | 111 | 24, 28, 36, 40, 44, 50, 60, 80, |
| | 112 | 28, 36, 40, 44, 50, 60, 80, 99, |
| | 113 | 36, 40, 44, 50, 60, 80, 99, 99, |
| | 114 | 40, 44, 50, 60, 80, 99, 99, 99, |
| | 115 | 44, 50, 60, 80, 99, 99, 99, 99, |
| | 116 | }; |
| | 117 | |
| | 118 | static const uint8_t zigzag[] = { |
| | 119 | 0, 1, 8, 9, 16, 2, 3, 10, |
| | 120 | 17, 24, 32, 25, 18, 11, 4, 5, |
| | 121 | 12, 19, 26, 33, 40, 48, 41, 34, |
| | 122 | 27, 20, 13, 6, 7, 14, 21, 28, |
| | 123 | 35, 42, 49, 56, 57, 50, 43, 36, |
| | 124 | 29, 22, 15, 23, 30, 37, 44, 51, |
| | 125 | 58, 59, 52, 45, 38, 31, 39, 46, |
| | 126 | 53, 60, 61, 54, 47, 55, 62, 63, |
| | 127 | }; |
| | 128 | |
| | 129 | static void get_qtable(int16_t *table, int quant, const uint8_t *quant_tab) |
| | 130 | { |
| | 131 | int factor = quant < 50 ? 5000 / FFMAX(quant, 1) : 200 - FFMIN(quant, 100) * 2; |
| | 132 | |
| | 133 | for (int i = 0; i < 64; i++) { |
| | 134 | table[i] = av_clip((quant_tab[i] * factor + 0x32) / 100, 1, 0x7fff); |
| | 135 | table[i] = ((int)scale_tab[i] * (int)table[i] + 0x800) >> 12; |
| | 136 | } |
| | 137 | } |
| | 138 | |
| | 139 | static inline void idct_1d(int *blk, int step) |
| | 140 | { |
| | 141 | const int t0 = blk[0 * step] + blk[4 * step]; |
| | 142 | const int t1 = blk[0 * step] - blk[4 * step]; |
| | 143 | const int t2 = blk[2 * step] + blk[6 * step]; |
| | 144 | const int t3 = (((blk[2 * step] - blk[6 * step]) * 362) >> 8) - t2; |
| | 145 | const int t4 = t0 + t2; |
| | 146 | const int t5 = t0 - t2; |
| | 147 | const int t6 = t1 + t3; |
| | 148 | const int t7 = t1 - t3; |
| | 149 | const int t8 = blk[5 * step] + blk[3 * step]; |
| | 150 | const int t9 = blk[5 * step] - blk[3 * step]; |
| | 151 | const int tA = blk[1 * step] + blk[7 * step]; |
| | 152 | const int tB = blk[1 * step] - blk[7 * step]; |
| | 153 | const int tC = t8 + tA; |
| | 154 | const int tD = (tB + t9) * 473 >> 8; |
| | 155 | const int tE = ((t9 * -669 >> 8) - tC) + tD; |
| | 156 | const int tF = ((tA - t8) * 362 >> 8) - tE; |
| | 157 | const int t10 = ((tB * 277 >> 8) - tD) + tF; |
| | 158 | |
| | 159 | blk[0 * step] = t4 + tC; |
| | 160 | blk[1 * step] = t6 + tE; |
| | 161 | blk[2 * step] = t7 + tF; |
| | 162 | blk[3 * step] = t5 - t10; |
| | 163 | blk[4 * step] = t5 + t10; |
| | 164 | blk[5 * step] = t7 - tF; |
| | 165 | blk[6 * step] = t6 - tE; |
| | 166 | blk[7 * step] = t4 - tC; |
| | 167 | } |
| | 168 | |
| | 169 | static void idct_put(uint8_t *dst, int stride, 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) + 128); |
| | 195 | block += 8; |
| | 196 | dst += stride; |
| | 197 | } |
| | 198 | } |
| | 199 | |
| | 200 | static void idct_add(uint8_t *dst, int stride, |
| | 201 | const uint8_t *src, int in_linesize, int *block) |
| | 202 | { |
| | 203 | for (int i = 0; i < 8; i++) { |
| | 204 | if ((block[0x08 + i] | |
| | 205 | block[0x10 + i] | |
| | 206 | block[0x18 + i] | |
| | 207 | block[0x20 + i] | |
| | 208 | block[0x28 + i] | |
| | 209 | block[0x30 + i] | |
| | 210 | block[0x38 + i]) == 0) { |
| | 211 | block[0x08 + i] = block[i]; |
| | 212 | block[0x10 + i] = block[i]; |
| | 213 | block[0x18 + i] = block[i]; |
| | 214 | block[0x20 + i] = block[i]; |
| | 215 | block[0x28 + i] = block[i]; |
| | 216 | block[0x30 + i] = block[i]; |
| | 217 | block[0x38 + i] = block[i]; |
| | 218 | } else { |
| | 219 | idct_1d(block + i, 8); |
| | 220 | } |
| | 221 | } |
| | 222 | |
| | 223 | for (int i = 0; i < 8; i++) { |
| | 224 | idct_1d(block, 1); |
| | 225 | for (int j = 0; j < 8; j++) |
| | 226 | dst[j] = av_clip_uint8((block[j] >> 5) + src[j]); |
| | 227 | block += 8; |
| | 228 | dst += stride; |
| | 229 | src += in_linesize; |
| | 230 | } |
| | 231 | } |
| | 232 | |
| | 233 | static inline void idct2_1d(int *blk, int step) |
| | 234 | { |
| | 235 | const int t0 = blk[0 * step]; |
| | 236 | const int t1 = blk[1 * step]; |
| | 237 | const int t2 = t1 * 473 >> 8; |
| | 238 | const int t3 = t2 - t1; |
| | 239 | const int t4 = (t1 * 362 >> 8) - t3; |
| | 240 | const int t5 = ((t1 * 277 >> 8) - t2) + t4; |
| | 241 | |
| | 242 | blk[0 * step] = t1 + t0; |
| | 243 | blk[1 * step] = t0 + t3; |
| | 244 | blk[2 * step] = t4 + t0; |
| | 245 | blk[3 * step] = t0 - t5; |
| | 246 | blk[4 * step] = t5 + t0; |
| | 247 | blk[5 * step] = t0 - t4; |
| | 248 | blk[6 * step] = t0 - t3; |
| | 249 | blk[7 * step] = t0 - t1; |
| | 250 | } |
| | 251 | |
| | 252 | static void idct2_put(uint8_t *dst, int stride, 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) + 128); |
| | 272 | } else { |
| | 273 | idct2_1d(block, 1); |
| | 274 | for (int j = 0; j < 8; j++) |
| | 275 | dst[j] = av_clip_uint8((block[j] >> 5) + 128); |
| | 276 | } |
| | 277 | block += 8; |
| | 278 | dst += stride; |
| | 279 | } |
| | 280 | } |
| | 281 | |
| | 282 | static void idct2_add(uint8_t *dst, int stride, |
| | 283 | const uint8_t *src, int in_linesize, |
| | 284 | int *block) |
| | 285 | { |
| | 286 | for (int i = 0; i < 2; i++) { |
| | 287 | if ((block[0x08 + i]) == 0) { |
| | 288 | block[0x08 + i] = block[i]; |
| | 289 | block[0x10 + i] = block[i]; |
| | 290 | block[0x18 + i] = block[i]; |
| | 291 | block[0x20 + i] = block[i]; |
| | 292 | block[0x28 + i] = block[i]; |
| | 293 | block[0x30 + i] = block[i]; |
| | 294 | block[0x38 + i] = block[i]; |
| | 295 | } else { |
| | 296 | idct2_1d(block + i, 8); |
| | 297 | } |
| | 298 | } |
| | 299 | |
| | 300 | for (int i = 0; i < 8; i++) { |
| | 301 | if (block[1] == 0) { |
| | 302 | for (int j = 0; j < 8; j++) |
| | 303 | dst[j] = av_clip_uint8((block[0] >> 5) + src[j]); |
| | 304 | } else { |
| | 305 | idct2_1d(block, 1); |
| | 306 | for (int j = 0; j < 8; j++) |
| | 307 | dst[j] = av_clip_uint8((block[j] >> 5) + src[j]); |
| | 308 | } |
| | 309 | block += 8; |
| | 310 | dst += stride; |
| | 311 | src += in_linesize; |
| | 312 | } |
| | 313 | } |
| | 314 | |
| | 315 | static void update_inter_block(uint8_t *dst, int stride, |
| | 316 | const uint8_t *src, int in_linesize, |
| | 317 | int block) |
| | 318 | { |
| | 319 | for (int i = 0; i < 8; i++) { |
| | 320 | for (int j = 0; j < 8; j++) |
| | 321 | dst[j] = av_clip_uint8(block + src[j]); |
| | 322 | dst += stride; |
| | 323 | src += in_linesize; |
| | 324 | } |
| | 325 | } |
| | 326 | |
| | 327 | static int decode_intra_block(AVCodecContext *avctx, int mode, |
| | 328 | GetByteContext *gbyte, int16_t *qtab, |
| | 329 | int *block, int *pfill, |
| | 330 | uint8_t *dst, int linesize) |
| | 331 | { |
| | 332 | MV30Context *s = avctx->priv_data; |
| | 333 | int fill; |
| | 334 | |
| | 335 | switch (mode) { |
| | 336 | case 0: |
| | 337 | s->bdsp.fill_block_tab[1](dst, 128, linesize, 8); |
| | 338 | break; |
| | 339 | case 1: |
| | 340 | fill = sign_extend(bytestream2_get_ne16(gbyte), 16); |
| | 341 | pfill[0] += fill; |
| | 342 | block[0] = ((pfill[0] * qtab[0]) >> 5) + 128; |
| | 343 | s->bdsp.fill_block_tab[1](dst, block[0], linesize, 8); |
| | 344 | break; |
| | 345 | case 2: |
| | 346 | memset(block, 0, sizeof(*block) * 64); |
| | 347 | fill = sign_extend(bytestream2_get_ne16(gbyte), 16); |
| | 348 | pfill[0] += fill; |
| | 349 | block[0] = pfill[0] * qtab[0]; |
| | 350 | block[1] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[1]; |
| | 351 | block[8] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[8]; |
| | 352 | block[9] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[9]; |
| | 353 | idct2_put(dst, linesize, block); |
| | 354 | break; |
| | 355 | case 3: |
| | 356 | fill = sign_extend(bytestream2_get_ne16(gbyte), 16); |
| | 357 | pfill[0] += fill; |
| | 358 | block[0] = pfill[0] * qtab[0]; |
| | 359 | for (int i = 1; i < 64; i++) |
| | 360 | block[zigzag[i]] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[zigzag[i]]; |
| | 361 | idct_put(dst, linesize, block); |
| | 362 | break; |
| | 363 | } |
| | 364 | |
| | 365 | return 0; |
| | 366 | } |
| | 367 | |
| | 368 | static int decode_inter_block(AVCodecContext *avctx, int mode, |
| | 369 | GetByteContext *gbyte, int16_t *qtab, |
| | 370 | int *block, int *pfill, |
| | 371 | uint8_t *dst, int linesize, |
| | 372 | const uint8_t *src, int in_linesize) |
| | 373 | { |
| | 374 | int fill; |
| | 375 | |
| | 376 | switch (mode) { |
| | 377 | case 0: |
| | 378 | copy_block8(dst, src, linesize, in_linesize, 8); |
| | 379 | break; |
| | 380 | case 1: |
| | 381 | fill = sign_extend(bytestream2_get_ne16(gbyte), 16); |
| | 382 | pfill[0] += fill; |
| | 383 | block[0] = (pfill[0] * qtab[0]) >> 5; |
| | 384 | update_inter_block(dst, linesize, src, in_linesize, block[0]); |
| | 385 | break; |
| | 386 | case 2: |
| | 387 | memset(block, 0, sizeof(*block) * 64); |
| | 388 | fill = sign_extend(bytestream2_get_ne16(gbyte), 16); |
| | 389 | pfill[0] += fill; |
| | 390 | block[0] = pfill[0] * qtab[0]; |
| | 391 | block[1] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[1]; |
| | 392 | block[8] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[8]; |
| | 393 | block[9] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[9]; |
| | 394 | idct2_add(dst, linesize, src, in_linesize, block); |
| | 395 | break; |
| | 396 | case 3: |
| | 397 | fill = sign_extend(bytestream2_get_ne16(gbyte), 16); |
| | 398 | pfill[0] += fill; |
| | 399 | block[0] = pfill[0] * qtab[0]; |
| | 400 | for (int i = 1; i < 64; i++) |
| | 401 | block[zigzag[i]] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[zigzag[i]]; |
| | 402 | idct_add(dst, linesize, src, in_linesize, block); |
| | 403 | break; |
| | 404 | } |
| | 405 | |
| | 406 | return 0; |
| | 407 | } |
| | 408 | |
| | 409 | static int decode_coeffs(GetBitContext *gb, int16_t *coeffs, int nb_codes) |
| | 410 | { |
| | 411 | memset(coeffs, 0, nb_codes * sizeof(*coeffs)); |
| | 412 | |
| | 413 | for (int i = 0; i < nb_codes;) { |
| | 414 | int value = get_vlc2(gb, cbp_tab.table, cbp_tab.bits, 1); |
| | 415 | |
| | 416 | if (value < 0) |
| | 417 | return AVERROR_INVALIDDATA; |
| | 418 | |
| | 419 | if (value > 0) { |
| | 420 | int x = get_bits(gb, value); |
| | 421 | |
| | 422 | if (x < (1 << value) / 2) { |
| | 423 | x = (1 << (value - 1)) + (x & ((1 << value) - 1 >> 1)); |
| | 424 | } else { |
| | 425 | x = -(1 << (value - 1)) - (x & ((1 << value) - 1 >> 1)); |
| | 426 | } |
| | 427 | coeffs[i++] = x; |
| | 428 | } else { |
| | 429 | int flag = get_bits1(gb); |
| | 430 | |
| | 431 | i += get_bits(gb, 3 + flag * 3) + 1 + flag * 8; |
| | 432 | } |
| | 433 | } |
| | 434 | |
| | 435 | return 0; |
| | 436 | } |
| | 437 | |
| | 438 | static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame) |
| | 439 | { |
| | 440 | MV30Context *s = avctx->priv_data; |
| | 441 | GetBitContext mgb; |
| | 442 | uint8_t *dst[6]; |
| | 443 | int linesize[6]; |
| | 444 | int ret; |
| | 445 | |
| | 446 | mgb = *gb; |
| | 447 | skip_bits_long(gb, s->mode_size * 8); |
| | 448 | |
| | 449 | linesize[0] = frame->linesize[0]; |
| | 450 | linesize[1] = frame->linesize[0]; |
| | 451 | linesize[2] = frame->linesize[0]; |
| | 452 | linesize[3] = frame->linesize[0]; |
| | 453 | linesize[4] = frame->linesize[1]; |
| | 454 | linesize[5] = frame->linesize[2]; |
| | 455 | |
| | 456 | for (int y = 0; y < avctx->height; y += 16) { |
| | 457 | GetByteContext gbyte; |
| | 458 | int pfill[3][1] = { 0 }; |
| | 459 | int nb_codes = get_bits(gb, 16); |
| | 460 | |
| | 461 | av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs)); |
| | 462 | if (!s->coeffs) |
| | 463 | return AVERROR(ENOMEM); |
| | 464 | ret = decode_coeffs(gb, s->coeffs, nb_codes); |
| | 465 | if (ret < 0) |
| | 466 | return ret; |
| | 467 | |
| | 468 | bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs)); |
| | 469 | |
| | 470 | for (int x = 0; x < avctx->width; x += 16) { |
| | 471 | dst[0] = frame->data[0] + linesize[0] * y + x; |
| | 472 | dst[1] = frame->data[0] + linesize[0] * y + x + 8; |
| | 473 | dst[2] = frame->data[0] + linesize[0] * (y + 8) + x; |
| | 474 | dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8; |
| | 475 | dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1); |
| | 476 | dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1); |
| | 477 | |
| | 478 | for (int b = 0; b < 6; b++) { |
| | 479 | int mode = get_bits_le(&mgb, 2); |
| | 480 | |
| | 481 | ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4], |
| | 482 | s->block[b], |
| | 483 | pfill[(b >= 4) + (b >= 5)], |
| | 484 | dst[b], linesize[b]); |
| | 485 | if (ret < 0) |
| | 486 | return ret; |
| | 487 | } |
| | 488 | } |
| | 489 | } |
| | 490 | |
| | 491 | return 0; |
| | 492 | } |
| | 493 | |
| | 494 | static int decode_inter(AVCodecContext *avctx, GetBitContext *gb, |
| | 495 | AVFrame *frame, AVFrame *prev) |
| | 496 | { |
| | 497 | MV30Context *s = avctx->priv_data; |
| | 498 | GetBitContext mask; |
| | 499 | GetBitContext mgb; |
| | 500 | GetByteContext mv; |
| | 501 | const int mask_size = ((avctx->height >> 4) * (avctx->width >> 4) * 2 + 7) / 8; |
| | 502 | uint8_t *dst[6], *src[6]; |
| | 503 | int in_linesize[6]; |
| | 504 | int linesize[6]; |
| | 505 | int ret, cnt = 0; |
| | 506 | int flags = 0; |
| | 507 | |
| | 508 | in_linesize[0] = prev->linesize[0]; |
| | 509 | in_linesize[1] = prev->linesize[0]; |
| | 510 | in_linesize[2] = prev->linesize[0]; |
| | 511 | in_linesize[3] = prev->linesize[0]; |
| | 512 | in_linesize[4] = prev->linesize[1]; |
| | 513 | in_linesize[5] = prev->linesize[2]; |
| | 514 | |
| | 515 | linesize[0] = frame->linesize[0]; |
| | 516 | linesize[1] = frame->linesize[0]; |
| | 517 | linesize[2] = frame->linesize[0]; |
| | 518 | linesize[3] = frame->linesize[0]; |
| | 519 | linesize[4] = frame->linesize[1]; |
| | 520 | linesize[5] = frame->linesize[2]; |
| | 521 | |
| | 522 | av_fast_padded_malloc(&s->mvectors, &s->mvectors_size, 2 * s->nb_mvectors * sizeof(*s->mvectors)); |
| | 523 | if (!s->mvectors) { |
| | 524 | ret = AVERROR(ENOMEM); |
| | 525 | goto fail; |
| | 526 | } |
| | 527 | |
| | 528 | mask = *gb; |
| | 529 | skip_bits_long(gb, mask_size * 8); |
| | 530 | mgb = *gb; |
| | 531 | skip_bits_long(gb, s->mode_size * 8); |
| | 532 | |
| | 533 | ret = decode_coeffs(gb, s->mvectors, 2 * s->nb_mvectors); |
| | 534 | if (ret < 0) |
| | 535 | goto fail; |
| | 536 | |
| | 537 | bytestream2_init(&mv, (uint8_t *)s->mvectors, 2 * s->nb_mvectors * sizeof(*s->mvectors)); |
| | 538 | |
| | 539 | for (int y = 0; y < avctx->height; y += 16) { |
| | 540 | GetByteContext gbyte; |
| | 541 | int pfill[3][1] = { 0 }; |
| | 542 | int nb_codes = get_bits(gb, 16); |
| | 543 | |
| | 544 | skip_bits(gb, 8); |
| | 545 | if (get_bits_left(gb) < 0) { |
| | 546 | ret = AVERROR_INVALIDDATA; |
| | 547 | goto fail; |
| | 548 | } |
| | 549 | |
| | 550 | av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs)); |
| | 551 | if (!s->coeffs) { |
| | 552 | ret = AVERROR(ENOMEM); |
| | 553 | goto fail; |
| | 554 | } |
| | 555 | |
| | 556 | ret = decode_coeffs(gb, s->coeffs, nb_codes); |
| | 557 | if (ret < 0) |
| | 558 | goto fail; |
| | 559 | |
| | 560 | bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs)); |
| | 561 | |
| | 562 | for (int x = 0; x < avctx->width; x += 16) { |
| | 563 | if (cnt >= 4) |
| | 564 | cnt = 0; |
| | 565 | if (cnt == 0) |
| | 566 | flags = get_bits(&mask, 8); |
| | 567 | |
| | 568 | dst[0] = frame->data[0] + linesize[0] * y + x; |
| | 569 | dst[1] = frame->data[0] + linesize[0] * y + x + 8; |
| | 570 | dst[2] = frame->data[0] + linesize[0] * (y + 8) + x; |
| | 571 | dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8; |
| | 572 | dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1); |
| | 573 | dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1); |
| | 574 | |
| | 575 | if ((flags >> (cnt)) & 1) { |
| | 576 | int mv_x = sign_extend(bytestream2_get_ne16(&mv), 16); |
| | 577 | int mv_y = sign_extend(bytestream2_get_ne16(&mv), 16); |
| | 578 | |
| | 579 | int px = x + mv_x; |
| | 580 | int py = y + mv_y; |
| | 581 | |
| | 582 | if (px < 0 || px >= avctx->width || |
| | 583 | py < 0 || py >= avctx->height) |
| | 584 | return AVERROR_INVALIDDATA; |
| | 585 | |
| | 586 | src[0] = prev->data[0] + in_linesize[0] * py + px; |
| | 587 | src[1] = prev->data[0] + in_linesize[0] * py + px + 8; |
| | 588 | src[2] = prev->data[0] + in_linesize[0] * (py + 8) + px; |
| | 589 | src[3] = prev->data[0] + in_linesize[0] * (py + 8) + px + 8; |
| | 590 | src[4] = prev->data[1] + in_linesize[4] * (py >> 1) + (px >> 1); |
| | 591 | src[5] = prev->data[2] + in_linesize[5] * (py >> 1) + (px >> 1); |
| | 592 | |
| | 593 | if ((flags >> (cnt + 4)) & 1) { |
| | 594 | for (int b = 0; b < 6; b++) |
| | 595 | copy_block8(dst[b], src[b], linesize[b], in_linesize[b], 8); |
| | 596 | } else { |
| | 597 | for (int b = 0; b < 6; b++) { |
| | 598 | int mode = get_bits_le(&mgb, 2); |
| | 599 | |
| | 600 | ret = decode_inter_block(avctx, mode, &gbyte, s->interq_tab[b >= 4], |
| | 601 | s->block[b], |
| | 602 | pfill[(b >= 4) + (b >= 5)], |
| | 603 | dst[b], linesize[b], |
| | 604 | src[b], in_linesize[b]); |
| | 605 | if (ret < 0) |
| | 606 | goto fail; |
| | 607 | } |
| | 608 | } |
| | 609 | } else { |
| | 610 | for (int b = 0; b < 6; b++) { |
| | 611 | int mode = get_bits_le(&mgb, 2); |
| | 612 | |
| | 613 | ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4], |
| | 614 | s->block[b], |
| | 615 | pfill[(b >= 4) + (b >= 5)], |
| | 616 | dst[b], linesize[b]); |
| | 617 | if (ret < 0) |
| | 618 | goto fail; |
| | 619 | } |
| | 620 | } |
| | 621 | |
| | 622 | cnt++; |
| | 623 | } |
| | 624 | } |
| | 625 | |
| | 626 | fail: |
| | 627 | return ret; |
| | 628 | } |
| | 629 | |
| | 630 | static int decode_frame(AVCodecContext *avctx, void *data, |
| | 631 | int *got_frame, AVPacket *avpkt) |
| | 632 | { |
| | 633 | MV30Context *s = avctx->priv_data; |
| | 634 | GetBitContext *gb = &s->gb; |
| | 635 | AVFrame *frame = data; |
| | 636 | int ret; |
| | 637 | |
| | 638 | if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0) |
| | 639 | return ret; |
| | 640 | |
| | 641 | if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0) |
| | 642 | return ret; |
| | 643 | |
| | 644 | s->intra_quant = get_bits(gb, 8); |
| | 645 | s->inter_quant = s->intra_quant + get_sbits(gb, 8); |
| | 646 | s->is_inter = get_bits_le(gb, 16); |
| | 647 | s->mode_size = get_bits_le(gb, 16); |
| | 648 | if (s->is_inter) |
| | 649 | s->nb_mvectors = get_bits_le(gb, 16); |
| | 650 | |
| | 651 | get_qtable(s->intraq_tab[0], s->intra_quant, luma_tab); |
| | 652 | get_qtable(s->intraq_tab[1], s->intra_quant, chroma_tab); |
| | 653 | |
| | 654 | frame->key_frame = s->is_inter == 0; |
| | 655 | |
| | 656 | if (frame->key_frame) { |
| | 657 | ret = decode_intra(avctx, gb, frame); |
| | 658 | if (ret < 0) |
| | 659 | return ret; |
| | 660 | } else { |
| | 661 | get_qtable(s->interq_tab[0], s->inter_quant, luma_tab); |
| | 662 | get_qtable(s->interq_tab[1], s->inter_quant, chroma_tab); |
| | 663 | |
| | 664 | if (!s->prev_frame->data[0]) { |
| | 665 | av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n"); |
| | 666 | return AVERROR_INVALIDDATA; |
| | 667 | } |
| | 668 | |
| | 669 | ret = decode_inter(avctx, gb, frame, s->prev_frame); |
| | 670 | if (ret < 0) |
| | 671 | return ret; |
| | 672 | } |
| | 673 | |
| | 674 | av_frame_unref(s->prev_frame); |
| | 675 | if ((ret = av_frame_ref(s->prev_frame, frame)) < 0) |
| | 676 | return ret; |
| | 677 | |
| | 678 | *got_frame = 1; |
| | 679 | |
| | 680 | return avpkt->size; |
| | 681 | } |
| | 682 | |
| | 683 | static const uint16_t cbp_codes[] = { |
| | 684 | 0, 1, 4, 5, 6, 0xE, 0x1E, 0x3E, 0x7E, 0xFE, 0x1FE, 0x1FF, |
| | 685 | }; |
| | 686 | |
| | 687 | static const uint8_t cbp_bits[] = { |
| | 688 | 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9, 9, |
| | 689 | }; |
| | 690 | |
| | 691 | static av_cold void init_static_data(void) |
| | 692 | { |
| | 693 | INIT_VLC_SPARSE_STATIC(&cbp_tab, 9, FF_ARRAY_ELEMS(cbp_bits), |
| | 694 | cbp_bits, 1, 1, cbp_codes, 2, 2, NULL, 0, 0, 512); |
| | 695 | } |
| | 696 | |
| | 697 | static av_cold int decode_init(AVCodecContext *avctx) |
| | 698 | { |
| | 699 | MV30Context *s = avctx->priv_data; |
| | 700 | static AVOnce init_static_once = AV_ONCE_INIT; |
| | 701 | |
| | 702 | avctx->pix_fmt = AV_PIX_FMT_YUV420P; |
| | 703 | avctx->color_range = AVCOL_RANGE_JPEG; |
| | 704 | |
| | 705 | ff_blockdsp_init(&s->bdsp, avctx); |
| | 706 | |
| | 707 | s->prev_frame = av_frame_alloc(); |
| | 708 | if (!s->prev_frame) |
| | 709 | return AVERROR(ENOMEM); |
| | 710 | |
| | 711 | ff_thread_once(&init_static_once, init_static_data); |
| | 712 | |
| | 713 | return 0; |
| | 714 | } |
| | 715 | |
| | 716 | static void decode_flush(AVCodecContext *avctx) |
| | 717 | { |
| | 718 | MV30Context *s = avctx->priv_data; |
| | 719 | |
| | 720 | av_frame_unref(s->prev_frame); |
| | 721 | } |
| | 722 | |
| | 723 | static av_cold int decode_close(AVCodecContext *avctx) |
| | 724 | { |
| | 725 | MV30Context *s = avctx->priv_data; |
| | 726 | |
| | 727 | av_frame_free(&s->prev_frame); |
| | 728 | av_freep(&s->coeffs); |
| | 729 | s->coeffs_size = 0; |
| | 730 | av_freep(&s->mvectors); |
| | 731 | s->mvectors_size = 0; |
| | 732 | |
| | 733 | return 0; |
| | 734 | } |
| | 735 | |
| | 736 | AVCodec ff_mv30_decoder = { |
| | 737 | .name = "mv30", |
| | 738 | .long_name = NULL_IF_CONFIG_SMALL("MidiVid 3.0"), |
| | 739 | .type = AVMEDIA_TYPE_VIDEO, |
| | 740 | .id = AV_CODEC_ID_MV30, |
| | 741 | .priv_data_size = sizeof(MV30Context), |
| | 742 | .init = decode_init, |
| | 743 | .close = decode_close, |
| | 744 | .decode = decode_frame, |
| | 745 | .flush = decode_flush, |
| | 746 | .capabilities = AV_CODEC_CAP_DR1, |
| | 747 | .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | |
| | 748 | FF_CODEC_CAP_INIT_CLEANUP, |
| | 749 | }; |