FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 
120 
121  int mb_x, mb_y;
122  int mb_xy;
125  int b_stride;
126 
127  uint32_t *mb2br_xy;
128 
131 
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];
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 int 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] = (z0 + z3) * qmul + 0x80000 >> 20;
252  output[stride * 2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
253  output[stride * 8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
254  output[stride * 10 + offset] = (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 ? 1538 * 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 int z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
285  const int z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
286  const int z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
287  const int z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
288  const int rr = (dc + 0x80000);
289 
290  dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
291  dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
292  dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
293  dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((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] << 1;
528  my = s->next_pic->motion_val[0][b_xy][1] << 1;
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 == INVALID_VLC || dy == INVALID_VLC) {
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 + 0x3000) / 3 - 0x1000;
566  fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
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 + 0x3000) / 3 + dx - 0x1000;
575  my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
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 + 0x6000) / 6 + dx - 0x1000;
584  my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
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  if (8LL*slice_bytes > get_bits_left(&s->gb)) {
1040  av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1041  return -1;
1042  }
1043 
1044  skip_bits(&s->gb, 8);
1045 
1047  if (!s->slice_buf)
1048  return AVERROR(ENOMEM);
1049 
1050  memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
1051 
1052  init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
1053 
1054  if (s->watermark_key) {
1055  uint32_t header = AV_RL32(&s->gb_slice.buffer[1]);
1056  AV_WL32(&s->gb_slice.buffer[1], header ^ s->watermark_key);
1057  }
1058  if (length > 0) {
1059  memmove(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1060  }
1061  skip_bits_long(&s->gb, slice_bytes * 8);
1062  }
1063 
1064  if ((slice_id = get_interleaved_ue_golomb(&s->gb_slice)) >= 3) {
1065  av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
1066  return -1;
1067  }
1068  if (get_bits1(&s->gb_slice)) {
1069  avpriv_report_missing_feature(s->avctx, "Media key encryption");
1070  return AVERROR_PATCHWELCOME;
1071  }
1072 
1073  s->slice_type = ff_h264_golomb_to_pict_type[slice_id];
1074 
1075  if ((header & 0x9F) == 2) {
1076  i = (s->mb_num < 64) ? 5 : av_log2(s->mb_num - 1);
1077  get_bits(&s->gb_slice, i);
1078  }
1079 
1080  s->slice_num = get_bits(&s->gb_slice, 8);
1081  s->qscale = get_bits(&s->gb_slice, 5);
1082  s->adaptive_quant = get_bits1(&s->gb_slice);
1083 
1084  /* unknown fields */
1085  skip_bits1(&s->gb_slice);
1086 
1087  if (s->has_watermark)
1088  skip_bits1(&s->gb_slice);
1089 
1090  skip_bits1(&s->gb_slice);
1091  skip_bits(&s->gb_slice, 2);
1092 
1093  if (skip_1stop_8data_bits(&s->gb_slice) < 0)
1094  return AVERROR_INVALIDDATA;
1095 
1096  /* reset intra predictors and invalidate motion vector references */
1097  if (s->mb_x > 0) {
1098  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - 1] + 3,
1099  -1, 4 * sizeof(int8_t));
1100  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_x],
1101  -1, 8 * sizeof(int8_t) * s->mb_x);
1102  }
1103  if (s->mb_y > 0) {
1104  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_stride],
1105  -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
1106 
1107  if (s->mb_x > 0)
1108  s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1109  }
1110 
1111  return 0;
1112 }
1113 
1115 {
1116  int q, x;
1117  const int max_qp = 51;
1118 
1119  for (q = 0; q < max_qp + 1; q++) {
1120  int shift = ff_h264_quant_div6[q] + 2;
1121  int idx = ff_h264_quant_rem6[q];
1122  for (x = 0; x < 16; x++)
1123  s->dequant4_coeff[q][(x >> 2) | ((x << 2) & 0xF)] =
1124  ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] * 16) << shift;
1125  }
1126 }
1127 
1129 {
1130  SVQ3Context *s = avctx->priv_data;
1131  int m, x, y;
1132  unsigned char *extradata;
1133  unsigned char *extradata_end;
1134  unsigned int size;
1135  int marker_found = 0;
1136  int ret;
1137 
1138  s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
1139  s->last_pic = av_mallocz(sizeof(*s->last_pic));
1140  s->next_pic = av_mallocz(sizeof(*s->next_pic));
1141  if (!s->next_pic || !s->last_pic || !s->cur_pic) {
1142  ret = AVERROR(ENOMEM);
1143  goto fail;
1144  }
1145 
1146  s->cur_pic->f = av_frame_alloc();
1147  s->last_pic->f = av_frame_alloc();
1148  s->next_pic->f = av_frame_alloc();
1149  if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1150  return AVERROR(ENOMEM);
1151 
1152  ff_h264dsp_init(&s->h264dsp, 8, 1);
1154  ff_videodsp_init(&s->vdsp, 8);
1155 
1156 
1157  avctx->bits_per_raw_sample = 8;
1158 
1159  ff_hpeldsp_init(&s->hdsp, avctx->flags);
1160  ff_tpeldsp_init(&s->tdsp);
1161 
1162  avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1163  avctx->color_range = AVCOL_RANGE_JPEG;
1164 
1165  s->avctx = avctx;
1166  s->halfpel_flag = 1;
1167  s->thirdpel_flag = 1;
1168  s->has_watermark = 0;
1169 
1170  /* prowl for the "SEQH" marker in the extradata */
1171  extradata = (unsigned char *)avctx->extradata;
1172  extradata_end = avctx->extradata + avctx->extradata_size;
1173  if (extradata) {
1174  for (m = 0; m + 8 < avctx->extradata_size; m++) {
1175  if (!memcmp(extradata, "SEQH", 4)) {
1176  marker_found = 1;
1177  break;
1178  }
1179  extradata++;
1180  }
1181  }
1182 
1183  /* if a match was found, parse the extra data */
1184  if (marker_found) {
1185  GetBitContext gb;
1186  int frame_size_code;
1187  int unk0, unk1, unk2, unk3, unk4;
1188 
1189  size = AV_RB32(&extradata[4]);
1190  if (size > extradata_end - extradata - 8) {
1191  ret = AVERROR_INVALIDDATA;
1192  goto fail;
1193  }
1194  init_get_bits(&gb, extradata + 8, size * 8);
1195 
1196  /* 'frame size code' and optional 'width, height' */
1197  frame_size_code = get_bits(&gb, 3);
1198  switch (frame_size_code) {
1199  case 0:
1200  avctx->width = 160;
1201  avctx->height = 120;
1202  break;
1203  case 1:
1204  avctx->width = 128;
1205  avctx->height = 96;
1206  break;
1207  case 2:
1208  avctx->width = 176;
1209  avctx->height = 144;
1210  break;
1211  case 3:
1212  avctx->width = 352;
1213  avctx->height = 288;
1214  break;
1215  case 4:
1216  avctx->width = 704;
1217  avctx->height = 576;
1218  break;
1219  case 5:
1220  avctx->width = 240;
1221  avctx->height = 180;
1222  break;
1223  case 6:
1224  avctx->width = 320;
1225  avctx->height = 240;
1226  break;
1227  case 7:
1228  avctx->width = get_bits(&gb, 12);
1229  avctx->height = get_bits(&gb, 12);
1230  break;
1231  }
1232 
1233  s->halfpel_flag = get_bits1(&gb);
1234  s->thirdpel_flag = get_bits1(&gb);
1235 
1236  /* unknown fields */
1237  unk0 = get_bits1(&gb);
1238  unk1 = get_bits1(&gb);
1239  unk2 = get_bits1(&gb);
1240  unk3 = get_bits1(&gb);
1241 
1242  s->low_delay = get_bits1(&gb);
1243 
1244  /* unknown field */
1245  unk4 = get_bits1(&gb);
1246 
1247  av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1248  unk0, unk1, unk2, unk3, unk4);
1249 
1250  if (skip_1stop_8data_bits(&gb) < 0) {
1251  ret = AVERROR_INVALIDDATA;
1252  goto fail;
1253  }
1254 
1255  s->has_watermark = get_bits1(&gb);
1256  avctx->has_b_frames = !s->low_delay;
1257  if (s->has_watermark) {
1258 #if CONFIG_ZLIB
1259  unsigned watermark_width = get_interleaved_ue_golomb(&gb);
1260  unsigned watermark_height = get_interleaved_ue_golomb(&gb);
1261  int u1 = get_interleaved_ue_golomb(&gb);
1262  int u2 = get_bits(&gb, 8);
1263  int u3 = get_bits(&gb, 2);
1264  int u4 = get_interleaved_ue_golomb(&gb);
1265  unsigned long buf_len = watermark_width *
1266  watermark_height * 4;
1267  int offset = get_bits_count(&gb) + 7 >> 3;
1268  uint8_t *buf;
1269 
1270  if (watermark_height <= 0 ||
1271  (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
1272  ret = -1;
1273  goto fail;
1274  }
1275 
1276  buf = av_malloc(buf_len);
1277  if (!buf) {
1278  ret = AVERROR(ENOMEM);
1279  goto fail;
1280  }
1281  av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1282  watermark_width, watermark_height);
1283  av_log(avctx, AV_LOG_DEBUG,
1284  "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1285  u1, u2, u3, u4, offset);
1286  if (uncompress(buf, &buf_len, extradata + 8 + offset,
1287  size - offset) != Z_OK) {
1288  av_log(avctx, AV_LOG_ERROR,
1289  "could not uncompress watermark logo\n");
1290  av_free(buf);
1291  ret = -1;
1292  goto fail;
1293  }
1294  s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1295  s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1296  av_log(avctx, AV_LOG_DEBUG,
1297  "watermark key %#"PRIx32"\n", s->watermark_key);
1298  av_free(buf);
1299 #else
1300  av_log(avctx, AV_LOG_ERROR,
1301  "this svq3 file contains watermark which need zlib support compiled in\n");
1302  ret = -1;
1303  goto fail;
1304 #endif
1305  }
1306  }
1307 
1308  s->mb_width = (avctx->width + 15) / 16;
1309  s->mb_height = (avctx->height + 15) / 16;
1310  s->mb_stride = s->mb_width + 1;
1311  s->mb_num = s->mb_width * s->mb_height;
1312  s->b_stride = 4 * s->mb_width;
1313  s->h_edge_pos = s->mb_width * 16;
1314  s->v_edge_pos = s->mb_height * 16;
1315 
1316  s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1317  if (!s->intra4x4_pred_mode)
1318  return AVERROR(ENOMEM);
1319 
1320  s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1321  sizeof(*s->mb2br_xy));
1322  if (!s->mb2br_xy)
1323  return AVERROR(ENOMEM);
1324 
1325  for (y = 0; y < s->mb_height; y++)
1326  for (x = 0; x < s->mb_width; x++) {
1327  const int mb_xy = x + y * s->mb_stride;
1328 
1329  s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1330  }
1331 
1333 
1334  return 0;
1335 fail:
1336  svq3_decode_end(avctx);
1337  return ret;
1338 }
1339 
1340 static void free_picture(AVCodecContext *avctx, SVQ3Frame *pic)
1341 {
1342  int i;
1343  for (i = 0; i < 2; i++) {
1344  av_buffer_unref(&pic->motion_val_buf[i]);
1345  av_buffer_unref(&pic->ref_index_buf[i]);
1346  }
1348 
1349  av_frame_unref(pic->f);
1350 }
1351 
1352 static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
1353 {
1354  SVQ3Context *s = avctx->priv_data;
1355  const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
1356  const int mb_array_size = s->mb_stride * s->mb_height;
1357  const int b4_stride = s->mb_width * 4 + 1;
1358  const int b4_array_size = b4_stride * s->mb_height * 4;
1359  int ret;
1360 
1361  if (!pic->motion_val_buf[0]) {
1362  int i;
1363 
1364  pic->mb_type_buf = av_buffer_allocz((big_mb_num + s->mb_stride) * sizeof(uint32_t));
1365  if (!pic->mb_type_buf)
1366  return AVERROR(ENOMEM);
1367  pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
1368 
1369  for (i = 0; i < 2; i++) {
1370  pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1371  pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1372  if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1373  ret = AVERROR(ENOMEM);
1374  goto fail;
1375  }
1376 
1377  pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1378  pic->ref_index[i] = pic->ref_index_buf[i]->data;
1379  }
1380  }
1381 
1382  ret = ff_get_buffer(avctx, pic->f,
1383  (s->pict_type != AV_PICTURE_TYPE_B) ?
1385  if (ret < 0)
1386  goto fail;
1387 
1388  if (!s->edge_emu_buffer) {
1389  s->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1390  if (!s->edge_emu_buffer)
1391  return AVERROR(ENOMEM);
1392  }
1393 
1394  return 0;
1395 fail:
1396  free_picture(avctx, pic);
1397  return ret;
1398 }
1399 
1400 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1401  int *got_frame, AVPacket *avpkt)
1402 {
1403  SVQ3Context *s = avctx->priv_data;
1404  int buf_size = avpkt->size;
1405  int left;
1406  uint8_t *buf;
1407  int ret, m, i;
1408 
1409  /* special case for last picture */
1410  if (buf_size == 0) {
1411  if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1412  ret = av_frame_ref(data, s->next_pic->f);
1413  if (ret < 0)
1414  return ret;
1415  s->last_frame_output = 1;
1416  *got_frame = 1;
1417  }
1418  return 0;
1419  }
1420 
1421  s->mb_x = s->mb_y = s->mb_xy = 0;
1422 
1423  if (s->watermark_key) {
1424  av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1425  if (!s->buf)
1426  return AVERROR(ENOMEM);
1427  memcpy(s->buf, avpkt->data, buf_size);
1428  buf = s->buf;
1429  } else {
1430  buf = avpkt->data;
1431  }
1432 
1433  ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1434  if (ret < 0)
1435  return ret;
1436 
1437  if (svq3_decode_slice_header(avctx))
1438  return -1;
1439 
1440  s->pict_type = s->slice_type;
1441 
1442  if (s->pict_type != AV_PICTURE_TYPE_B)
1443  FFSWAP(SVQ3Frame*, s->next_pic, s->last_pic);
1444 
1445  av_frame_unref(s->cur_pic->f);
1446 
1447  /* for skipping the frame */
1448  s->cur_pic->f->pict_type = s->pict_type;
1450 
1451  ret = get_buffer(avctx, s->cur_pic);
1452  if (ret < 0)
1453  return ret;
1454 
1455  for (i = 0; i < 16; i++) {
1456  s->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1457  s->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1458  }
1459  for (i = 0; i < 16; i++) {
1460  s->block_offset[16 + i] =
1461  s->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1462  s->block_offset[48 + 16 + i] =
1463  s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1464  }
1465 
1466  if (s->pict_type != AV_PICTURE_TYPE_I) {
1467  if (!s->last_pic->f->data[0]) {
1468  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1469  av_frame_unref(s->last_pic->f);
1470  ret = get_buffer(avctx, s->last_pic);
1471  if (ret < 0)
1472  return ret;
1473  memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1474  memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1475  s->last_pic->f->linesize[1]);
1476  memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1477  s->last_pic->f->linesize[2]);
1478  }
1479 
1480  if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1481  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1482  av_frame_unref(s->next_pic->f);
1483  ret = get_buffer(avctx, s->next_pic);
1484  if (ret < 0)
1485  return ret;
1486  memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1487  memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1488  s->next_pic->f->linesize[1]);
1489  memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1490  s->next_pic->f->linesize[2]);
1491  }
1492  }
1493 
1494  if (avctx->debug & FF_DEBUG_PICT_INFO)
1496  "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1498  s->halfpel_flag, s->thirdpel_flag,
1499  s->adaptive_quant, s->qscale, s->slice_num);
1500 
1501  if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1503  avctx->skip_frame >= AVDISCARD_ALL)
1504  return 0;
1505 
1506  if (s->next_p_frame_damaged) {
1507  if (s->pict_type == AV_PICTURE_TYPE_B)
1508  return 0;
1509  else
1510  s->next_p_frame_damaged = 0;
1511  }
1512 
1513  if (s->pict_type == AV_PICTURE_TYPE_B) {
1515 
1516  if (s->frame_num_offset < 0)
1517  s->frame_num_offset += 256;
1518  if (s->frame_num_offset == 0 ||
1520  av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1521  return -1;
1522  }
1523  } else {
1524  s->prev_frame_num = s->frame_num;
1525  s->frame_num = s->slice_num;
1527 
1528  if (s->prev_frame_num_offset < 0)
1529  s->prev_frame_num_offset += 256;
1530  }
1531 
1532  for (m = 0; m < 2; m++) {
1533  int i;
1534  for (i = 0; i < 4; i++) {
1535  int j;
1536  for (j = -1; j < 4; j++)
1537  s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1538  if (i < 3)
1539  s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1540  }
1541  }
1542 
1543  for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1544  for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1545  unsigned mb_type;
1546  s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1547 
1548  if ((get_bits_left(&s->gb_slice)) <= 7) {
1549  if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1550  show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1551 
1552  if (svq3_decode_slice_header(avctx))
1553  return -1;
1554  }
1555  if (s->slice_type != s->pict_type) {
1556  avpriv_request_sample(avctx, "non constant slice type");
1557  }
1558  /* TODO: support s->mb_skip_run */
1559  }
1560 
1561  mb_type = get_interleaved_ue_golomb(&s->gb_slice);
1562 
1563  if (s->pict_type == AV_PICTURE_TYPE_I)
1564  mb_type += 8;
1565  else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1566  mb_type += 4;
1567  if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1569  "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1570  return -1;
1571  }
1572 
1573  if (mb_type != 0 || s->cbp)
1574  hl_decode_mb(s);
1575 
1576  if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1577  s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1578  (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1579  }
1580 
1581  ff_draw_horiz_band(avctx, s->cur_pic->f,
1582  s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1583  16 * s->mb_y, 16, PICT_FRAME, 0,
1584  s->low_delay);
1585  }
1586 
1587  left = buf_size*8 - get_bits_count(&s->gb_slice);
1588 
1589  if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1590  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);
1591  //av_hex_dump(stderr, buf+buf_size-8, 8);
1592  }
1593 
1594  if (left < 0) {
1595  av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1596  return -1;
1597  }
1598 
1599  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1600  ret = av_frame_ref(data, s->cur_pic->f);
1601  else if (s->last_pic->f->data[0])
1602  ret = av_frame_ref(data, s->last_pic->f);
1603  if (ret < 0)
1604  return ret;
1605 
1606  /* Do not output the last pic after seeking. */
1607  if (s->last_pic->f->data[0] || s->low_delay)
1608  *got_frame = 1;
1609 
1610  if (s->pict_type != AV_PICTURE_TYPE_B) {
1611  FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1612  } else {
1613  av_frame_unref(s->cur_pic->f);
1614  }
1615 
1616  return buf_size;
1617 }
1618 
1620 {
1621  SVQ3Context *s = avctx->priv_data;
1622 
1623  free_picture(avctx, s->cur_pic);
1624  free_picture(avctx, s->next_pic);
1625  free_picture(avctx, s->last_pic);
1626  av_frame_free(&s->cur_pic->f);
1627  av_frame_free(&s->next_pic->f);
1628  av_frame_free(&s->last_pic->f);
1629  av_freep(&s->cur_pic);
1630  av_freep(&s->next_pic);
1631  av_freep(&s->last_pic);
1632  av_freep(&s->slice_buf);
1635  av_freep(&s->mb2br_xy);
1636 
1637 
1638  av_freep(&s->buf);
1639  s->buf_size = 0;
1640 
1641  return 0;
1642 }
1643 
1645  .name = "svq3",
1646  .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1647  .type = AVMEDIA_TYPE_VIDEO,
1648  .id = AV_CODEC_ID_SVQ3,
1649  .priv_data_size = sizeof(SVQ3Context),
1651  .close = svq3_decode_end,
1653  .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1656  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1657  AV_PIX_FMT_NONE},
1658 };
#define MB_TYPE_INTRA16x16
Definition: avcodec.h:1263
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
#define MB_TYPE_SKIP
Definition: avcodec.h:1273
discard all frames except keyframes
Definition: avcodec.h:795
void(* prefetch)(uint8_t *buf, ptrdiff_t stride, int h)
Prefetch memory into cache (if supported by hardware).
Definition: videodsp.h:76
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:124
This structure describes decoded (raw) audio or video data.
Definition: frame.h:190
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
#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:261
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:259
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:204
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:2428
int size
Definition: avcodec.h:1617
#define MB_TYPE_INTRA4x4
Definition: avcodec.h:1262
#define u2(width, value, name)
int mb_xy
Definition: svq3.c:122
const uint8_t * buffer
Definition: get_bits.h:56
int av_log2(unsigned v)
Definition: intmath.c:26
uint8_t * slice_buf
Definition: svq3.c:96
#define INVALID_VLC
Definition: golomb.h:38
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1919
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:120
int v_edge_pos
Definition: svq3.c:107
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:252
const uint8_t ff_h264_quant_rem6[QP_MAX_NUM+1]
Definition: h264data.c:174
discard all
Definition: avcodec.h:796
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:3093
#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:30
AVCodec.
Definition: avcodec.h:3646
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
#define AV_COPY32(d, s)
Definition: intreadwrite.h:586
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:3317
static int16_t block[64]
Definition: dct.c:113
#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:993
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
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:150
#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:2933
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:388
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1806
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
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
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:101
#define height
uint8_t * data
Definition: avcodec.h:1616
thirdpel DSP context
Definition: tpeldsp.h:42
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:199
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:91
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:113
thirdpel DSP functions
ptrdiff_t size
Definition: opengl_enc.c:101
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:870
#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:587
#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:2013
#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:163
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:180
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:1786
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
GLsizei GLsizei * length
Definition: opengl_enc.c:115
unsigned int left_samples_available
Definition: svq3.c:137
const char * name
Name of the codec implementation.
Definition: avcodec.h:3653
#define IS_SKIP(a)
Definition: mpegutils.h:83
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
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:226
#define fail()
Definition: checkasm.h:85
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:499
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:962
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:264
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
#define width
int width
picture width / height.
Definition: avcodec.h:1878
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:296
static av_cold int svq3_decode_init(AVCodecContext *avctx)
Definition: svq3.c:1128
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
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:786
int last_frame_output
Definition: svq3.c:108
int next_p_frame_damaged
Definition: svq3.c:105
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:474
#define IS_INTRA16x16(a)
Definition: mpegutils.h:78
#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:1644
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:221
int debug
debug
Definition: avcodec.h:2932
int intra16x16_pred_mode
Definition: svq3.c:130
main external API structure.
Definition: avcodec.h:1691
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: utils.c:953
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
GLint GLenum type
Definition: opengl_enc.c:105
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:645
int extradata_size
Definition: avcodec.h:1807
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:82
AVBufferRef * mb_type_buf
Definition: svq3.c:74
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:313
const uint8_t ff_h264_golomb_to_intra4x4_cbp[48]
Definition: h264data.c:42
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:338
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:306
int index
Definition: gxfenc.c:89
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264dec.h:661
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:425
static void init_dequant4_coeff_table(SVQ3Context *s)
Definition: svq3.c:1114
#define MB_TYPE_16x16
Definition: avcodec.h:1265
void(* h264_chroma_dc_dequant_idct)(int16_t *block, int qmul)
Definition: h264dsp.h:104
static int svq3_decode_end(AVCodecContext *avctx)
Definition: svq3.c:1619
#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:81
int slice_num
Definition: svq3.c:109
static const struct @118 svq3_dct_tables[2][16]
#define u(width,...)
AVFrame * f
Definition: svq3.c:69
uint8_t * buf
Definition: svq3.c:102
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
SVQ3Frame * last_pic
Definition: svq3.c:93
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:498
static void free_picture(AVCodecContext *avctx, SVQ3Frame *pic)
Definition: svq3.c:1340
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:204
uint8_t level
Definition: svq3.c:207
Definition: vp9.h:84
#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:792
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
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.
if(ret< 0)
Definition: vf_mcdeint.c:282
static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
Definition: svq3.c:1352
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:161
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:743
#define IS_INTRA(x, y)
static const uint32_t svq3_dequant_coeff[32]
Definition: svq3.c:215
void * priv_data
Definition: avcodec.h:1733
#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:77
#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:397
int slice_size
Definition: svq3.c:97
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:259
#define AV_ZERO32(d)
Definition: intreadwrite.h:614
Definition: vf_geq.c:46
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
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
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:2484
#define av_freep(p)
uint32_t watermark_key
Definition: svq3.c:101
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: ffmpeg.c:2045
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:592
#define av_always_inline
Definition: attributes.h:39
SVQ3Frame * next_pic
Definition: svq3.c:92
#define FFSWAP(type, a, b)
Definition: common.h:99
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
Definition: golomb.h:115
int buf_size
Definition: svq3.c:103
exp golomb vlc stuff
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1593
static int svq3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: svq3.c:1400
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1363
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:968
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
int16_t mv_cache[2][5 *8][2]
Definition: svq3.c:141