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 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 
1068  s->slice_type = ff_h264_golomb_to_pict_type[slice_id];
1069 
1070  if ((header & 0x9F) == 2) {
1071  i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
1072  get_bits(&s->gb_slice, i);
1073  } else if (get_bits1(&s->gb_slice)) {
1074  avpriv_report_missing_feature(s->avctx, "Media key encryption");
1075  return AVERROR_PATCHWELCOME;
1076  }
1077 
1078  s->slice_num = get_bits(&s->gb_slice, 8);
1079  s->qscale = get_bits(&s->gb_slice, 5);
1080  s->adaptive_quant = get_bits1(&s->gb_slice);
1081 
1082  /* unknown fields */
1083  skip_bits1(&s->gb_slice);
1084 
1085  if (s->has_watermark)
1086  skip_bits1(&s->gb_slice);
1087 
1088  skip_bits1(&s->gb_slice);
1089  skip_bits(&s->gb_slice, 2);
1090 
1091  if (skip_1stop_8data_bits(&s->gb_slice) < 0)
1092  return AVERROR_INVALIDDATA;
1093 
1094  /* reset intra predictors and invalidate motion vector references */
1095  if (s->mb_x > 0) {
1096  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - 1] + 3,
1097  -1, 4 * sizeof(int8_t));
1098  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_x],
1099  -1, 8 * sizeof(int8_t) * s->mb_x);
1100  }
1101  if (s->mb_y > 0) {
1102  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_stride],
1103  -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
1104 
1105  if (s->mb_x > 0)
1106  s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1107  }
1108 
1109  return 0;
1110 }
1111 
1113 {
1114  int q, x;
1115  const int max_qp = 51;
1116 
1117  for (q = 0; q < max_qp + 1; q++) {
1118  int shift = ff_h264_quant_div6[q] + 2;
1119  int idx = ff_h264_quant_rem6[q];
1120  for (x = 0; x < 16; x++)
1121  s->dequant4_coeff[q][(x >> 2) | ((x << 2) & 0xF)] =
1122  ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] * 16) << shift;
1123  }
1124 }
1125 
1127 {
1128  SVQ3Context *s = avctx->priv_data;
1129  int m, x, y;
1130  unsigned char *extradata;
1131  unsigned char *extradata_end;
1132  unsigned int size;
1133  int marker_found = 0;
1134  int ret;
1135 
1136  s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
1137  s->last_pic = av_mallocz(sizeof(*s->last_pic));
1138  s->next_pic = av_mallocz(sizeof(*s->next_pic));
1139  if (!s->next_pic || !s->last_pic || !s->cur_pic) {
1140  ret = AVERROR(ENOMEM);
1141  goto fail;
1142  }
1143 
1144  s->cur_pic->f = av_frame_alloc();
1145  s->last_pic->f = av_frame_alloc();
1146  s->next_pic->f = av_frame_alloc();
1147  if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1148  return AVERROR(ENOMEM);
1149 
1150  ff_h264dsp_init(&s->h264dsp, 8, 1);
1152  ff_videodsp_init(&s->vdsp, 8);
1153 
1154 
1155  avctx->bits_per_raw_sample = 8;
1156 
1157  ff_hpeldsp_init(&s->hdsp, avctx->flags);
1158  ff_tpeldsp_init(&s->tdsp);
1159 
1160  avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1161  avctx->color_range = AVCOL_RANGE_JPEG;
1162 
1163  s->avctx = avctx;
1164  s->halfpel_flag = 1;
1165  s->thirdpel_flag = 1;
1166  s->has_watermark = 0;
1167 
1168  /* prowl for the "SEQH" marker in the extradata */
1169  extradata = (unsigned char *)avctx->extradata;
1170  extradata_end = avctx->extradata + avctx->extradata_size;
1171  if (extradata) {
1172  for (m = 0; m + 8 < avctx->extradata_size; m++) {
1173  if (!memcmp(extradata, "SEQH", 4)) {
1174  marker_found = 1;
1175  break;
1176  }
1177  extradata++;
1178  }
1179  }
1180 
1181  /* if a match was found, parse the extra data */
1182  if (marker_found) {
1183  GetBitContext gb;
1184  int frame_size_code;
1185  int unk0, unk1, unk2, unk3, unk4;
1186 
1187  size = AV_RB32(&extradata[4]);
1188  if (size > extradata_end - extradata - 8) {
1189  ret = AVERROR_INVALIDDATA;
1190  goto fail;
1191  }
1192  init_get_bits(&gb, extradata + 8, size * 8);
1193 
1194  /* 'frame size code' and optional 'width, height' */
1195  frame_size_code = get_bits(&gb, 3);
1196  switch (frame_size_code) {
1197  case 0:
1198  avctx->width = 160;
1199  avctx->height = 120;
1200  break;
1201  case 1:
1202  avctx->width = 128;
1203  avctx->height = 96;
1204  break;
1205  case 2:
1206  avctx->width = 176;
1207  avctx->height = 144;
1208  break;
1209  case 3:
1210  avctx->width = 352;
1211  avctx->height = 288;
1212  break;
1213  case 4:
1214  avctx->width = 704;
1215  avctx->height = 576;
1216  break;
1217  case 5:
1218  avctx->width = 240;
1219  avctx->height = 180;
1220  break;
1221  case 6:
1222  avctx->width = 320;
1223  avctx->height = 240;
1224  break;
1225  case 7:
1226  avctx->width = get_bits(&gb, 12);
1227  avctx->height = get_bits(&gb, 12);
1228  break;
1229  }
1230 
1231  s->halfpel_flag = get_bits1(&gb);
1232  s->thirdpel_flag = get_bits1(&gb);
1233 
1234  /* unknown fields */
1235  unk0 = get_bits1(&gb);
1236  unk1 = get_bits1(&gb);
1237  unk2 = get_bits1(&gb);
1238  unk3 = get_bits1(&gb);
1239 
1240  s->low_delay = get_bits1(&gb);
1241 
1242  /* unknown field */
1243  unk4 = get_bits1(&gb);
1244 
1245  av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1246  unk0, unk1, unk2, unk3, unk4);
1247 
1248  if (skip_1stop_8data_bits(&gb) < 0) {
1249  ret = AVERROR_INVALIDDATA;
1250  goto fail;
1251  }
1252 
1253  s->has_watermark = get_bits1(&gb);
1254  avctx->has_b_frames = !s->low_delay;
1255  if (s->has_watermark) {
1256 #if CONFIG_ZLIB
1257  unsigned watermark_width = get_interleaved_ue_golomb(&gb);
1258  unsigned watermark_height = get_interleaved_ue_golomb(&gb);
1259  int u1 = get_interleaved_ue_golomb(&gb);
1260  int u2 = get_bits(&gb, 8);
1261  int u3 = get_bits(&gb, 2);
1262  int u4 = get_interleaved_ue_golomb(&gb);
1263  unsigned long buf_len = watermark_width *
1264  watermark_height * 4;
1265  int offset = get_bits_count(&gb) + 7 >> 3;
1266  uint8_t *buf;
1267 
1268  if (watermark_height <= 0 ||
1269  (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
1270  ret = -1;
1271  goto fail;
1272  }
1273 
1274  buf = av_malloc(buf_len);
1275  if (!buf) {
1276  ret = AVERROR(ENOMEM);
1277  goto fail;
1278  }
1279  av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1280  watermark_width, watermark_height);
1281  av_log(avctx, AV_LOG_DEBUG,
1282  "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1283  u1, u2, u3, u4, offset);
1284  if (uncompress(buf, &buf_len, extradata + 8 + offset,
1285  size - offset) != Z_OK) {
1286  av_log(avctx, AV_LOG_ERROR,
1287  "could not uncompress watermark logo\n");
1288  av_free(buf);
1289  ret = -1;
1290  goto fail;
1291  }
1292  s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1293  s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1294  av_log(avctx, AV_LOG_DEBUG,
1295  "watermark key %#"PRIx32"\n", s->watermark_key);
1296  av_free(buf);
1297 #else
1298  av_log(avctx, AV_LOG_ERROR,
1299  "this svq3 file contains watermark which need zlib support compiled in\n");
1300  ret = -1;
1301  goto fail;
1302 #endif
1303  }
1304  }
1305 
1306  s->mb_width = (avctx->width + 15) / 16;
1307  s->mb_height = (avctx->height + 15) / 16;
1308  s->mb_stride = s->mb_width + 1;
1309  s->mb_num = s->mb_width * s->mb_height;
1310  s->b_stride = 4 * s->mb_width;
1311  s->h_edge_pos = s->mb_width * 16;
1312  s->v_edge_pos = s->mb_height * 16;
1313 
1314  s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1315  if (!s->intra4x4_pred_mode)
1316  return AVERROR(ENOMEM);
1317 
1318  s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1319  sizeof(*s->mb2br_xy));
1320  if (!s->mb2br_xy)
1321  return AVERROR(ENOMEM);
1322 
1323  for (y = 0; y < s->mb_height; y++)
1324  for (x = 0; x < s->mb_width; x++) {
1325  const int mb_xy = x + y * s->mb_stride;
1326 
1327  s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1328  }
1329 
1331 
1332  return 0;
1333 fail:
1334  svq3_decode_end(avctx);
1335  return ret;
1336 }
1337 
1338 static void free_picture(AVCodecContext *avctx, SVQ3Frame *pic)
1339 {
1340  int i;
1341  for (i = 0; i < 2; i++) {
1342  av_buffer_unref(&pic->motion_val_buf[i]);
1343  av_buffer_unref(&pic->ref_index_buf[i]);
1344  }
1346 
1347  av_frame_unref(pic->f);
1348 }
1349 
1350 static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
1351 {
1352  SVQ3Context *s = avctx->priv_data;
1353  const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
1354  const int mb_array_size = s->mb_stride * s->mb_height;
1355  const int b4_stride = s->mb_width * 4 + 1;
1356  const int b4_array_size = b4_stride * s->mb_height * 4;
1357  int ret;
1358 
1359  if (!pic->motion_val_buf[0]) {
1360  int i;
1361 
1362  pic->mb_type_buf = av_buffer_allocz((big_mb_num + s->mb_stride) * sizeof(uint32_t));
1363  if (!pic->mb_type_buf)
1364  return AVERROR(ENOMEM);
1365  pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
1366 
1367  for (i = 0; i < 2; i++) {
1368  pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1369  pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1370  if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1371  ret = AVERROR(ENOMEM);
1372  goto fail;
1373  }
1374 
1375  pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1376  pic->ref_index[i] = pic->ref_index_buf[i]->data;
1377  }
1378  }
1379 
1380  ret = ff_get_buffer(avctx, pic->f,
1381  (s->pict_type != AV_PICTURE_TYPE_B) ?
1383  if (ret < 0)
1384  goto fail;
1385 
1386  if (!s->edge_emu_buffer) {
1387  s->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1388  if (!s->edge_emu_buffer)
1389  return AVERROR(ENOMEM);
1390  }
1391 
1392  return 0;
1393 fail:
1394  free_picture(avctx, pic);
1395  return ret;
1396 }
1397 
1398 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1399  int *got_frame, AVPacket *avpkt)
1400 {
1401  SVQ3Context *s = avctx->priv_data;
1402  int buf_size = avpkt->size;
1403  int left;
1404  uint8_t *buf;
1405  int ret, m, i;
1406 
1407  /* special case for last picture */
1408  if (buf_size == 0) {
1409  if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1410  ret = av_frame_ref(data, s->next_pic->f);
1411  if (ret < 0)
1412  return ret;
1413  s->last_frame_output = 1;
1414  *got_frame = 1;
1415  }
1416  return 0;
1417  }
1418 
1419  s->mb_x = s->mb_y = s->mb_xy = 0;
1420 
1421  if (s->watermark_key) {
1422  av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1423  if (!s->buf)
1424  return AVERROR(ENOMEM);
1425  memcpy(s->buf, avpkt->data, buf_size);
1426  buf = s->buf;
1427  } else {
1428  buf = avpkt->data;
1429  }
1430 
1431  ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1432  if (ret < 0)
1433  return ret;
1434 
1435  if (svq3_decode_slice_header(avctx))
1436  return -1;
1437 
1438  s->pict_type = s->slice_type;
1439 
1440  if (s->pict_type != AV_PICTURE_TYPE_B)
1441  FFSWAP(SVQ3Frame*, s->next_pic, s->last_pic);
1442 
1443  av_frame_unref(s->cur_pic->f);
1444 
1445  /* for skipping the frame */
1446  s->cur_pic->f->pict_type = s->pict_type;
1448 
1449  ret = get_buffer(avctx, s->cur_pic);
1450  if (ret < 0)
1451  return ret;
1452 
1453  for (i = 0; i < 16; i++) {
1454  s->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1455  s->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1456  }
1457  for (i = 0; i < 16; i++) {
1458  s->block_offset[16 + i] =
1459  s->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1460  s->block_offset[48 + 16 + i] =
1461  s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1462  }
1463 
1464  if (s->pict_type != AV_PICTURE_TYPE_I) {
1465  if (!s->last_pic->f->data[0]) {
1466  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1467  av_frame_unref(s->last_pic->f);
1468  ret = get_buffer(avctx, s->last_pic);
1469  if (ret < 0)
1470  return ret;
1471  memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1472  memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1473  s->last_pic->f->linesize[1]);
1474  memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1475  s->last_pic->f->linesize[2]);
1476  }
1477 
1478  if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1479  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1480  av_frame_unref(s->next_pic->f);
1481  ret = get_buffer(avctx, s->next_pic);
1482  if (ret < 0)
1483  return ret;
1484  memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1485  memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1486  s->next_pic->f->linesize[1]);
1487  memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1488  s->next_pic->f->linesize[2]);
1489  }
1490  }
1491 
1492  if (avctx->debug & FF_DEBUG_PICT_INFO)
1494  "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1496  s->halfpel_flag, s->thirdpel_flag,
1497  s->adaptive_quant, s->qscale, s->slice_num);
1498 
1499  if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1501  avctx->skip_frame >= AVDISCARD_ALL)
1502  return 0;
1503 
1504  if (s->next_p_frame_damaged) {
1505  if (s->pict_type == AV_PICTURE_TYPE_B)
1506  return 0;
1507  else
1508  s->next_p_frame_damaged = 0;
1509  }
1510 
1511  if (s->pict_type == AV_PICTURE_TYPE_B) {
1513 
1514  if (s->frame_num_offset < 0)
1515  s->frame_num_offset += 256;
1516  if (s->frame_num_offset == 0 ||
1518  av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1519  return -1;
1520  }
1521  } else {
1522  s->prev_frame_num = s->frame_num;
1523  s->frame_num = s->slice_num;
1525 
1526  if (s->prev_frame_num_offset < 0)
1527  s->prev_frame_num_offset += 256;
1528  }
1529 
1530  for (m = 0; m < 2; m++) {
1531  int i;
1532  for (i = 0; i < 4; i++) {
1533  int j;
1534  for (j = -1; j < 4; j++)
1535  s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1536  if (i < 3)
1537  s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1538  }
1539  }
1540 
1541  for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1542  for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1543  unsigned mb_type;
1544  s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1545 
1546  if ((get_bits_left(&s->gb_slice)) <= 7) {
1547  if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1548  show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1549 
1550  if (svq3_decode_slice_header(avctx))
1551  return -1;
1552  }
1553  if (s->slice_type != s->pict_type) {
1554  avpriv_request_sample(avctx, "non constant slice type");
1555  }
1556  /* TODO: support s->mb_skip_run */
1557  }
1558 
1559  mb_type = get_interleaved_ue_golomb(&s->gb_slice);
1560 
1561  if (s->pict_type == AV_PICTURE_TYPE_I)
1562  mb_type += 8;
1563  else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1564  mb_type += 4;
1565  if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1567  "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1568  return -1;
1569  }
1570 
1571  if (mb_type != 0 || s->cbp)
1572  hl_decode_mb(s);
1573 
1574  if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1575  s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1576  (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1577  }
1578 
1579  ff_draw_horiz_band(avctx, s->cur_pic->f,
1580  s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1581  16 * s->mb_y, 16, PICT_FRAME, 0,
1582  s->low_delay);
1583  }
1584 
1585  left = buf_size*8 - get_bits_count(&s->gb_slice);
1586 
1587  if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1588  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);
1589  //av_hex_dump(stderr, buf+buf_size-8, 8);
1590  }
1591 
1592  if (left < 0) {
1593  av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1594  return -1;
1595  }
1596 
1597  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1598  ret = av_frame_ref(data, s->cur_pic->f);
1599  else if (s->last_pic->f->data[0])
1600  ret = av_frame_ref(data, s->last_pic->f);
1601  if (ret < 0)
1602  return ret;
1603 
1604  /* Do not output the last pic after seeking. */
1605  if (s->last_pic->f->data[0] || s->low_delay)
1606  *got_frame = 1;
1607 
1608  if (s->pict_type != AV_PICTURE_TYPE_B) {
1609  FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1610  } else {
1611  av_frame_unref(s->cur_pic->f);
1612  }
1613 
1614  return buf_size;
1615 }
1616 
1618 {
1619  SVQ3Context *s = avctx->priv_data;
1620 
1621  free_picture(avctx, s->cur_pic);
1622  free_picture(avctx, s->next_pic);
1623  free_picture(avctx, s->last_pic);
1624  av_frame_free(&s->cur_pic->f);
1625  av_frame_free(&s->next_pic->f);
1626  av_frame_free(&s->last_pic->f);
1627  av_freep(&s->cur_pic);
1628  av_freep(&s->next_pic);
1629  av_freep(&s->last_pic);
1630  av_freep(&s->slice_buf);
1633  av_freep(&s->mb2br_xy);
1634 
1635 
1636  av_freep(&s->buf);
1637  s->buf_size = 0;
1638 
1639  return 0;
1640 }
1641 
1643  .name = "svq3",
1644  .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1645  .type = AVMEDIA_TYPE_VIDEO,
1646  .id = AV_CODEC_ID_SVQ3,
1647  .priv_data_size = sizeof(SVQ3Context),
1649  .close = svq3_decode_end,
1651  .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1654  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1655  AV_PIX_FMT_NONE},
1656 };
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:796
void(* prefetch)(uint8_t *buf, ptrdiff_t stride, int h)
Prefetch memory into cache (if supported by hardware).
Definition: videodsp.h:76
#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
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
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: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:2151
int size
Definition: avcodec.h:1434
int mb_xy
Definition: svq3.c:122
const uint8_t * buffer
Definition: get_bits.h:57
int av_log2(unsigned v)
Definition: intmath.c:26
uint8_t * slice_buf
Definition: svq3.c:96
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1730
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
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
const uint8_t ff_h264_quant_rem6[QP_MAX_NUM+1]
Definition: h264data.c:174
discard all
Definition: avcodec.h:797
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:2744
#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:3411
#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:2978
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:987
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
static const struct @133 svq3_dct_tables[2][16]
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 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:2602
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:1621
#define MB_TYPE_16x16
Definition: mpegutils.h:54
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:253
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:112
#define height
uint8_t * data
Definition: avcodec.h:1433
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
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:864
#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:1810
#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:1601
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
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:3418
#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:117
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:956
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:78
int width
picture width / height.
Definition: avcodec.h:1693
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:1126
#define s(width, name)
Definition: cbs_vp9.c:257
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:822
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:512
#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:1642
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:2601
int intra16x16_pred_mode
Definition: svq3.c:130
main external API structure.
Definition: avcodec.h:1521
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:1922
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:644
int extradata_size
Definition: avcodec.h:1622
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:1112
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:1617
#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
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:1338
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:793
int
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:279
static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
Definition: svq3.c:1350
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:776
#define IS_INTRA(x, y)
static const uint32_t svq3_dequant_coeff[32]
Definition: svq3.c:215
void * priv_data
Definition: avcodec.h:1548
#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
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:2207
#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
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:64
This structure stores compressed data.
Definition: avcodec.h:1410
static int svq3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: svq3.c:1398
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1138
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:962
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)
Definition: mem.c:191
int16_t mv_cache[2][5 *8][2]
Definition: svq3.c:141