FFmpeg  4.0
svq3.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2003 The FFmpeg Project
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /*
22  * How to use this decoder:
23  * SVQ3 data is transported within Apple Quicktime files. Quicktime files
24  * have stsd atoms to describe media trak properties. A stsd atom for a
25  * video trak contains 1 or more ImageDescription atoms. These atoms begin
26  * with the 4-byte length of the atom followed by the codec fourcc. Some
27  * decoders need information in this atom to operate correctly. Such
28  * is the case with SVQ3. In order to get the best use out of this decoder,
29  * the calling app must make the SVQ3 ImageDescription atom available
30  * via the AVCodecContext's extradata[_size] field:
31  *
32  * AVCodecContext.extradata = pointer to ImageDescription, first characters
33  * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
34  * AVCodecContext.extradata_size = size of ImageDescription atom memory
35  * buffer (which will be the same as the ImageDescription atom size field
36  * from the QT file, minus 4 bytes since the length is missing)
37  *
38  * You will know you have these parameters passed correctly when the decoder
39  * correctly decodes this file:
40  * http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41  */
42 
43 #include <inttypes.h>
44 
45 #include "libavutil/attributes.h"
46 #include "internal.h"
47 #include "avcodec.h"
48 #include "mpegutils.h"
49 #include "h264dec.h"
50 #include "h264data.h"
51 #include "golomb.h"
52 #include "hpeldsp.h"
53 #include "mathops.h"
54 #include "rectangle.h"
55 #include "tpeldsp.h"
56 
57 #if CONFIG_ZLIB
58 #include <zlib.h>
59 #endif
60 
61 #include "svq1.h"
62 
63 /**
64  * @file
65  * svq3 decoder.
66  */
67 
68 typedef struct SVQ3Frame {
70 
72  int16_t (*motion_val[2])[2];
73 
75  uint32_t *mb_type;
76 
77 
79  int8_t *ref_index[2];
80 } SVQ3Frame;
81 
82 typedef struct SVQ3Context {
84 
90 
101  uint32_t watermark_key;
103  int buf_size;
110  int qscale;
111  int cbp;
116 
117  enum AVPictureType pict_type;
118  enum AVPictureType slice_type;
120 
121  int mb_x, mb_y;
122  int mb_xy;
123  int mb_width, mb_height;
124  int mb_stride, mb_num;
125  int b_stride;
126 
127  uint32_t *mb2br_xy;
128 
131 
132  int8_t intra4x4_pred_mode_cache[5 * 8];
133  int8_t (*intra4x4_pred_mode);
134 
135  unsigned int top_samples_available;
138 
140 
141  DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
142  DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8];
143  DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
144  DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
145  DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
146  uint32_t dequant4_coeff[QP_MAX_NUM + 1][16];
147  int block_offset[2 * (16 * 3)];
148 } SVQ3Context;
149 
150 #define FULLPEL_MODE 1
151 #define HALFPEL_MODE 2
152 #define THIRDPEL_MODE 3
153 #define PREDICT_MODE 4
154 
155 /* dual scan (from some older H.264 draft)
156  * o-->o-->o o
157  * | /|
158  * o o o / o
159  * | / | |/ |
160  * o o o o
161  * /
162  * o-->o-->o-->o
163  */
164 static const uint8_t svq3_scan[16] = {
165  0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
166  2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
167  0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
168  0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
169 };
170 
171 static const uint8_t luma_dc_zigzag_scan[16] = {
172  0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
173  3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
174  1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
175  3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
176 };
177 
178 static const uint8_t svq3_pred_0[25][2] = {
179  { 0, 0 },
180  { 1, 0 }, { 0, 1 },
181  { 0, 2 }, { 1, 1 }, { 2, 0 },
182  { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
183  { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
184  { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
185  { 2, 4 }, { 3, 3 }, { 4, 2 },
186  { 4, 3 }, { 3, 4 },
187  { 4, 4 }
188 };
189 
190 static const int8_t svq3_pred_1[6][6][5] = {
191  { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
192  { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
193  { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
194  { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
195  { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
196  { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
197  { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
198  { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
199  { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
200  { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
201  { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
202  { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
203 };
204 
205 static const struct {
208 } svq3_dct_tables[2][16] = {
209  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
210  { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
211  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
212  { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
213 };
214 
215 static const uint32_t svq3_dequant_coeff[32] = {
216  3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
217  9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
218  24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
219  61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
220 };
221 
222 static int svq3_decode_end(AVCodecContext *avctx);
223 
224 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
225 {
226  const unsigned qmul = svq3_dequant_coeff[qp];
227 #define stride 16
228  int i;
229  int temp[16];
230  static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
231 
232  for (i = 0; i < 4; i++) {
233  const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
234  const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
235  const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
236  const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
237 
238  temp[4 * i + 0] = z0 + z3;
239  temp[4 * i + 1] = z1 + z2;
240  temp[4 * i + 2] = z1 - z2;
241  temp[4 * i + 3] = z0 - z3;
242  }
243 
244  for (i = 0; i < 4; i++) {
245  const int offset = x_offset[i];
246  const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
247  const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
248  const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
249  const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
250 
251  output[stride * 0 + offset] = (int)((z0 + z3) * qmul + 0x80000) >> 20;
252  output[stride * 2 + offset] = (int)((z1 + z2) * qmul + 0x80000) >> 20;
253  output[stride * 8 + offset] = (int)((z1 - z2) * qmul + 0x80000) >> 20;
254  output[stride * 10 + offset] = (int)((z0 - z3) * qmul + 0x80000) >> 20;
255  }
256 }
257 #undef stride
258 
259 static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
260  int stride, int qp, int dc)
261 {
262  const int qmul = svq3_dequant_coeff[qp];
263  int i;
264 
265  if (dc) {
266  dc = 13 * 13 * (dc == 1 ? 1538U* block[0]
267  : qmul * (block[0] >> 3) / 2);
268  block[0] = 0;
269  }
270 
271  for (i = 0; i < 4; i++) {
272  const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
273  const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
274  const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
275  const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
276 
277  block[0 + 4 * i] = z0 + z3;
278  block[1 + 4 * i] = z1 + z2;
279  block[2 + 4 * i] = z1 - z2;
280  block[3 + 4 * i] = z0 - z3;
281  }
282 
283  for (i = 0; i < 4; i++) {
284  const unsigned z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
285  const unsigned z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
286  const unsigned z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
287  const unsigned z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
288  const int rr = (dc + 0x80000u);
289 
290  dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((int)((z0 + z3) * qmul + rr) >> 20));
291  dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((int)((z1 + z2) * qmul + rr) >> 20));
292  dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((int)((z1 - z2) * qmul + rr) >> 20));
293  dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((int)((z0 - z3) * qmul + rr) >> 20));
294  }
295 
296  memset(block, 0, 16 * sizeof(int16_t));
297 }
298 
299 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
300  int index, const int type)
301 {
302  static const uint8_t *const scan_patterns[4] = {
304  };
305 
306  int run, level, sign, limit;
307  unsigned vlc;
308  const int intra = 3 * type >> 2;
309  const uint8_t *const scan = scan_patterns[type];
310 
311  for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
312  for (; (vlc = get_interleaved_ue_golomb(gb)) != 0; index++) {
313  if ((int32_t)vlc < 0)
314  return -1;
315 
316  sign = (vlc & 1) ? 0 : -1;
317  vlc = vlc + 1 >> 1;
318 
319  if (type == 3) {
320  if (vlc < 3) {
321  run = 0;
322  level = vlc;
323  } else if (vlc < 4) {
324  run = 1;
325  level = 1;
326  } else {
327  run = vlc & 0x3;
328  level = (vlc + 9 >> 2) - run;
329  }
330  } else {
331  if (vlc < 16U) {
332  run = svq3_dct_tables[intra][vlc].run;
333  level = svq3_dct_tables[intra][vlc].level;
334  } else if (intra) {
335  run = vlc & 0x7;
336  level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
337  } else {
338  run = vlc & 0xF;
339  level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
340  }
341  }
342 
343 
344  if ((index += run) >= limit)
345  return -1;
346 
347  block[scan[index]] = (level ^ sign) - sign;
348  }
349 
350  if (type != 2) {
351  break;
352  }
353  }
354 
355  return 0;
356 }
357 
358 static av_always_inline int
359 svq3_fetch_diagonal_mv(const SVQ3Context *s, const int16_t **C,
360  int i, int list, int part_width)
361 {
362  const int topright_ref = s->ref_cache[list][i - 8 + part_width];
363 
364  if (topright_ref != PART_NOT_AVAILABLE) {
365  *C = s->mv_cache[list][i - 8 + part_width];
366  return topright_ref;
367  } else {
368  *C = s->mv_cache[list][i - 8 - 1];
369  return s->ref_cache[list][i - 8 - 1];
370  }
371 }
372 
373 /**
374  * Get the predicted MV.
375  * @param n the block index
376  * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
377  * @param mx the x component of the predicted motion vector
378  * @param my the y component of the predicted motion vector
379  */
381  int part_width, int list,
382  int ref, int *const mx, int *const my)
383 {
384  const int index8 = scan8[n];
385  const int top_ref = s->ref_cache[list][index8 - 8];
386  const int left_ref = s->ref_cache[list][index8 - 1];
387  const int16_t *const A = s->mv_cache[list][index8 - 1];
388  const int16_t *const B = s->mv_cache[list][index8 - 8];
389  const int16_t *C;
390  int diagonal_ref, match_count;
391 
392 /* mv_cache
393  * B . . A T T T T
394  * U . . L . . , .
395  * U . . L . . . .
396  * U . . L . . , .
397  * . . . L . . . .
398  */
399 
400  diagonal_ref = svq3_fetch_diagonal_mv(s, &C, index8, list, part_width);
401  match_count = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
402  if (match_count > 1) { //most common
403  *mx = mid_pred(A[0], B[0], C[0]);
404  *my = mid_pred(A[1], B[1], C[1]);
405  } else if (match_count == 1) {
406  if (left_ref == ref) {
407  *mx = A[0];
408  *my = A[1];
409  } else if (top_ref == ref) {
410  *mx = B[0];
411  *my = B[1];
412  } else {
413  *mx = C[0];
414  *my = C[1];
415  }
416  } else {
417  if (top_ref == PART_NOT_AVAILABLE &&
418  diagonal_ref == PART_NOT_AVAILABLE &&
419  left_ref != PART_NOT_AVAILABLE) {
420  *mx = A[0];
421  *my = A[1];
422  } else {
423  *mx = mid_pred(A[0], B[0], C[0]);
424  *my = mid_pred(A[1], B[1], C[1]);
425  }
426  }
427 }
428 
429 static inline void svq3_mc_dir_part(SVQ3Context *s,
430  int x, int y, int width, int height,
431  int mx, int my, int dxy,
432  int thirdpel, int dir, int avg)
433 {
434  const SVQ3Frame *pic = (dir == 0) ? s->last_pic : s->next_pic;
435  uint8_t *src, *dest;
436  int i, emu = 0;
437  int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
438  int linesize = s->cur_pic->f->linesize[0];
439  int uvlinesize = s->cur_pic->f->linesize[1];
440 
441  mx += x;
442  my += y;
443 
444  if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
445  my < 0 || my >= s->v_edge_pos - height - 1) {
446  emu = 1;
447  mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
448  my = av_clip(my, -16, s->v_edge_pos - height + 15);
449  }
450 
451  /* form component predictions */
452  dest = s->cur_pic->f->data[0] + x + y * linesize;
453  src = pic->f->data[0] + mx + my * linesize;
454 
455  if (emu) {
457  linesize, linesize,
458  width + 1, height + 1,
459  mx, my, s->h_edge_pos, s->v_edge_pos);
460  src = s->edge_emu_buffer;
461  }
462  if (thirdpel)
463  (avg ? s->tdsp.avg_tpel_pixels_tab
464  : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, linesize,
465  width, height);
466  else
467  (avg ? s->hdsp.avg_pixels_tab
468  : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, linesize,
469  height);
470 
471  if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
472  mx = mx + (mx < (int) x) >> 1;
473  my = my + (my < (int) y) >> 1;
474  width = width >> 1;
475  height = height >> 1;
476  blocksize++;
477 
478  for (i = 1; i < 3; i++) {
479  dest = s->cur_pic->f->data[i] + (x >> 1) + (y >> 1) * uvlinesize;
480  src = pic->f->data[i] + mx + my * uvlinesize;
481 
482  if (emu) {
484  uvlinesize, uvlinesize,
485  width + 1, height + 1,
486  mx, my, (s->h_edge_pos >> 1),
487  s->v_edge_pos >> 1);
488  src = s->edge_emu_buffer;
489  }
490  if (thirdpel)
491  (avg ? s->tdsp.avg_tpel_pixels_tab
492  : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
493  uvlinesize,
494  width, height);
495  else
496  (avg ? s->hdsp.avg_pixels_tab
497  : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
498  uvlinesize,
499  height);
500  }
501  }
502 }
503 
504 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
505  int dir, int avg)
506 {
507  int i, j, k, mx, my, dx, dy, x, y;
508  const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
509  const int part_height = 16 >> ((unsigned)(size + 1) / 3);
510  const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
511  const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
512  const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
513 
514  for (i = 0; i < 16; i += part_height)
515  for (j = 0; j < 16; j += part_width) {
516  const int b_xy = (4 * s->mb_x + (j >> 2)) +
517  (4 * s->mb_y + (i >> 2)) * s->b_stride;
518  int dxy;
519  x = 16 * s->mb_x + j;
520  y = 16 * s->mb_y + i;
521  k = (j >> 2 & 1) + (i >> 1 & 2) +
522  (j >> 1 & 4) + (i & 8);
523 
524  if (mode != PREDICT_MODE) {
525  svq3_pred_motion(s, k, part_width >> 2, dir, 1, &mx, &my);
526  } else {
527  mx = s->next_pic->motion_val[0][b_xy][0] * 2;
528  my = s->next_pic->motion_val[0][b_xy][1] * 2;
529 
530  if (dir == 0) {
531  mx = mx * s->frame_num_offset /
532  s->prev_frame_num_offset + 1 >> 1;
533  my = my * s->frame_num_offset /
534  s->prev_frame_num_offset + 1 >> 1;
535  } else {
536  mx = mx * (s->frame_num_offset - s->prev_frame_num_offset) /
537  s->prev_frame_num_offset + 1 >> 1;
538  my = my * (s->frame_num_offset - s->prev_frame_num_offset) /
539  s->prev_frame_num_offset + 1 >> 1;
540  }
541  }
542 
543  /* clip motion vector prediction to frame border */
544  mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
545  my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
546 
547  /* get (optional) motion vector differential */
548  if (mode == PREDICT_MODE) {
549  dx = dy = 0;
550  } else {
553 
554  if (dx != (int16_t)dx || dy != (int16_t)dy) {
555  av_log(s->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
556  return -1;
557  }
558  }
559 
560  /* compute motion vector */
561  if (mode == THIRDPEL_MODE) {
562  int fx, fy;
563  mx = (mx + 1 >> 1) + dx;
564  my = (my + 1 >> 1) + dy;
565  fx = (unsigned)(mx + 0x30000) / 3 - 0x10000;
566  fy = (unsigned)(my + 0x30000) / 3 - 0x10000;
567  dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
568 
569  svq3_mc_dir_part(s, x, y, part_width, part_height,
570  fx, fy, dxy, 1, dir, avg);
571  mx += mx;
572  my += my;
573  } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
574  mx = (unsigned)(mx + 1 + 0x30000) / 3 + dx - 0x10000;
575  my = (unsigned)(my + 1 + 0x30000) / 3 + dy - 0x10000;
576  dxy = (mx & 1) + 2 * (my & 1);
577 
578  svq3_mc_dir_part(s, x, y, part_width, part_height,
579  mx >> 1, my >> 1, dxy, 0, dir, avg);
580  mx *= 3;
581  my *= 3;
582  } else {
583  mx = (unsigned)(mx + 3 + 0x60000) / 6 + dx - 0x10000;
584  my = (unsigned)(my + 3 + 0x60000) / 6 + dy - 0x10000;
585 
586  svq3_mc_dir_part(s, x, y, part_width, part_height,
587  mx, my, 0, 0, dir, avg);
588  mx *= 6;
589  my *= 6;
590  }
591 
592  /* update mv_cache */
593  if (mode != PREDICT_MODE) {
594  int32_t mv = pack16to32(mx, my);
595 
596  if (part_height == 8 && i < 8) {
597  AV_WN32A(s->mv_cache[dir][scan8[k] + 1 * 8], mv);
598 
599  if (part_width == 8 && j < 8)
600  AV_WN32A(s->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
601  }
602  if (part_width == 8 && j < 8)
603  AV_WN32A(s->mv_cache[dir][scan8[k] + 1], mv);
604  if (part_width == 4 || part_height == 4)
605  AV_WN32A(s->mv_cache[dir][scan8[k]], mv);
606  }
607 
608  /* write back motion vectors */
609  fill_rectangle(s->cur_pic->motion_val[dir][b_xy],
610  part_width >> 2, part_height >> 2, s->b_stride,
611  pack16to32(mx, my), 4);
612  }
613 
614  return 0;
615 }
616 
618  int mb_type, const int *block_offset,
619  int linesize, uint8_t *dest_y)
620 {
621  int i;
622  if (!IS_INTRA4x4(mb_type)) {
623  for (i = 0; i < 16; i++)
624  if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
625  uint8_t *const ptr = dest_y + block_offset[i];
626  svq3_add_idct_c(ptr, s->mb + i * 16, linesize,
627  s->qscale, IS_INTRA(mb_type) ? 1 : 0);
628  }
629  }
630 }
631 
633  int mb_type,
634  const int *block_offset,
635  int linesize,
636  uint8_t *dest_y)
637 {
638  int i;
639  int qscale = s->qscale;
640 
641  if (IS_INTRA4x4(mb_type)) {
642  for (i = 0; i < 16; i++) {
643  uint8_t *const ptr = dest_y + block_offset[i];
644  const int dir = s->intra4x4_pred_mode_cache[scan8[i]];
645 
646  uint8_t *topright;
647  int nnz, tr;
648  if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
649  const int topright_avail = (s->topright_samples_available << i) & 0x8000;
650  av_assert2(s->mb_y || linesize <= block_offset[i]);
651  if (!topright_avail) {
652  tr = ptr[3 - linesize] * 0x01010101u;
653  topright = (uint8_t *)&tr;
654  } else
655  topright = ptr + 4 - linesize;
656  } else
657  topright = NULL;
658 
659  s->hpc.pred4x4[dir](ptr, topright, linesize);
660  nnz = s->non_zero_count_cache[scan8[i]];
661  if (nnz) {
662  svq3_add_idct_c(ptr, s->mb + i * 16, linesize, qscale, 0);
663  }
664  }
665  } else {
666  s->hpc.pred16x16[s->intra16x16_pred_mode](dest_y, linesize);
667  svq3_luma_dc_dequant_idct_c(s->mb, s->mb_luma_dc[0], qscale);
668  }
669 }
670 
672 {
673  const int mb_x = s->mb_x;
674  const int mb_y = s->mb_y;
675  const int mb_xy = s->mb_xy;
676  const int mb_type = s->cur_pic->mb_type[mb_xy];
677  uint8_t *dest_y, *dest_cb, *dest_cr;
678  int linesize, uvlinesize;
679  int i, j;
680  const int *block_offset = &s->block_offset[0];
681  const int block_h = 16 >> 1;
682 
683  linesize = s->cur_pic->f->linesize[0];
684  uvlinesize = s->cur_pic->f->linesize[1];
685 
686  dest_y = s->cur_pic->f->data[0] + (mb_x + mb_y * linesize) * 16;
687  dest_cb = s->cur_pic->f->data[1] + mb_x * 8 + mb_y * uvlinesize * block_h;
688  dest_cr = s->cur_pic->f->data[2] + mb_x * 8 + mb_y * uvlinesize * block_h;
689 
690  s->vdsp.prefetch(dest_y + (s->mb_x & 3) * 4 * linesize + 64, linesize, 4);
691  s->vdsp.prefetch(dest_cb + (s->mb_x & 7) * uvlinesize + 64, dest_cr - dest_cb, 2);
692 
693  if (IS_INTRA(mb_type)) {
694  s->hpc.pred8x8[s->chroma_pred_mode](dest_cb, uvlinesize);
695  s->hpc.pred8x8[s->chroma_pred_mode](dest_cr, uvlinesize);
696 
697  hl_decode_mb_predict_luma(s, mb_type, block_offset, linesize, dest_y);
698  }
699 
700  hl_decode_mb_idct_luma(s, mb_type, block_offset, linesize, dest_y);
701 
702  if (s->cbp & 0x30) {
703  uint8_t *dest[2] = { dest_cb, dest_cr };
704  s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 1,
705  s->dequant4_coeff[4][0]);
706  s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 2,
707  s->dequant4_coeff[4][0]);
708  for (j = 1; j < 3; j++) {
709  for (i = j * 16; i < j * 16 + 4; i++)
710  if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
711  uint8_t *const ptr = dest[j - 1] + block_offset[i];
712  svq3_add_idct_c(ptr, s->mb + i * 16,
713  uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
714  }
715  }
716  }
717 }
718 
719 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
720 {
721  int i, j, k, m, dir, mode;
722  int cbp = 0;
723  uint32_t vlc;
724  int8_t *top, *left;
725  const int mb_xy = s->mb_xy;
726  const int b_xy = 4 * s->mb_x + 4 * s->mb_y * s->b_stride;
727 
728  s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
729  s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
730  s->topright_samples_available = 0xFFFF;
731 
732  if (mb_type == 0) { /* SKIP */
733  if (s->pict_type == AV_PICTURE_TYPE_P ||
734  s->next_pic->mb_type[mb_xy] == -1) {
735  svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
736  0, 0, 0, 0, 0, 0);
737 
738  if (s->pict_type == AV_PICTURE_TYPE_B)
739  svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
740  0, 0, 0, 0, 1, 1);
741 
742  mb_type = MB_TYPE_SKIP;
743  } else {
744  mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
745  if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
746  return -1;
747  if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
748  return -1;
749 
750  mb_type = MB_TYPE_16x16;
751  }
752  } else if (mb_type < 8) { /* INTER */
753  if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&s->gb_slice))
754  mode = THIRDPEL_MODE;
755  else if (s->halfpel_flag &&
756  s->thirdpel_flag == !get_bits1(&s->gb_slice))
757  mode = HALFPEL_MODE;
758  else
759  mode = FULLPEL_MODE;
760 
761  /* fill caches */
762  /* note ref_cache should contain here:
763  * ????????
764  * ???11111
765  * N??11111
766  * N??11111
767  * N??11111
768  */
769 
770  for (m = 0; m < 2; m++) {
771  if (s->mb_x > 0 && s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6] != -1) {
772  for (i = 0; i < 4; i++)
773  AV_COPY32(s->mv_cache[m][scan8[0] - 1 + i * 8],
774  s->cur_pic->motion_val[m][b_xy - 1 + i * s->b_stride]);
775  } else {
776  for (i = 0; i < 4; i++)
777  AV_ZERO32(s->mv_cache[m][scan8[0] - 1 + i * 8]);
778  }
779  if (s->mb_y > 0) {
780  memcpy(s->mv_cache[m][scan8[0] - 1 * 8],
781  s->cur_pic->motion_val[m][b_xy - s->b_stride],
782  4 * 2 * sizeof(int16_t));
783  memset(&s->ref_cache[m][scan8[0] - 1 * 8],
784  (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
785 
786  if (s->mb_x < s->mb_width - 1) {
787  AV_COPY32(s->mv_cache[m][scan8[0] + 4 - 1 * 8],
788  s->cur_pic->motion_val[m][b_xy - s->b_stride + 4]);
789  s->ref_cache[m][scan8[0] + 4 - 1 * 8] =
790  (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
791  s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
792  } else
793  s->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
794  if (s->mb_x > 0) {
795  AV_COPY32(s->mv_cache[m][scan8[0] - 1 - 1 * 8],
796  s->cur_pic->motion_val[m][b_xy - s->b_stride - 1]);
797  s->ref_cache[m][scan8[0] - 1 - 1 * 8] =
798  (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
799  } else
800  s->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
801  } else
802  memset(&s->ref_cache[m][scan8[0] - 1 * 8 - 1],
803  PART_NOT_AVAILABLE, 8);
804 
805  if (s->pict_type != AV_PICTURE_TYPE_B)
806  break;
807  }
808 
809  /* decode motion vector(s) and form prediction(s) */
810  if (s->pict_type == AV_PICTURE_TYPE_P) {
811  if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
812  return -1;
813  } else { /* AV_PICTURE_TYPE_B */
814  if (mb_type != 2) {
815  if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
816  return -1;
817  } else {
818  for (i = 0; i < 4; i++)
819  memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
820  0, 4 * 2 * sizeof(int16_t));
821  }
822  if (mb_type != 1) {
823  if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
824  return -1;
825  } else {
826  for (i = 0; i < 4; i++)
827  memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
828  0, 4 * 2 * sizeof(int16_t));
829  }
830  }
831 
832  mb_type = MB_TYPE_16x16;
833  } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
834  int8_t *i4x4 = s->intra4x4_pred_mode + s->mb2br_xy[s->mb_xy];
835  int8_t *i4x4_cache = s->intra4x4_pred_mode_cache;
836 
837  memset(s->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
838 
839  if (mb_type == 8) {
840  if (s->mb_x > 0) {
841  for (i = 0; i < 4; i++)
842  s->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6 - i];
843  if (s->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
844  s->left_samples_available = 0x5F5F;
845  }
846  if (s->mb_y > 0) {
847  s->intra4x4_pred_mode_cache[4 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 0];
848  s->intra4x4_pred_mode_cache[5 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 1];
849  s->intra4x4_pred_mode_cache[6 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 2];
850  s->intra4x4_pred_mode_cache[7 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 3];
851 
852  if (s->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
853  s->top_samples_available = 0x33FF;
854  }
855 
856  /* decode prediction codes for luma blocks */
857  for (i = 0; i < 16; i += 2) {
859 
860  if (vlc >= 25U) {
862  "luma prediction:%"PRIu32"\n", vlc);
863  return -1;
864  }
865 
866  left = &s->intra4x4_pred_mode_cache[scan8[i] - 1];
867  top = &s->intra4x4_pred_mode_cache[scan8[i] - 8];
868 
869  left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
870  left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
871 
872  if (left[1] == -1 || left[2] == -1) {
873  av_log(s->avctx, AV_LOG_ERROR, "weird prediction\n");
874  return -1;
875  }
876  }
877  } else { /* mb_type == 33, DC_128_PRED block type */
878  for (i = 0; i < 4; i++)
879  memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
880  }
881 
882  AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
883  i4x4[4] = i4x4_cache[7 + 8 * 3];
884  i4x4[5] = i4x4_cache[7 + 8 * 2];
885  i4x4[6] = i4x4_cache[7 + 8 * 1];
886 
887  if (mb_type == 8) {
891 
892  s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
893  s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
894  } else {
895  for (i = 0; i < 4; i++)
896  memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
897 
898  s->top_samples_available = 0x33FF;
899  s->left_samples_available = 0x5F5F;
900  }
901 
902  mb_type = MB_TYPE_INTRA4x4;
903  } else { /* INTRA16x16 */
904  dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
905  dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
906 
908  s->left_samples_available, dir, 0)) < 0) {
909  av_log(s->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
910  return s->intra16x16_pred_mode;
911  }
912 
913  cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
914  mb_type = MB_TYPE_INTRA16x16;
915  }
916 
917  if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
918  for (i = 0; i < 4; i++)
919  memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
920  0, 4 * 2 * sizeof(int16_t));
921  if (s->pict_type == AV_PICTURE_TYPE_B) {
922  for (i = 0; i < 4; i++)
923  memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
924  0, 4 * 2 * sizeof(int16_t));
925  }
926  }
927  if (!IS_INTRA4x4(mb_type)) {
928  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy], DC_PRED, 8);
929  }
930  if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
931  memset(s->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
932  }
933 
934  if (!IS_INTRA16x16(mb_type) &&
935  (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
936  if ((vlc = get_interleaved_ue_golomb(&s->gb_slice)) >= 48U){
937  av_log(s->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
938  return -1;
939  }
940 
941  cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
943  }
944  if (IS_INTRA16x16(mb_type) ||
945  (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
947 
948  if (s->qscale > 31u) {
949  av_log(s->avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
950  return -1;
951  }
952  }
953  if (IS_INTRA16x16(mb_type)) {
954  AV_ZERO128(s->mb_luma_dc[0] + 0);
955  AV_ZERO128(s->mb_luma_dc[0] + 8);
956  if (svq3_decode_block(&s->gb_slice, s->mb_luma_dc[0], 0, 1)) {
958  "error while decoding intra luma dc\n");
959  return -1;
960  }
961  }
962 
963  if (cbp) {
964  const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
965  const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
966 
967  for (i = 0; i < 4; i++)
968  if ((cbp & (1 << i))) {
969  for (j = 0; j < 4; j++) {
970  k = index ? (1 * (j & 1) + 2 * (i & 1) +
971  2 * (j & 2) + 4 * (i & 2))
972  : (4 * i + j);
973  s->non_zero_count_cache[scan8[k]] = 1;
974 
975  if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], index, type)) {
977  "error while decoding block\n");
978  return -1;
979  }
980  }
981  }
982 
983  if ((cbp & 0x30)) {
984  for (i = 1; i < 3; ++i)
985  if (svq3_decode_block(&s->gb_slice, &s->mb[16 * 16 * i], 0, 3)) {
987  "error while decoding chroma dc block\n");
988  return -1;
989  }
990 
991  if ((cbp & 0x20)) {
992  for (i = 1; i < 3; i++) {
993  for (j = 0; j < 4; j++) {
994  k = 16 * i + j;
995  s->non_zero_count_cache[scan8[k]] = 1;
996 
997  if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], 1, 1)) {
999  "error while decoding chroma ac block\n");
1000  return -1;
1001  }
1002  }
1003  }
1004  }
1005  }
1006  }
1007 
1008  s->cbp = cbp;
1009  s->cur_pic->mb_type[mb_xy] = mb_type;
1010 
1011  if (IS_INTRA(mb_type))
1014 
1015  return 0;
1016 }
1017 
1019 {
1020  SVQ3Context *s = avctx->priv_data;
1021  const int mb_xy = s->mb_xy;
1022  int i, header;
1023  unsigned slice_id;
1024 
1025  header = get_bits(&s->gb, 8);
1026 
1027  if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
1028  /* TODO: what? */
1029  av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
1030  return -1;
1031  } else {
1032  int slice_bits, slice_bytes, slice_length;
1033  int length = header >> 5 & 3;
1034 
1035  slice_length = show_bits(&s->gb, 8 * length);
1036  slice_bits = slice_length * 8;
1037  slice_bytes = slice_length + length - 1;
1038 
1039  skip_bits(&s->gb, 8);
1040 
1042  if (!s->slice_buf)
1043  return AVERROR(ENOMEM);
1044 
1045  if (slice_bytes * 8LL > get_bits_left(&s->gb)) {
1046  av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1047  return AVERROR_INVALIDDATA;
1048  }
1049  memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
1050 
1051  if (s->watermark_key) {
1052  uint32_t header = AV_RL32(&s->slice_buf[1]);
1053  AV_WL32(&s->slice_buf[1], header ^ s->watermark_key);
1054  }
1055  init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
1056 
1057  if (length > 0) {
1058  memmove(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1059  }
1060  skip_bits_long(&s->gb, slice_bytes * 8);
1061  }
1062 
1063  if ((slice_id = get_interleaved_ue_golomb(&s->gb_slice)) >= 3) {
1064  av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
1065  return -1;
1066  }
1067  if (get_bits1(&s->gb_slice)) {
1068  avpriv_report_missing_feature(s->avctx, "Media key encryption");
1069  return AVERROR_PATCHWELCOME;
1070  }
1071 
1072  s->slice_type = ff_h264_golomb_to_pict_type[slice_id];
1073 
1074  if ((header & 0x9F) == 2) {
1075  i = (s->mb_num < 64) ? 5 : av_log2(s->mb_num - 1);
1076  get_bits(&s->gb_slice, i);
1077  }
1078 
1079  s->slice_num = get_bits(&s->gb_slice, 8);
1080  s->qscale = get_bits(&s->gb_slice, 5);
1081  s->adaptive_quant = get_bits1(&s->gb_slice);
1082 
1083  /* unknown fields */
1084  skip_bits1(&s->gb_slice);
1085 
1086  if (s->has_watermark)
1087  skip_bits1(&s->gb_slice);
1088 
1089  skip_bits1(&s->gb_slice);
1090  skip_bits(&s->gb_slice, 2);
1091 
1092  if (skip_1stop_8data_bits(&s->gb_slice) < 0)
1093  return AVERROR_INVALIDDATA;
1094 
1095  /* reset intra predictors and invalidate motion vector references */
1096  if (s->mb_x > 0) {
1097  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - 1] + 3,
1098  -1, 4 * sizeof(int8_t));
1099  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_x],
1100  -1, 8 * sizeof(int8_t) * s->mb_x);
1101  }
1102  if (s->mb_y > 0) {
1103  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_stride],
1104  -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
1105 
1106  if (s->mb_x > 0)
1107  s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1108  }
1109 
1110  return 0;
1111 }
1112 
1114 {
1115  int q, x;
1116  const int max_qp = 51;
1117 
1118  for (q = 0; q < max_qp + 1; q++) {
1119  int shift = ff_h264_quant_div6[q] + 2;
1120  int idx = ff_h264_quant_rem6[q];
1121  for (x = 0; x < 16; x++)
1122  s->dequant4_coeff[q][(x >> 2) | ((x << 2) & 0xF)] =
1123  ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] * 16) << shift;
1124  }
1125 }
1126 
1128 {
1129  SVQ3Context *s = avctx->priv_data;
1130  int m, x, y;
1131  unsigned char *extradata;
1132  unsigned char *extradata_end;
1133  unsigned int size;
1134  int marker_found = 0;
1135  int ret;
1136 
1137  s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
1138  s->last_pic = av_mallocz(sizeof(*s->last_pic));
1139  s->next_pic = av_mallocz(sizeof(*s->next_pic));
1140  if (!s->next_pic || !s->last_pic || !s->cur_pic) {
1141  ret = AVERROR(ENOMEM);
1142  goto fail;
1143  }
1144 
1145  s->cur_pic->f = av_frame_alloc();
1146  s->last_pic->f = av_frame_alloc();
1147  s->next_pic->f = av_frame_alloc();
1148  if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1149  return AVERROR(ENOMEM);
1150 
1151  ff_h264dsp_init(&s->h264dsp, 8, 1);
1153  ff_videodsp_init(&s->vdsp, 8);
1154 
1155 
1156  avctx->bits_per_raw_sample = 8;
1157 
1158  ff_hpeldsp_init(&s->hdsp, avctx->flags);
1159  ff_tpeldsp_init(&s->tdsp);
1160 
1161  avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1162  avctx->color_range = AVCOL_RANGE_JPEG;
1163 
1164  s->avctx = avctx;
1165  s->halfpel_flag = 1;
1166  s->thirdpel_flag = 1;
1167  s->has_watermark = 0;
1168 
1169  /* prowl for the "SEQH" marker in the extradata */
1170  extradata = (unsigned char *)avctx->extradata;
1171  extradata_end = avctx->extradata + avctx->extradata_size;
1172  if (extradata) {
1173  for (m = 0; m + 8 < avctx->extradata_size; m++) {
1174  if (!memcmp(extradata, "SEQH", 4)) {
1175  marker_found = 1;
1176  break;
1177  }
1178  extradata++;
1179  }
1180  }
1181 
1182  /* if a match was found, parse the extra data */
1183  if (marker_found) {
1184  GetBitContext gb;
1185  int frame_size_code;
1186  int unk0, unk1, unk2, unk3, unk4;
1187 
1188  size = AV_RB32(&extradata[4]);
1189  if (size > extradata_end - extradata - 8) {
1190  ret = AVERROR_INVALIDDATA;
1191  goto fail;
1192  }
1193  init_get_bits(&gb, extradata + 8, size * 8);
1194 
1195  /* 'frame size code' and optional 'width, height' */
1196  frame_size_code = get_bits(&gb, 3);
1197  switch (frame_size_code) {
1198  case 0:
1199  avctx->width = 160;
1200  avctx->height = 120;
1201  break;
1202  case 1:
1203  avctx->width = 128;
1204  avctx->height = 96;
1205  break;
1206  case 2:
1207  avctx->width = 176;
1208  avctx->height = 144;
1209  break;
1210  case 3:
1211  avctx->width = 352;
1212  avctx->height = 288;
1213  break;
1214  case 4:
1215  avctx->width = 704;
1216  avctx->height = 576;
1217  break;
1218  case 5:
1219  avctx->width = 240;
1220  avctx->height = 180;
1221  break;
1222  case 6:
1223  avctx->width = 320;
1224  avctx->height = 240;
1225  break;
1226  case 7:
1227  avctx->width = get_bits(&gb, 12);
1228  avctx->height = get_bits(&gb, 12);
1229  break;
1230  }
1231 
1232  s->halfpel_flag = get_bits1(&gb);
1233  s->thirdpel_flag = get_bits1(&gb);
1234 
1235  /* unknown fields */
1236  unk0 = get_bits1(&gb);
1237  unk1 = get_bits1(&gb);
1238  unk2 = get_bits1(&gb);
1239  unk3 = get_bits1(&gb);
1240 
1241  s->low_delay = get_bits1(&gb);
1242 
1243  /* unknown field */
1244  unk4 = get_bits1(&gb);
1245 
1246  av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1247  unk0, unk1, unk2, unk3, unk4);
1248 
1249  if (skip_1stop_8data_bits(&gb) < 0) {
1250  ret = AVERROR_INVALIDDATA;
1251  goto fail;
1252  }
1253 
1254  s->has_watermark = get_bits1(&gb);
1255  avctx->has_b_frames = !s->low_delay;
1256  if (s->has_watermark) {
1257 #if CONFIG_ZLIB
1258  unsigned watermark_width = get_interleaved_ue_golomb(&gb);
1259  unsigned watermark_height = get_interleaved_ue_golomb(&gb);
1260  int u1 = get_interleaved_ue_golomb(&gb);
1261  int u2 = get_bits(&gb, 8);
1262  int u3 = get_bits(&gb, 2);
1263  int u4 = get_interleaved_ue_golomb(&gb);
1264  unsigned long buf_len = watermark_width *
1265  watermark_height * 4;
1266  int offset = get_bits_count(&gb) + 7 >> 3;
1267  uint8_t *buf;
1268 
1269  if (watermark_height <= 0 ||
1270  (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
1271  ret = -1;
1272  goto fail;
1273  }
1274 
1275  buf = av_malloc(buf_len);
1276  if (!buf) {
1277  ret = AVERROR(ENOMEM);
1278  goto fail;
1279  }
1280  av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1281  watermark_width, watermark_height);
1282  av_log(avctx, AV_LOG_DEBUG,
1283  "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1284  u1, u2, u3, u4, offset);
1285  if (uncompress(buf, &buf_len, extradata + 8 + offset,
1286  size - offset) != Z_OK) {
1287  av_log(avctx, AV_LOG_ERROR,
1288  "could not uncompress watermark logo\n");
1289  av_free(buf);
1290  ret = -1;
1291  goto fail;
1292  }
1293  s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1294  s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1295  av_log(avctx, AV_LOG_DEBUG,
1296  "watermark key %#"PRIx32"\n", s->watermark_key);
1297  av_free(buf);
1298 #else
1299  av_log(avctx, AV_LOG_ERROR,
1300  "this svq3 file contains watermark which need zlib support compiled in\n");
1301  ret = -1;
1302  goto fail;
1303 #endif
1304  }
1305  }
1306 
1307  s->mb_width = (avctx->width + 15) / 16;
1308  s->mb_height = (avctx->height + 15) / 16;
1309  s->mb_stride = s->mb_width + 1;
1310  s->mb_num = s->mb_width * s->mb_height;
1311  s->b_stride = 4 * s->mb_width;
1312  s->h_edge_pos = s->mb_width * 16;
1313  s->v_edge_pos = s->mb_height * 16;
1314 
1315  s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1316  if (!s->intra4x4_pred_mode)
1317  return AVERROR(ENOMEM);
1318 
1319  s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1320  sizeof(*s->mb2br_xy));
1321  if (!s->mb2br_xy)
1322  return AVERROR(ENOMEM);
1323 
1324  for (y = 0; y < s->mb_height; y++)
1325  for (x = 0; x < s->mb_width; x++) {
1326  const int mb_xy = x + y * s->mb_stride;
1327 
1328  s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1329  }
1330 
1332 
1333  return 0;
1334 fail:
1335  svq3_decode_end(avctx);
1336  return ret;
1337 }
1338 
1339 static void free_picture(AVCodecContext *avctx, SVQ3Frame *pic)
1340 {
1341  int i;
1342  for (i = 0; i < 2; i++) {
1343  av_buffer_unref(&pic->motion_val_buf[i]);
1344  av_buffer_unref(&pic->ref_index_buf[i]);
1345  }
1347 
1348  av_frame_unref(pic->f);
1349 }
1350 
1351 static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
1352 {
1353  SVQ3Context *s = avctx->priv_data;
1354  const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
1355  const int mb_array_size = s->mb_stride * s->mb_height;
1356  const int b4_stride = s->mb_width * 4 + 1;
1357  const int b4_array_size = b4_stride * s->mb_height * 4;
1358  int ret;
1359 
1360  if (!pic->motion_val_buf[0]) {
1361  int i;
1362 
1363  pic->mb_type_buf = av_buffer_allocz((big_mb_num + s->mb_stride) * sizeof(uint32_t));
1364  if (!pic->mb_type_buf)
1365  return AVERROR(ENOMEM);
1366  pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
1367 
1368  for (i = 0; i < 2; i++) {
1369  pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1370  pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1371  if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1372  ret = AVERROR(ENOMEM);
1373  goto fail;
1374  }
1375 
1376  pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1377  pic->ref_index[i] = pic->ref_index_buf[i]->data;
1378  }
1379  }
1380 
1381  ret = ff_get_buffer(avctx, pic->f,
1382  (s->pict_type != AV_PICTURE_TYPE_B) ?
1384  if (ret < 0)
1385  goto fail;
1386 
1387  if (!s->edge_emu_buffer) {
1388  s->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1389  if (!s->edge_emu_buffer)
1390  return AVERROR(ENOMEM);
1391  }
1392 
1393  return 0;
1394 fail:
1395  free_picture(avctx, pic);
1396  return ret;
1397 }
1398 
1399 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1400  int *got_frame, AVPacket *avpkt)
1401 {
1402  SVQ3Context *s = avctx->priv_data;
1403  int buf_size = avpkt->size;
1404  int left;
1405  uint8_t *buf;
1406  int ret, m, i;
1407 
1408  /* special case for last picture */
1409  if (buf_size == 0) {
1410  if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1411  ret = av_frame_ref(data, s->next_pic->f);
1412  if (ret < 0)
1413  return ret;
1414  s->last_frame_output = 1;
1415  *got_frame = 1;
1416  }
1417  return 0;
1418  }
1419 
1420  s->mb_x = s->mb_y = s->mb_xy = 0;
1421 
1422  if (s->watermark_key) {
1423  av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1424  if (!s->buf)
1425  return AVERROR(ENOMEM);
1426  memcpy(s->buf, avpkt->data, buf_size);
1427  buf = s->buf;
1428  } else {
1429  buf = avpkt->data;
1430  }
1431 
1432  ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1433  if (ret < 0)
1434  return ret;
1435 
1436  if (svq3_decode_slice_header(avctx))
1437  return -1;
1438 
1439  s->pict_type = s->slice_type;
1440 
1441  if (s->pict_type != AV_PICTURE_TYPE_B)
1442  FFSWAP(SVQ3Frame*, s->next_pic, s->last_pic);
1443 
1444  av_frame_unref(s->cur_pic->f);
1445 
1446  /* for skipping the frame */
1447  s->cur_pic->f->pict_type = s->pict_type;
1449 
1450  ret = get_buffer(avctx, s->cur_pic);
1451  if (ret < 0)
1452  return ret;
1453 
1454  for (i = 0; i < 16; i++) {
1455  s->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1456  s->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1457  }
1458  for (i = 0; i < 16; i++) {
1459  s->block_offset[16 + i] =
1460  s->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1461  s->block_offset[48 + 16 + i] =
1462  s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1463  }
1464 
1465  if (s->pict_type != AV_PICTURE_TYPE_I) {
1466  if (!s->last_pic->f->data[0]) {
1467  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1468  av_frame_unref(s->last_pic->f);
1469  ret = get_buffer(avctx, s->last_pic);
1470  if (ret < 0)
1471  return ret;
1472  memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1473  memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1474  s->last_pic->f->linesize[1]);
1475  memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1476  s->last_pic->f->linesize[2]);
1477  }
1478 
1479  if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1480  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1481  av_frame_unref(s->next_pic->f);
1482  ret = get_buffer(avctx, s->next_pic);
1483  if (ret < 0)
1484  return ret;
1485  memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1486  memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1487  s->next_pic->f->linesize[1]);
1488  memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1489  s->next_pic->f->linesize[2]);
1490  }
1491  }
1492 
1493  if (avctx->debug & FF_DEBUG_PICT_INFO)
1495  "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1497  s->halfpel_flag, s->thirdpel_flag,
1498  s->adaptive_quant, s->qscale, s->slice_num);
1499 
1500  if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1502  avctx->skip_frame >= AVDISCARD_ALL)
1503  return 0;
1504 
1505  if (s->next_p_frame_damaged) {
1506  if (s->pict_type == AV_PICTURE_TYPE_B)
1507  return 0;
1508  else
1509  s->next_p_frame_damaged = 0;
1510  }
1511 
1512  if (s->pict_type == AV_PICTURE_TYPE_B) {
1514 
1515  if (s->frame_num_offset < 0)
1516  s->frame_num_offset += 256;
1517  if (s->frame_num_offset == 0 ||
1519  av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1520  return -1;
1521  }
1522  } else {
1523  s->prev_frame_num = s->frame_num;
1524  s->frame_num = s->slice_num;
1526 
1527  if (s->prev_frame_num_offset < 0)
1528  s->prev_frame_num_offset += 256;
1529  }
1530 
1531  for (m = 0; m < 2; m++) {
1532  int i;
1533  for (i = 0; i < 4; i++) {
1534  int j;
1535  for (j = -1; j < 4; j++)
1536  s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1537  if (i < 3)
1538  s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1539  }
1540  }
1541 
1542  for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1543  for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1544  unsigned mb_type;
1545  s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1546 
1547  if ((get_bits_left(&s->gb_slice)) <= 7) {
1548  if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1549  show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1550 
1551  if (svq3_decode_slice_header(avctx))
1552  return -1;
1553  }
1554  if (s->slice_type != s->pict_type) {
1555  avpriv_request_sample(avctx, "non constant slice type");
1556  }
1557  /* TODO: support s->mb_skip_run */
1558  }
1559 
1560  mb_type = get_interleaved_ue_golomb(&s->gb_slice);
1561 
1562  if (s->pict_type == AV_PICTURE_TYPE_I)
1563  mb_type += 8;
1564  else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1565  mb_type += 4;
1566  if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1568  "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1569  return -1;
1570  }
1571 
1572  if (mb_type != 0 || s->cbp)
1573  hl_decode_mb(s);
1574 
1575  if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1576  s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1577  (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1578  }
1579 
1580  ff_draw_horiz_band(avctx, s->cur_pic->f,
1581  s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1582  16 * s->mb_y, 16, PICT_FRAME, 0,
1583  s->low_delay);
1584  }
1585 
1586  left = buf_size*8 - get_bits_count(&s->gb_slice);
1587 
1588  if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1589  av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, s->mb_y, s->mb_x, left);
1590  //av_hex_dump(stderr, buf+buf_size-8, 8);
1591  }
1592 
1593  if (left < 0) {
1594  av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1595  return -1;
1596  }
1597 
1598  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1599  ret = av_frame_ref(data, s->cur_pic->f);
1600  else if (s->last_pic->f->data[0])
1601  ret = av_frame_ref(data, s->last_pic->f);
1602  if (ret < 0)
1603  return ret;
1604 
1605  /* Do not output the last pic after seeking. */
1606  if (s->last_pic->f->data[0] || s->low_delay)
1607  *got_frame = 1;
1608 
1609  if (s->pict_type != AV_PICTURE_TYPE_B) {
1610  FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1611  } else {
1612  av_frame_unref(s->cur_pic->f);
1613  }
1614 
1615  return buf_size;
1616 }
1617 
1619 {
1620  SVQ3Context *s = avctx->priv_data;
1621 
1622  free_picture(avctx, s->cur_pic);
1623  free_picture(avctx, s->next_pic);
1624  free_picture(avctx, s->last_pic);
1625  av_frame_free(&s->cur_pic->f);
1626  av_frame_free(&s->next_pic->f);
1627  av_frame_free(&s->last_pic->f);
1628  av_freep(&s->cur_pic);
1629  av_freep(&s->next_pic);
1630  av_freep(&s->last_pic);
1631  av_freep(&s->slice_buf);
1634  av_freep(&s->mb2br_xy);
1635 
1636 
1637  av_freep(&s->buf);
1638  s->buf_size = 0;
1639 
1640  return 0;
1641 }
1642 
1644  .name = "svq3",
1645  .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1646  .type = AVMEDIA_TYPE_VIDEO,
1647  .id = AV_CODEC_ID_SVQ3,
1648  .priv_data_size = sizeof(SVQ3Context),
1650  .close = svq3_decode_end,
1652  .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1655  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1656  AV_PIX_FMT_NONE},
1657 };
uint8_t pred_mode
Definition: h264data.h:35
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
#define NULL
Definition: coverity.c:32
discard all frames except keyframes
Definition: avcodec.h:793
void(* h264_chroma_dc_dequant_idct)(int16_t *block, int qmul)
Definition: h264dsp.h:104
const char * s
Definition: avisynth_c.h:768
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int cbp
Definition: svq3.c:111
static int shift(int a, int b)
Definition: sonic.c:82
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
int size
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
#define C
HpelDSPContext hdsp
Definition: svq3.c:87
op_pixels_func avg_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:68
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:269
uint16_t ff_svq1_packet_checksum(const uint8_t *data, const int length, int value)
Definition: svq13.c:60
static int svq3_decode_block(GetBitContext *gb, int16_t *block, int index, const int type)
Definition: svq3.c:299
else temp
Definition: vf_mcdeint.c:256
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:212
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int prev_frame_num
Definition: svq3.c:115
static av_always_inline void svq3_pred_motion(const SVQ3Context *s, int n, int part_width, int list, int ref, int *const mx, int *const my)
Get the predicted MV.
Definition: svq3.c:380
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2148
int size
Definition: avcodec.h:1431
int mb_xy
Definition: svq3.c:122
const uint8_t * buffer
Definition: get_bits.h:57
uint8_t * slice_buf
Definition: svq3.c:96
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1727
av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, int chroma_format_idc)
Set the intra prediction function pointers.
Definition: h264pred.c:411
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
int v_edge_pos
Definition: svq3.c:107
const uint8_t ff_h264_quant_rem6[QP_MAX_NUM+1]
Definition: h264data.c:174
discard all
Definition: avcodec.h:794
void(* prefetch)(uint8_t *buf, ptrdiff_t stride, int h)
Prefetch memory into cache (if supported by hardware).
Definition: videodsp.h:76
uint8_t run
Definition: svq3.c:206
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2741
#define src
Definition: vp8dsp.c:254
#define FULLPEL_MODE
Definition: svq3.c:150
void ff_draw_horiz_band(AVCodecContext *avctx, AVFrame *cur, AVFrame *last, int y, int h, int picture_structure, int first_field, int low_delay)
Draw a horizontal band if supported.
Definition: mpegutils.c:51
AVCodec.
Definition: avcodec.h:3408
#define MB_TYPE_INTRA4x4
Definition: mpegutils.h:51
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
#define AV_COPY32(d, s)
Definition: intreadwrite.h:586
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
int16_t mb[16 *48 *2]
Definition: svq3.c:143
Macro definitions for various function/variable attributes.
static int svq3_mc_dir(SVQ3Context *s, int size, int mode, int dir, int avg)
Definition: svq3.c:504
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2975
static int16_t block[64]
Definition: dct.c:115
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:984
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
int has_watermark
Definition: svq3.c:100
int thirdpel_flag
Definition: svq3.c:99
#define MB_TYPE_INTRA16x16
Definition: mpegutils.h:52
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
int mb_num
Definition: svq3.c:124
const uint8_t ff_h264_dequant4_coeff_init[6][3]
Definition: h264data.c:152
static const uint8_t luma_dc_zigzag_scan[16]
Definition: svq3.c:171
uint8_t
static av_always_inline void hl_decode_mb_idct_luma(SVQ3Context *s, int mb_type, const int *block_offset, int linesize, uint8_t *dest_y)
Definition: svq3.c:617
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
#define mb
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
#define DC_PRED8x8
Definition: h264pred.h:68
int block_offset[2 *(16 *3)]
Definition: svq3.c:147
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2599
#define AV_RB32
Definition: intreadwrite.h:130
static av_always_inline int svq3_fetch_diagonal_mv(const SVQ3Context *s, const int16_t **C, int i, int list, int part_width)
Definition: svq3.c:359
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:441
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1618
#define MB_TYPE_16x16
Definition: mpegutils.h:54
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:344
const uint8_t ff_h264_chroma_dc_scan[4]
Definition: h264data.c:54
Context for storing H.264 prediction functions.
Definition: h264pred.h:92
void(* pred8x8[4+3+4])(uint8_t *src, ptrdiff_t stride)
Definition: h264pred.h:97
const char data[16]
Definition: mxf.c:90
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
#define height
uint8_t * data
Definition: avcodec.h:1430
thirdpel DSP context
Definition: tpeldsp.h:42
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:200
const IMbInfo ff_h264_i_mb_type_info[26]
Definition: h264data.c:66
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:88
AVBufferRef * ref_index_buf[2]
Definition: svq3.c:78
const uint8_t ff_h264_golomb_to_inter_cbp[48]
Definition: h264data.c:48
int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx, int top_samples_available, int left_samples_available)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
Definition: h264_parse.c:131
thirdpel DSP functions
static const uint8_t header[24]
Definition: sdr2.c:67
enum AVPictureType slice_type
Definition: svq3.c:118
void(* pred4x4[9+3+3])(uint8_t *src, const uint8_t *topright, ptrdiff_t stride)
Definition: h264pred.h:93
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:861
#define A(x)
Definition: vp56_arith.h:28
#define av_log(a,...)
int prev_frame_num_offset
Definition: svq3.c:114
int low_delay
Definition: svq3.c:119
static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
Definition: svq3.c:719
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:596
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1807
#define HALFPEL_MODE
Definition: svq3.c:151
AVCodecContext * avctx
Definition: svq3.c:83
int8_t * intra4x4_pred_mode
Definition: svq3.c:133
#define AVERROR(e)
Definition: error.h:43
uint8_t * edge_emu_buffer
Definition: svq3.c:139
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define B
Definition: huffyuvdsp.h:32
av_cold void ff_tpeldsp_init(TpelDSPContext *c)
Definition: tpeldsp.c:312
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
const uint8_t ff_zigzag_scan[16+1]
Definition: mathtables.c:109
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1598
uint16_t width
Definition: gdv.c:47
int frame_num
Definition: svq3.c:112
int mb_x
Definition: svq3.c:121
static int get_interleaved_se_golomb(GetBitContext *gb)
Definition: golomb.h:222
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static const struct @124 svq3_dct_tables[2][16]
unsigned int left_samples_available
Definition: svq3.c:137
const char * name
Name of the codec implementation.
Definition: avcodec.h:3415
#define IS_SKIP(a)
Definition: mpegutils.h:81
int chroma_pred_mode
Definition: svq3.c:129
const uint8_t ff_h264_golomb_to_pict_type[5]
Definition: h264data.c:37
#define PREDICT_MODE
Definition: svq3.c:153
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define fail()
Definition: checkasm.h:116
unsigned int topright_samples_available
Definition: svq3.c:136
Sorenson Vector Quantizer #1 (SVQ1) video codec.
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:488
Definition: svq3.c:68
useful rectangle filling function
AVBufferRef * motion_val_buf[2]
Definition: svq3.c:71
tpel_mc_func avg_tpel_pixels_tab[11]
Definition: tpeldsp.h:54
Half-pel DSP context.
Definition: hpeldsp.h:45
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: avcodec.h:953
SVQ3Frame * cur_pic
Definition: svq3.c:91
Context for storing H.264 DSP functions.
Definition: h264dsp.h:42
uint32_t dequant4_coeff[QP_MAX_NUM+1][16]
Definition: svq3.c:146
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:301
int16_t(*[2] motion_val)[2]
Definition: svq3.c:72
#define FFMIN(a, b)
Definition: common.h:96
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:74
int width
picture width / height.
Definition: avcodec.h:1690
int32_t
GetBitContext gb_slice
Definition: svq3.c:95
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:304
static av_cold int svq3_decode_init(AVCodecContext *avctx)
Definition: svq3.c:1127
tpel_mc_func put_tpel_pixels_tab[11]
Thirdpel motion compensation with rounding (a + b + 1) >> 1.
Definition: tpeldsp.h:53
H.264 / AVC / MPEG-4 part10 codec.
int b_stride
Definition: svq3.c:125
#define AV_RL32
Definition: intreadwrite.h:146
H264PredContext hpc
Definition: svq3.c:86
int n
Definition: avisynth_c.h:684
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:822
if(ret< 0)
Definition: vf_mcdeint.c:279
int last_frame_output
Definition: svq3.c:108
int next_p_frame_damaged
Definition: svq3.c:105
#define av_log2
Definition: intmath.h:83
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:499
#define IS_INTRA16x16(a)
Definition: mpegutils.h:76
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static const int8_t mv[256][2]
Definition: 4xm.c:77
H264DSPContext h264dsp
Definition: svq3.c:85
Half-pel DSP functions.
AVCodec ff_svq3_decoder
Definition: svq3.c:1643
GetBitContext gb
Definition: svq3.c:94
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:249
int debug
debug
Definition: avcodec.h:2598
int intra16x16_pred_mode
Definition: svq3.c:130
main external API structure.
Definition: avcodec.h:1518
const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1]
Definition: h264data.c:203
uint8_t * data
The data buffer.
Definition: buffer.h:89
#define QP_MAX_NUM
Definition: h264.h:27
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1891
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
void * buf
Definition: avisynth_c.h:690
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:644
int extradata_size
Definition: avcodec.h:1619
void(* pred16x16[4+3+2])(uint8_t *src, ptrdiff_t stride)
Definition: h264pred.h:98
int qscale
Definition: svq3.c:110
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
AVBufferRef * mb_type_buf
Definition: svq3.c:74
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:321
const uint8_t ff_h264_golomb_to_intra4x4_cbp[48]
Definition: h264data.c:42
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:346
int mb_height
Definition: svq3.c:123
enum AVPictureType pict_type
Definition: svq3.c:117
const uint8_t ff_h264_quant_div6[QP_MAX_NUM+1]
Definition: h264data.c:182
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:314
int index
Definition: gxfenc.c:89
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264dec.h:660
static void svq3_mc_dir_part(SVQ3Context *s, int x, int y, int width, int height, int mx, int my, int dxy, int thirdpel, int dir, int avg)
Definition: svq3.c:429
uint32_t * mb_type
Definition: svq3.c:75
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:433
static void init_dequant4_coeff_table(SVQ3Context *s)
Definition: svq3.c:1113
cl_device_type type
static int svq3_decode_end(AVCodecContext *avctx)
Definition: svq3.c:1618
#define mid_pred
Definition: mathops.h:97
int8_t ref_cache[2][5 *8]
Definition: svq3.c:142
static const uint8_t svq3_pred_0[25][2]
Definition: svq3.c:178
int mb_y
Definition: svq3.c:121
AVPictureType
Definition: avutil.h:272
#define IS_INTER(a)
Definition: mpegutils.h:79
int slice_num
Definition: svq3.c:109
AVFrame * f
Definition: svq3.c:69
#define MB_TYPE_SKIP
Definition: mpegutils.h:62
uint8_t * buf
Definition: svq3.c:102
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
SVQ3Frame * last_pic
Definition: svq3.c:93
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
VideoDSPContext vdsp
Definition: svq3.c:89
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:551
static void free_picture(AVCodecContext *avctx, SVQ3Frame *pic)
Definition: svq3.c:1339
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint32_t * mb2br_xy
Definition: svq3.c:127
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
uint8_t level
Definition: svq3.c:207
Definition: vp9.h:48
#define AV_ZERO128(d)
Definition: intreadwrite.h:622
A reference to a data buffer.
Definition: buffer.h:81
#define avg(a, b, c, d)
discard all non reference
Definition: avcodec.h:790
int
static av_always_inline void hl_decode_mb_predict_luma(SVQ3Context *s, int mb_type, const int *block_offset, int linesize, uint8_t *dest_y)
Definition: svq3.c:632
uint8_t non_zero_count_cache[15 *8]
Definition: svq3.c:145
uint8_t cbp
Definition: h264data.h:36
common internal api header.
static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
Definition: svq3.c:1351
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int mb_stride
Definition: svq3.c:124
int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available, int left_samples_available, int mode, int is_chroma)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
Definition: h264_parse.c:179
int16_t mb_luma_dc[3][16 *2]
Definition: svq3.c:144
int h_edge_pos
Definition: svq3.c:106
Bi-dir predicted.
Definition: avutil.h:276
static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
Definition: svq3.c:224
#define stride
int frame_num_offset
Definition: svq3.c:113
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:773
#define IS_INTRA(x, y)
static const uint32_t svq3_dequant_coeff[32]
Definition: svq3.c:215
void * priv_data
Definition: avcodec.h:1545
#define THIRDPEL_MODE
Definition: svq3.c:152
#define PICT_FRAME
Definition: mpegutils.h:39
unsigned int top_samples_available
Definition: svq3.c:135
#define IS_INTRA4x4(a)
Definition: mpegutils.h:75
#define av_free(p)
static void hl_decode_mb(SVQ3Context *s)
Definition: svq3.c:671
static int svq3_decode_slice_header(AVCodecContext *avctx)
Definition: svq3.c:1018
#define PART_NOT_AVAILABLE
Definition: h264dec.h:391
int slice_size
Definition: svq3.c:97
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:296
#define AV_ZERO32(d)
Definition: intreadwrite.h:614
TpelDSPContext tdsp
Definition: svq3.c:88
static const uint8_t svq3_scan[16]
Definition: svq3.c:164
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: svq3.c:132
int mb_width
Definition: svq3.c:123
av_cold void ff_h264dsp_init(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)
Definition: h264dsp.c:67
static const int8_t svq3_pred_1[6][6][5]
Definition: svq3.c:190
static void svq3_add_idct_c(uint8_t *dst, int16_t *block, int stride, int qp, int dc)
Definition: svq3.c:259
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2204
#define av_freep(p)
uint32_t watermark_key
Definition: svq3.c:101
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:601
#define av_always_inline
Definition: attributes.h:39
SVQ3Frame * next_pic
Definition: svq3.c:92
#define FFSWAP(type, a, b)
Definition: common.h:99
const char int length
Definition: avisynth_c.h:768
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
Definition: golomb.h:115
int buf_size
Definition: svq3.c:103
exp golomb vlc stuff
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1407
static int svq3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: svq3.c:1399
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1135
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:959
for(j=16;j >0;--j)
Predicted.
Definition: avutil.h:275
int halfpel_flag
Definition: svq3.c:98
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
int adaptive_quant
Definition: svq3.c:104
int8_t * ref_index[2]
Definition: svq3.c:79
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:191
int16_t mv_cache[2][5 *8][2]
Definition: svq3.c:141