FFmpeg
mv30.c
Go to the documentation of this file.
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 typedef struct MV30Context {
39  GetBitContext gb;
40 
41  int intra_quant;
42  int inter_quant;
43  int is_inter;
44  int mode_size;
45  int nb_mvectors;
46 
47  int block[6][64];
48  int16_t *mvectors;
49  unsigned int mvectors_size;
50  int16_t *coeffs;
51  unsigned int coeffs_size;
52 
53  int16_t intraq_tab[2][64];
54  int16_t interq_tab[2][64];
55 
56  BlockDSPContext bdsp;
57  AVFrame *prev_frame;
58 } MV30Context;
59 
60 static VLC cbp_tab;
61 
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,
71 };
72 
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,
82 };
83 
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,
93 };
94 
95 static void get_qtable(int16_t *table, int quant, const uint8_t *quant_tab)
96 {
97  int factor = quant < 50 ? 5000 / FFMAX(quant, 1) : 200 - FFMIN(quant, 100) * 2;
98 
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;
102  }
103 }
104 
105 static inline void idct_1d(unsigned *blk, int step)
106 {
107  const unsigned t0 = blk[0 * step] + blk[4 * step];
108  const unsigned t1 = blk[0 * step] - blk[4 * step];
109  const unsigned t2 = blk[2 * step] + blk[6 * step];
110  const unsigned t3 = ((int)((blk[2 * step] - blk[6 * step]) * 362U) >> 8) - t2;
111  const unsigned t4 = t0 + t2;
112  const unsigned t5 = t0 - t2;
113  const unsigned t6 = t1 + t3;
114  const unsigned t7 = t1 - t3;
115  const unsigned t8 = blk[5 * step] + blk[3 * step];
116  const unsigned t9 = blk[5 * step] - blk[3 * step];
117  const unsigned tA = blk[1 * step] + blk[7 * step];
118  const unsigned tB = blk[1 * step] - blk[7 * step];
119  const unsigned tC = t8 + tA;
120  const unsigned tD = (int)((tB + t9) * 473U) >> 8;
121  const unsigned tE = (((int)(t9 * -669U) >> 8) - tC) + tD;
122  const unsigned tF = ((int)((tA - t8) * 362U) >> 8) - tE;
123  const unsigned t10 = (((int)(tB * 277U) >> 8) - tD) + tF;
124 
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;
133 }
134 
135 static void idct_put(uint8_t *dst, int stride, int *block)
136 {
137  for (int i = 0; i < 8; i++) {
138  if ((block[0x08 + i] |
139  block[0x10 + i] |
140  block[0x18 + i] |
141  block[0x20 + i] |
142  block[0x28 + i] |
143  block[0x30 + 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];
152  } else {
153  idct_1d(block + i, 8);
154  }
155  }
156 
157  for (int i = 0; i < 8; i++) {
158  idct_1d(block, 1);
159  for (int j = 0; j < 8; j++)
160  dst[j] = av_clip_uint8((block[j] >> 5) + 128);
161  block += 8;
162  dst += stride;
163  }
164 }
165 
166 static void idct_add(uint8_t *dst, int stride,
167  const uint8_t *src, int in_linesize, int *block)
168 {
169  for (int i = 0; i < 8; i++) {
170  if ((block[0x08 + i] |
171  block[0x10 + i] |
172  block[0x18 + i] |
173  block[0x20 + i] |
174  block[0x28 + i] |
175  block[0x30 + 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];
184  } else {
185  idct_1d(block + i, 8);
186  }
187  }
188 
189  for (int i = 0; i < 8; i++) {
190  idct_1d(block, 1);
191  for (int j = 0; j < 8; j++)
192  dst[j] = av_clip_uint8((block[j] >> 5) + src[j]);
193  block += 8;
194  dst += stride;
195  src += in_linesize;
196  }
197 }
198 
199 static inline void idct2_1d(int *blk, int step)
200 {
201  const unsigned int t0 = blk[0 * step];
202  const unsigned int t1 = blk[1 * step];
203  const unsigned int t2 = (int)(t1 * 473U) >> 8;
204  const unsigned int t3 = t2 - t1;
205  const unsigned int t4 = ((int)(t1 * 362U) >> 8) - t3;
206  const unsigned int t5 = (((int)(t1 * 277U) >> 8) - t2) + t4;
207 
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;
216 }
217 
218 static void idct2_put(uint8_t *dst, int stride, int *block)
219 {
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];
229  } else {
230  idct2_1d(block + i, 8);
231  }
232  }
233 
234  for (int i = 0; i < 8; i++) {
235  if (block[1] == 0) {
236  for (int j = 0; j < 8; j++)
237  dst[j] = av_clip_uint8((block[0] >> 5) + 128);
238  } else {
239  idct2_1d(block, 1);
240  for (int j = 0; j < 8; j++)
241  dst[j] = av_clip_uint8((block[j] >> 5) + 128);
242  }
243  block += 8;
244  dst += stride;
245  }
246 }
247 
248 static void idct2_add(uint8_t *dst, int stride,
249  const uint8_t *src, int in_linesize,
250  int *block)
251 {
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];
261  } else {
262  idct2_1d(block + i, 8);
263  }
264  }
265 
266  for (int i = 0; i < 8; i++) {
267  if (block[1] == 0) {
268  for (int j = 0; j < 8; j++)
269  dst[j] = av_clip_uint8((block[0] >> 5) + src[j]);
270  } else {
271  idct2_1d(block, 1);
272  for (int j = 0; j < 8; j++)
273  dst[j] = av_clip_uint8((block[j] >> 5) + src[j]);
274  }
275  block += 8;
276  dst += stride;
277  src += in_linesize;
278  }
279 }
280 
281 static void update_inter_block(uint8_t *dst, int stride,
282  const uint8_t *src, int in_linesize,
283  int block)
284 {
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]);
288  dst += stride;
289  src += in_linesize;
290  }
291 }
292 
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)
297 {
298  MV30Context *s = avctx->priv_data;
299  int fill;
300 
301  switch (mode) {
302  case 0:
303  s->bdsp.fill_block_tab[1](dst, 128, linesize, 8);
304  break;
305  case 1:
306  fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
307  pfill[0] += fill;
308  block[0] = ((int)((unsigned)pfill[0] * qtab[0]) >> 5) + 128;
309  s->bdsp.fill_block_tab[1](dst, block[0], linesize, 8);
310  break;
311  case 2:
312  memset(block, 0, sizeof(*block) * 64);
313  fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
314  pfill[0] += fill;
315  block[0] = (unsigned)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);
320  break;
321  case 3:
322  fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
323  pfill[0] += fill;
324  block[0] = (unsigned)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);
328  break;
329  }
330 
331  return 0;
332 }
333 
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)
339 {
340  int fill;
341 
342  switch (mode) {
343  case 0:
344  copy_block8(dst, src, linesize, in_linesize, 8);
345  break;
346  case 1:
347  fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
348  pfill[0] += fill;
349  block[0] = (int)((unsigned)pfill[0] * qtab[0]) >> 5;
350  update_inter_block(dst, linesize, src, in_linesize, block[0]);
351  break;
352  case 2:
353  memset(block, 0, sizeof(*block) * 64);
354  fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
355  pfill[0] += fill;
356  block[0] = (unsigned)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);
361  break;
362  case 3:
363  fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
364  pfill[0] += fill;
365  block[0] = (unsigned)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);
369  break;
370  }
371 
372  return 0;
373 }
374 
375 static int decode_coeffs(GetBitContext *gb, int16_t *coeffs, int nb_codes)
376 {
377  memset(coeffs, 0, nb_codes * sizeof(*coeffs));
378 
379  for (int i = 0; i < nb_codes;) {
380  int value = get_vlc2(gb, cbp_tab.table, cbp_tab.bits, 1);
381 
382  if (value < 0)
383  return AVERROR_INVALIDDATA;
384 
385  if (value > 0) {
386  int x = get_bits(gb, value);
387 
388  if (x < (1 << value) / 2) {
389  x = (1 << (value - 1)) + (x & ((1 << value) - 1 >> 1));
390  } else {
391  x = -(1 << (value - 1)) - (x & ((1 << value) - 1 >> 1));
392  }
393  coeffs[i++] = x;
394  } else {
395  int flag = get_bits1(gb);
396 
397  i += get_bits(gb, 3 + flag * 3) + 1 + flag * 8;
398  }
399  }
400 
401  return 0;
402 }
403 
404 static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
405 {
406  MV30Context *s = avctx->priv_data;
407  GetBitContext mgb;
408  uint8_t *dst[6];
409  int linesize[6];
410  int ret;
411 
412  mgb = *gb;
413  if (get_bits_left(gb) < s->mode_size * 8)
414  return AVERROR_INVALIDDATA;
415 
416  skip_bits_long(gb, s->mode_size * 8);
417 
418  linesize[0] = frame->linesize[0];
419  linesize[1] = frame->linesize[0];
420  linesize[2] = frame->linesize[0];
421  linesize[3] = frame->linesize[0];
422  linesize[4] = frame->linesize[1];
423  linesize[5] = frame->linesize[2];
424 
425  for (int y = 0; y < avctx->height; y += 16) {
426  GetByteContext gbyte;
427  int pfill[3][1] = { {0} };
428  int nb_codes = get_bits(gb, 16);
429 
430  av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));
431  if (!s->coeffs)
432  return AVERROR(ENOMEM);
433  ret = decode_coeffs(gb, s->coeffs, nb_codes);
434  if (ret < 0)
435  return ret;
436 
437  bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));
438 
439  for (int x = 0; x < avctx->width; x += 16) {
440  dst[0] = frame->data[0] + linesize[0] * y + x;
441  dst[1] = frame->data[0] + linesize[0] * y + x + 8;
442  dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;
443  dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;
444  dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);
445  dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);
446 
447  for (int b = 0; b < 6; b++) {
448  int mode = get_bits_le(&mgb, 2);
449 
450  ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],
451  s->block[b],
452  pfill[(b >= 4) + (b >= 5)],
453  dst[b], linesize[b]);
454  if (ret < 0)
455  return ret;
456  }
457  }
458  }
459 
460  return 0;
461 }
462 
463 static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
464  AVFrame *frame, AVFrame *prev)
465 {
466  MV30Context *s = avctx->priv_data;
467  GetBitContext mask;
468  GetBitContext mgb;
469  GetByteContext mv;
470  const int mask_size = ((avctx->height >> 4) * (avctx->width >> 4) * 2 + 7) / 8;
471  uint8_t *dst[6], *src[6];
472  int in_linesize[6];
473  int linesize[6];
474  int ret, cnt = 0;
475  int flags = 0;
476 
477  in_linesize[0] = prev->linesize[0];
478  in_linesize[1] = prev->linesize[0];
479  in_linesize[2] = prev->linesize[0];
480  in_linesize[3] = prev->linesize[0];
481  in_linesize[4] = prev->linesize[1];
482  in_linesize[5] = prev->linesize[2];
483 
484  linesize[0] = frame->linesize[0];
485  linesize[1] = frame->linesize[0];
486  linesize[2] = frame->linesize[0];
487  linesize[3] = frame->linesize[0];
488  linesize[4] = frame->linesize[1];
489  linesize[5] = frame->linesize[2];
490 
491  av_fast_padded_malloc(&s->mvectors, &s->mvectors_size, 2 * s->nb_mvectors * sizeof(*s->mvectors));
492  if (!s->mvectors) {
493  ret = AVERROR(ENOMEM);
494  goto fail;
495  }
496 
497  mask = *gb;
498  skip_bits_long(gb, mask_size * 8);
499  mgb = *gb;
500  skip_bits_long(gb, s->mode_size * 8);
501 
502  ret = decode_coeffs(gb, s->mvectors, 2 * s->nb_mvectors);
503  if (ret < 0)
504  goto fail;
505 
506  bytestream2_init(&mv, (uint8_t *)s->mvectors, 2 * s->nb_mvectors * sizeof(*s->mvectors));
507 
508  for (int y = 0; y < avctx->height; y += 16) {
509  GetByteContext gbyte;
510  int pfill[3][1] = { {0} };
511  int nb_codes = get_bits(gb, 16);
512 
513  skip_bits(gb, 8);
514  if (get_bits_left(gb) < 0) {
515  ret = AVERROR_INVALIDDATA;
516  goto fail;
517  }
518 
519  av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));
520  if (!s->coeffs) {
521  ret = AVERROR(ENOMEM);
522  goto fail;
523  }
524 
525  ret = decode_coeffs(gb, s->coeffs, nb_codes);
526  if (ret < 0)
527  goto fail;
528 
529  bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));
530 
531  for (int x = 0; x < avctx->width; x += 16) {
532  if (cnt >= 4)
533  cnt = 0;
534  if (cnt == 0) {
535  if (get_bits_left(&mask) < 8) {
536  ret = AVERROR_INVALIDDATA;
537  goto fail;
538  }
539  flags = get_bits(&mask, 8);
540  }
541 
542  dst[0] = frame->data[0] + linesize[0] * y + x;
543  dst[1] = frame->data[0] + linesize[0] * y + x + 8;
544  dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;
545  dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;
546  dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);
547  dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);
548 
549  if ((flags >> (cnt)) & 1) {
550  int mv_x = sign_extend(bytestream2_get_ne16(&mv), 16);
551  int mv_y = sign_extend(bytestream2_get_ne16(&mv), 16);
552 
553  int px = x + mv_x;
554  int py = y + mv_y;
555 
556  if (px < 0 || px > FFALIGN(avctx->width , 16) - 16 ||
557  py < 0 || py > FFALIGN(avctx->height, 16) - 16)
558  return AVERROR_INVALIDDATA;
559 
560  src[0] = prev->data[0] + in_linesize[0] * py + px;
561  src[1] = prev->data[0] + in_linesize[0] * py + px + 8;
562  src[2] = prev->data[0] + in_linesize[0] * (py + 8) + px;
563  src[3] = prev->data[0] + in_linesize[0] * (py + 8) + px + 8;
564  src[4] = prev->data[1] + in_linesize[4] * (py >> 1) + (px >> 1);
565  src[5] = prev->data[2] + in_linesize[5] * (py >> 1) + (px >> 1);
566 
567  if ((flags >> (cnt + 4)) & 1) {
568  for (int b = 0; b < 6; b++)
569  copy_block8(dst[b], src[b], linesize[b], in_linesize[b], 8);
570  } else {
571  for (int b = 0; b < 6; b++) {
572  int mode = get_bits_le(&mgb, 2);
573 
574  ret = decode_inter_block(avctx, mode, &gbyte, s->interq_tab[b >= 4],
575  s->block[b],
576  pfill[(b >= 4) + (b >= 5)],
577  dst[b], linesize[b],
578  src[b], in_linesize[b]);
579  if (ret < 0)
580  goto fail;
581  }
582  }
583  } else {
584  for (int b = 0; b < 6; b++) {
585  int mode = get_bits_le(&mgb, 2);
586 
587  ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],
588  s->block[b],
589  pfill[(b >= 4) + (b >= 5)],
590  dst[b], linesize[b]);
591  if (ret < 0)
592  goto fail;
593  }
594  }
595 
596  cnt++;
597  }
598  }
599 
600 fail:
601  return ret;
602 }
603 
604 static int decode_frame(AVCodecContext *avctx, void *data,
605  int *got_frame, AVPacket *avpkt)
606 {
607  MV30Context *s = avctx->priv_data;
608  GetBitContext *gb = &s->gb;
609  AVFrame *frame = data;
610  int ret;
611 
612  if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
613  return ret;
614 
615  if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
616  return ret;
617 
618  s->intra_quant = get_bits(gb, 8);
619  s->inter_quant = s->intra_quant + get_sbits(gb, 8);
620  s->is_inter = get_bits_le(gb, 16);
621  s->mode_size = get_bits_le(gb, 16);
622  if (s->is_inter)
623  s->nb_mvectors = get_bits_le(gb, 16);
624 
625  get_qtable(s->intraq_tab[0], s->intra_quant, luma_tab);
626  get_qtable(s->intraq_tab[1], s->intra_quant, chroma_tab);
627 
628  frame->key_frame = s->is_inter == 0;
629 
630  if (frame->key_frame) {
631  ret = decode_intra(avctx, gb, frame);
632  if (ret < 0)
633  return ret;
634  } else {
635  get_qtable(s->interq_tab[0], s->inter_quant, luma_tab);
636  get_qtable(s->interq_tab[1], s->inter_quant, chroma_tab);
637 
638  if (!s->prev_frame->data[0]) {
639  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
640  return AVERROR_INVALIDDATA;
641  }
642 
643  ret = decode_inter(avctx, gb, frame, s->prev_frame);
644  if (ret < 0)
645  return ret;
646  }
647 
648  av_frame_unref(s->prev_frame);
649  if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
650  return ret;
651 
652  *got_frame = 1;
653 
654  return avpkt->size;
655 }
656 
657 static const uint16_t cbp_codes[] = {
658  0, 1, 4, 5, 6, 0xE, 0x1E, 0x3E, 0x7E, 0xFE, 0x1FE, 0x1FF,
659 };
660 
661 static const uint8_t cbp_bits[] = {
662  2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9, 9,
663 };
664 
665 static av_cold void init_static_data(void)
666 {
667  INIT_VLC_SPARSE_STATIC(&cbp_tab, 9, FF_ARRAY_ELEMS(cbp_bits),
668  cbp_bits, 1, 1, cbp_codes, 2, 2, NULL, 0, 0, 512);
669 }
670 
671 static av_cold int decode_init(AVCodecContext *avctx)
672 {
673  MV30Context *s = avctx->priv_data;
674  static AVOnce init_static_once = AV_ONCE_INIT;
675 
676  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
677  avctx->color_range = AVCOL_RANGE_JPEG;
678 
679  ff_blockdsp_init(&s->bdsp, avctx);
680 
681  s->prev_frame = av_frame_alloc();
682  if (!s->prev_frame)
683  return AVERROR(ENOMEM);
684 
685  ff_thread_once(&init_static_once, init_static_data);
686 
687  return 0;
688 }
689 
690 static void decode_flush(AVCodecContext *avctx)
691 {
692  MV30Context *s = avctx->priv_data;
693 
694  av_frame_unref(s->prev_frame);
695 }
696 
697 static av_cold int decode_close(AVCodecContext *avctx)
698 {
699  MV30Context *s = avctx->priv_data;
700 
701  av_frame_free(&s->prev_frame);
702  av_freep(&s->coeffs);
703  s->coeffs_size = 0;
704  av_freep(&s->mvectors);
705  s->mvectors_size = 0;
706 
707  return 0;
708 }
709 
710 AVCodec ff_mv30_decoder = {
711  .name = "mv30",
712  .long_name = NULL_IF_CONFIG_SMALL("MidiVid 3.0"),
713  .type = AVMEDIA_TYPE_VIDEO,
714  .id = AV_CODEC_ID_MV30,
715  .priv_data_size = sizeof(MV30Context),
716  .init = decode_init,
717  .close = decode_close,
718  .decode = decode_frame,
719  .flush = decode_flush,
720  .capabilities = AV_CODEC_CAP_DR1,
721  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
722  FF_CODEC_CAP_INIT_CLEANUP,
723 };
MV30Context::mvectors_size
unsigned int mvectors_size
Definition: mv30.c:49
AVCodec
AVCodec.
Definition: codec.h:190
stride
int stride
Definition: mace.c:144
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
idct2_add
static void idct2_add(uint8_t *dst, int stride, const uint8_t *src, int in_linesize, int *block)
Definition: mv30.c:248
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
blockdsp.h
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
GetByteContext
Definition: bytestream.h:33
thread.h
mv
static const int8_t mv[256][2]
Definition: 4xm.c:77
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
luma_tab
static const uint8_t luma_tab[]
Definition: mv30.c:62
t0
#define t0
Definition: regdef.h:28
b
#define b
Definition: input.c:41
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:91
ff_mv30_decoder
AVCodec ff_mv30_decoder
Definition: mv30.c:710
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
copy_block8
static void copy_block8(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
Definition: copy_block.h:47
t1
#define t1
Definition: regdef.h:29
BlockDSPContext
Definition: blockdsp.h:35
MV30Context::inter_quant
int inter_quant
Definition: mv30.c:42
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
t10
#define t10
Definition: regdef.h:55
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
decode_intra
static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
Definition: mv30.c:404
init_static_data
static av_cold void init_static_data(void)
Definition: mv30.c:665
U
#define U(x)
Definition: vp56_arith.h:37
fail
#define fail()
Definition: checkasm.h:123
MV30Context::bdsp
BlockDSPContext bdsp
Definition: mv30.c:56
AV_CODEC_ID_MV30
@ AV_CODEC_ID_MV30
Definition: codec_id.h:295
GetBitContext
Definition: get_bits.h:61
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mv30.c:604
chroma_tab
static const uint8_t chroma_tab[]
Definition: mv30.c:73
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
cbp_codes
static const uint16_t cbp_codes[]
Definition: mv30.c:657
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
mask
static const uint16_t mask[17]
Definition: lzw.c:38
INIT_VLC_SPARSE_STATIC
#define INIT_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, h, i, j, static_size)
Definition: vlc.h:57
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:509
t7
#define t7
Definition: regdef.h:35
get_bits_le
static unsigned int get_bits_le(GetBitContext *s, int n)
Definition: get_bits.h:420
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
get_bits.h
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
blk
#define blk(i)
Definition: sha.c:185
decode_flush
static void decode_flush(AVCodecContext *avctx)
Definition: mv30.c:690
MV30Context::prev_frame
AVFrame * prev_frame
Definition: mv30.c:57
cbp_bits
static const uint8_t cbp_bits[]
Definition: mv30.c:661
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
MV30Context
Definition: mv30.c:38
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:500
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
decode_intra_block
static int decode_intra_block(AVCodecContext *avctx, int mode, GetByteContext *gbyte, int16_t *qtab, int *block, int *pfill, uint8_t *dst, int linesize)
Definition: mv30.c:293
t5
#define t5
Definition: regdef.h:33
aandcttab.h
t6
#define t6
Definition: regdef.h:34
MV30Context::mode_size
int mode_size
Definition: mv30.c:44
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
src
#define src
Definition: vp8dsp.c:254
mathops.h
idct2_put
static void idct2_put(uint8_t *dst, int stride, int *block)
Definition: mv30.c:218
zigzag
static const uint8_t zigzag[]
Definition: mv30.c:84
MV30Context::is_inter
int is_inter
Definition: mv30.c:43
AVOnce
#define AVOnce
Definition: thread.h:172
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: mv30.c:697
MV30Context::nb_mvectors
int nb_mvectors
Definition: mv30.c:45
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1854
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AVPacket::size
int size
Definition: packet.h:356
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:444
idct_put
static void idct_put(uint8_t *dst, int stride, int *block)
Definition: mv30.c:135
bytestream2_get_ne16
#define bytestream2_get_ne16
Definition: bytestream.h:115
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
MV30Context::gb
GetBitContext gb
Definition: mv30.c:39
t8
#define t8
Definition: regdef.h:53
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
flag
#define flag(name)
Definition: cbs_av1.c:557
MV30Context::interq_tab
int16_t interq_tab[2][64]
Definition: mv30.c:54
idct_1d
static void idct_1d(unsigned *blk, int step)
Definition: mv30.c:105
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
copy_block.h
MV30Context::coeffs
int16_t * coeffs
Definition: mv30.c:50
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
t4
#define t4
Definition: regdef.h:32
t3
#define t3
Definition: regdef.h:31
MV30Context::intra_quant
int intra_quant
Definition: mv30.c:41
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:70
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
uint8_t
uint8_t
Definition: audio_convert.c:194
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
MV30Context::coeffs_size
unsigned int coeffs_size
Definition: mv30.c:51
AVCodecContext::height
int height
Definition: avcodec.h:699
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
avcodec.h
get_qtable
static void get_qtable(int16_t *table, int quant, const uint8_t *quant_tab)
Definition: mv30.c:95
MV30Context::block
int block[6][64]
Definition: mv30.c:47
VLC::bits
int bits
Definition: vlc.h:27
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
MV30Context::intraq_tab
int16_t intraq_tab[2][64]
Definition: mv30.c:53
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
AVCodecContext
main external API structure.
Definition: avcodec.h:526
t2
#define t2
Definition: regdef.h:30
mode
mode
Definition: ebur128.h:83
VLC
Definition: vlc.h:26
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
decode_coeffs
static int decode_coeffs(GetBitContext *gb, int16_t *coeffs, int nb_codes)
Definition: mv30.c:375
factor
static const int factor[16]
Definition: vf_pp7.c:75
MV30Context::mvectors
int16_t * mvectors
Definition: mv30.c:48
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
t9
#define t9
Definition: regdef.h:54
decode_inter
static int decode_inter(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame, AVFrame *prev)
Definition: mv30.c:463
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: mv30.c:671
quant
const uint8_t * quant
Definition: vorbis_enc_data.h:458
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
bytestream.h
idct_add
static void idct_add(uint8_t *dst, int stride, const uint8_t *src, int in_linesize, int *block)
Definition: mv30.c:166
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
int
int
Definition: ffmpeg_filter.c:192
cbp_tab
static VLC cbp_tab
Definition: mv30.c:60
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
idct2_1d
static void idct2_1d(int *blk, int step)
Definition: mv30.c:199
ff_aanscales
const uint16_t ff_aanscales[64]
Definition: aandcttab.c:26
update_inter_block
static void update_inter_block(uint8_t *dst, int stride, const uint8_t *src, int in_linesize, int block)
Definition: mv30.c:281
decode_inter_block
static int decode_inter_block(AVCodecContext *avctx, int mode, GetByteContext *gbyte, int16_t *qtab, int *block, int *pfill, uint8_t *dst, int linesize, const uint8_t *src, int in_linesize)
Definition: mv30.c:334
Generated on Wed Aug 24 2022 21:31:29 for FFmpeg by   doxygen 1.8.17