FFmpeg
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 "libavutil/crc.h"
47 #include "libavutil/mem_internal.h"
48 
49 #include "codec_internal.h"
50 #include "internal.h"
51 #include "avcodec.h"
52 #include "mpegutils.h"
53 #include "h264data.h"
54 #include "h264dsp.h"
55 #include "h264pred.h"
56 #include "h264_parse.h"
57 #include "golomb.h"
58 #include "hpeldsp.h"
59 #include "mathops.h"
60 #include "rectangle.h"
61 #include "tpeldsp.h"
62 #include "videodsp.h"
63 
64 #if CONFIG_ZLIB
65 #include <zlib.h>
66 #endif
67 
68 #include "svq1.h"
69 
70 /**
71  * @file
72  * svq3 decoder.
73  */
74 
75 typedef struct SVQ3Frame {
77 
78  int16_t (*motion_val_buf[2])[2];
79  int16_t (*motion_val[2])[2];
80 
81  uint32_t *mb_type_buf, *mb_type;
82 } SVQ3Frame;
83 
84 typedef struct SVQ3Context {
86 
92 
98  uint8_t *slice_buf;
99  unsigned slice_buf_size;
103  uint32_t watermark_key;
109  int qscale;
110  int cbp;
115 
119 
120  int mb_x, mb_y;
121  int mb_xy;
124  int b_stride;
125 
126  uint32_t *mb2br_xy;
127 
130 
133 
134  unsigned int top_samples_available;
136 
137  uint8_t *edge_emu_buffer;
138 
139  DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
140  DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8];
141  DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
142  DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
143  DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
144  uint32_t dequant4_coeff[QP_MAX_NUM + 1][16];
145  int block_offset[2 * (16 * 3)];
147 } SVQ3Context;
148 
149 #define FULLPEL_MODE 1
150 #define HALFPEL_MODE 2
151 #define THIRDPEL_MODE 3
152 #define PREDICT_MODE 4
153 
154 /* dual scan (from some older H.264 draft)
155  * o-->o-->o o
156  * | /|
157  * o o o / o
158  * | / | |/ |
159  * o o o o
160  * /
161  * o-->o-->o-->o
162  */
163 static const uint8_t svq3_scan[16] = {
164  0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
165  2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
166  0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
167  0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
168 };
169 
170 static const uint8_t luma_dc_zigzag_scan[16] = {
171  0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
172  3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
173  1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
174  3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
175 };
176 
177 static const uint8_t svq3_pred_0[25][2] = {
178  { 0, 0 },
179  { 1, 0 }, { 0, 1 },
180  { 0, 2 }, { 1, 1 }, { 2, 0 },
181  { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
182  { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
183  { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
184  { 2, 4 }, { 3, 3 }, { 4, 2 },
185  { 4, 3 }, { 3, 4 },
186  { 4, 4 }
187 };
188 
189 static const int8_t svq3_pred_1[6][6][5] = {
190  { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
191  { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
192  { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
193  { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
194  { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
195  { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
196  { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
197  { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
198  { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
199  { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
200  { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
201  { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
202 };
203 
204 static const struct {
205  uint8_t run;
206  uint8_t level;
207 } svq3_dct_tables[2][16] = {
208  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
209  { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
210  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
211  { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
212 };
213 
214 static const uint32_t svq3_dequant_coeff[32] = {
215  3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
216  9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
217  24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
218  61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
219 };
220 
221 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
222 {
223  const unsigned qmul = svq3_dequant_coeff[qp];
224 #define stride 16
225  int i;
226  int temp[16];
227  static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
228 
229  for (i = 0; i < 4; i++) {
230  const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
231  const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
232  const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
233  const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
234 
235  temp[4 * i + 0] = z0 + z3;
236  temp[4 * i + 1] = z1 + z2;
237  temp[4 * i + 2] = z1 - z2;
238  temp[4 * i + 3] = z0 - z3;
239  }
240 
241  for (i = 0; i < 4; i++) {
242  const int offset = x_offset[i];
243  const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
244  const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
245  const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
246  const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
247 
248  output[stride * 0 + offset] = (int)((z0 + z3) * qmul + 0x80000) >> 20;
249  output[stride * 2 + offset] = (int)((z1 + z2) * qmul + 0x80000) >> 20;
250  output[stride * 8 + offset] = (int)((z1 - z2) * qmul + 0x80000) >> 20;
251  output[stride * 10 + offset] = (int)((z0 - z3) * qmul + 0x80000) >> 20;
252  }
253 }
254 #undef stride
255 
256 static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
257  int stride, int qp, int dc)
258 {
259  const int qmul = svq3_dequant_coeff[qp];
260  int i;
261 
262  if (dc) {
263  dc = 13 * 13 * (dc == 1 ? 1538U* block[0]
264  : qmul * (block[0] >> 3) / 2);
265  block[0] = 0;
266  }
267 
268  for (i = 0; i < 4; i++) {
269  const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
270  const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
271  const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
272  const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
273 
274  block[0 + 4 * i] = z0 + z3;
275  block[1 + 4 * i] = z1 + z2;
276  block[2 + 4 * i] = z1 - z2;
277  block[3 + 4 * i] = z0 - z3;
278  }
279 
280  for (i = 0; i < 4; i++) {
281  const unsigned z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
282  const unsigned z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
283  const unsigned z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
284  const unsigned z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
285  const int rr = (dc + 0x80000u);
286 
287  dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((int)((z0 + z3) * qmul + rr) >> 20));
288  dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((int)((z1 + z2) * qmul + rr) >> 20));
289  dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((int)((z1 - z2) * qmul + rr) >> 20));
290  dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((int)((z0 - z3) * qmul + rr) >> 20));
291  }
292 
293  memset(block, 0, 16 * sizeof(int16_t));
294 }
295 
296 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
297  int index, const int type)
298 {
299  static const uint8_t *const scan_patterns[4] = {
301  };
302 
303  int run, level, sign, limit;
304  unsigned vlc;
305  const int intra = 3 * type >> 2;
306  const uint8_t *const scan = scan_patterns[type];
307 
308  for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
309  for (; (vlc = get_interleaved_ue_golomb(gb)) != 0; index++) {
310  if ((int32_t)vlc < 0)
311  return -1;
312 
313  sign = (vlc & 1) ? 0 : -1;
314  vlc = vlc + 1 >> 1;
315 
316  if (type == 3) {
317  if (vlc < 3) {
318  run = 0;
319  level = vlc;
320  } else if (vlc < 4) {
321  run = 1;
322  level = 1;
323  } else {
324  run = vlc & 0x3;
325  level = (vlc + 9 >> 2) - run;
326  }
327  } else {
328  if (vlc < 16U) {
329  run = svq3_dct_tables[intra][vlc].run;
330  level = svq3_dct_tables[intra][vlc].level;
331  } else if (intra) {
332  run = vlc & 0x7;
333  level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
334  } else {
335  run = vlc & 0xF;
336  level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
337  }
338  }
339 
340 
341  if ((index += run) >= limit)
342  return -1;
343 
344  block[scan[index]] = (level ^ sign) - sign;
345  }
346 
347  if (type != 2) {
348  break;
349  }
350  }
351 
352  return 0;
353 }
354 
355 static av_always_inline int
356 svq3_fetch_diagonal_mv(const SVQ3Context *s, const int16_t **C,
357  int i, int list, int part_width)
358 {
359  const int topright_ref = s->ref_cache[list][i - 8 + part_width];
360 
361  if (topright_ref != PART_NOT_AVAILABLE) {
362  *C = s->mv_cache[list][i - 8 + part_width];
363  return topright_ref;
364  } else {
365  *C = s->mv_cache[list][i - 8 - 1];
366  return s->ref_cache[list][i - 8 - 1];
367  }
368 }
369 
370 /**
371  * Get the predicted MV.
372  * @param n the block index
373  * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
374  * @param mx the x component of the predicted motion vector
375  * @param my the y component of the predicted motion vector
376  */
377 static av_always_inline void svq3_pred_motion(const SVQ3Context *s, int n,
378  int part_width, int list,
379  int ref, int *const mx, int *const my)
380 {
381  const int index8 = scan8[n];
382  const int top_ref = s->ref_cache[list][index8 - 8];
383  const int left_ref = s->ref_cache[list][index8 - 1];
384  const int16_t *const A = s->mv_cache[list][index8 - 1];
385  const int16_t *const B = s->mv_cache[list][index8 - 8];
386  const int16_t *C;
387  int diagonal_ref, match_count;
388 
389 /* mv_cache
390  * B . . A T T T T
391  * U . . L . . , .
392  * U . . L . . . .
393  * U . . L . . , .
394  * . . . L . . . .
395  */
396 
397  diagonal_ref = svq3_fetch_diagonal_mv(s, &C, index8, list, part_width);
398  match_count = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
399  if (match_count > 1) { //most common
400  *mx = mid_pred(A[0], B[0], C[0]);
401  *my = mid_pred(A[1], B[1], C[1]);
402  } else if (match_count == 1) {
403  if (left_ref == ref) {
404  *mx = A[0];
405  *my = A[1];
406  } else if (top_ref == ref) {
407  *mx = B[0];
408  *my = B[1];
409  } else {
410  *mx = C[0];
411  *my = C[1];
412  }
413  } else {
414  if (top_ref == PART_NOT_AVAILABLE &&
415  diagonal_ref == PART_NOT_AVAILABLE &&
416  left_ref != PART_NOT_AVAILABLE) {
417  *mx = A[0];
418  *my = A[1];
419  } else {
420  *mx = mid_pred(A[0], B[0], C[0]);
421  *my = mid_pred(A[1], B[1], C[1]);
422  }
423  }
424 }
425 
426 static inline void svq3_mc_dir_part(SVQ3Context *s,
427  int x, int y, int width, int height,
428  int mx, int my, int dxy,
429  int thirdpel, int dir, int avg)
430 {
431  const SVQ3Frame *pic = (dir == 0) ? s->last_pic : s->next_pic;
432  uint8_t *src, *dest;
433  int i, emu = 0;
434  int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
435  int linesize = s->cur_pic->f->linesize[0];
436  int uvlinesize = s->cur_pic->f->linesize[1];
437 
438  mx += x;
439  my += y;
440 
441  if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
442  my < 0 || my >= s->v_edge_pos - height - 1) {
443  emu = 1;
444  mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
445  my = av_clip(my, -16, s->v_edge_pos - height + 15);
446  }
447 
448  /* form component predictions */
449  dest = s->cur_pic->f->data[0] + x + y * linesize;
450  src = pic->f->data[0] + mx + my * linesize;
451 
452  if (emu) {
453  s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
454  linesize, linesize,
455  width + 1, height + 1,
456  mx, my, s->h_edge_pos, s->v_edge_pos);
457  src = s->edge_emu_buffer;
458  }
459  if (thirdpel)
460  (avg ? s->tdsp.avg_tpel_pixels_tab
461  : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, linesize,
462  width, height);
463  else
464  (avg ? s->hdsp.avg_pixels_tab
465  : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, linesize,
466  height);
467 
468  if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
469  mx = mx + (mx < (int) x) >> 1;
470  my = my + (my < (int) y) >> 1;
471  width = width >> 1;
472  height = height >> 1;
473  blocksize++;
474 
475  for (i = 1; i < 3; i++) {
476  dest = s->cur_pic->f->data[i] + (x >> 1) + (y >> 1) * uvlinesize;
477  src = pic->f->data[i] + mx + my * uvlinesize;
478 
479  if (emu) {
480  s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
481  uvlinesize, uvlinesize,
482  width + 1, height + 1,
483  mx, my, (s->h_edge_pos >> 1),
484  s->v_edge_pos >> 1);
485  src = s->edge_emu_buffer;
486  }
487  if (thirdpel)
488  (avg ? s->tdsp.avg_tpel_pixels_tab
489  : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
490  uvlinesize,
491  width, height);
492  else
493  (avg ? s->hdsp.avg_pixels_tab
494  : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
495  uvlinesize,
496  height);
497  }
498  }
499 }
500 
501 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
502  int dir, int avg)
503 {
504  int i, j, k, mx, my, dx, dy, x, y;
505  const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
506  const int part_height = 16 >> ((unsigned)(size + 1) / 3);
507  const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
508  const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
509  const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
510 
511  for (i = 0; i < 16; i += part_height)
512  for (j = 0; j < 16; j += part_width) {
513  const int b_xy = (4 * s->mb_x + (j >> 2)) +
514  (4 * s->mb_y + (i >> 2)) * s->b_stride;
515  int dxy;
516  x = 16 * s->mb_x + j;
517  y = 16 * s->mb_y + i;
518  k = (j >> 2 & 1) + (i >> 1 & 2) +
519  (j >> 1 & 4) + (i & 8);
520 
521  if (mode != PREDICT_MODE) {
522  svq3_pred_motion(s, k, part_width >> 2, dir, 1, &mx, &my);
523  } else {
524  mx = s->next_pic->motion_val[0][b_xy][0] * 2;
525  my = s->next_pic->motion_val[0][b_xy][1] * 2;
526 
527  if (dir == 0) {
528  mx = mx * s->frame_num_offset /
529  s->prev_frame_num_offset + 1 >> 1;
530  my = my * s->frame_num_offset /
531  s->prev_frame_num_offset + 1 >> 1;
532  } else {
533  mx = mx * (s->frame_num_offset - s->prev_frame_num_offset) /
534  s->prev_frame_num_offset + 1 >> 1;
535  my = my * (s->frame_num_offset - s->prev_frame_num_offset) /
536  s->prev_frame_num_offset + 1 >> 1;
537  }
538  }
539 
540  /* clip motion vector prediction to frame border */
541  mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
542  my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
543 
544  /* get (optional) motion vector differential */
545  if (mode == PREDICT_MODE) {
546  dx = dy = 0;
547  } else {
548  dy = get_interleaved_se_golomb(&s->gb_slice);
549  dx = get_interleaved_se_golomb(&s->gb_slice);
550 
551  if (dx != (int16_t)dx || dy != (int16_t)dy) {
552  av_log(s->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
553  return -1;
554  }
555  }
556 
557  /* compute motion vector */
558  if (mode == THIRDPEL_MODE) {
559  int fx, fy;
560  mx = (mx + 1 >> 1) + dx;
561  my = (my + 1 >> 1) + dy;
562  fx = (unsigned)(mx + 0x30000) / 3 - 0x10000;
563  fy = (unsigned)(my + 0x30000) / 3 - 0x10000;
564  dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
565 
566  svq3_mc_dir_part(s, x, y, part_width, part_height,
567  fx, fy, dxy, 1, dir, avg);
568  mx += mx;
569  my += my;
570  } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
571  mx = (unsigned)(mx + 1 + 0x30000) / 3 + dx - 0x10000;
572  my = (unsigned)(my + 1 + 0x30000) / 3 + dy - 0x10000;
573  dxy = (mx & 1) + 2 * (my & 1);
574 
575  svq3_mc_dir_part(s, x, y, part_width, part_height,
576  mx >> 1, my >> 1, dxy, 0, dir, avg);
577  mx *= 3;
578  my *= 3;
579  } else {
580  mx = (unsigned)(mx + 3 + 0x60000) / 6 + dx - 0x10000;
581  my = (unsigned)(my + 3 + 0x60000) / 6 + dy - 0x10000;
582 
583  svq3_mc_dir_part(s, x, y, part_width, part_height,
584  mx, my, 0, 0, dir, avg);
585  mx *= 6;
586  my *= 6;
587  }
588 
589  /* update mv_cache */
590  if (mode != PREDICT_MODE) {
591  int32_t mv = pack16to32(mx, my);
592 
593  if (part_height == 8 && i < 8) {
594  AV_WN32A(s->mv_cache[dir][scan8[k] + 1 * 8], mv);
595 
596  if (part_width == 8 && j < 8)
597  AV_WN32A(s->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
598  }
599  if (part_width == 8 && j < 8)
600  AV_WN32A(s->mv_cache[dir][scan8[k] + 1], mv);
601  if (part_width == 4 || part_height == 4)
602  AV_WN32A(s->mv_cache[dir][scan8[k]], mv);
603  }
604 
605  /* write back motion vectors */
606  fill_rectangle(s->cur_pic->motion_val[dir][b_xy],
607  part_width >> 2, part_height >> 2, s->b_stride,
608  pack16to32(mx, my), 4);
609  }
610 
611  return 0;
612 }
613 
615  int mb_type, const int *block_offset,
616  int linesize, uint8_t *dest_y)
617 {
618  int i;
619  if (!IS_INTRA4x4(mb_type)) {
620  for (i = 0; i < 16; i++)
621  if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
622  uint8_t *const ptr = dest_y + block_offset[i];
623  svq3_add_idct_c(ptr, s->mb + i * 16, linesize,
624  s->qscale, IS_INTRA(mb_type) ? 1 : 0);
625  }
626  }
627 }
628 
630  int mb_type,
631  const int *block_offset,
632  int linesize,
633  uint8_t *dest_y)
634 {
635  int i;
636  int qscale = s->qscale;
637 
638  if (IS_INTRA4x4(mb_type)) {
639  for (i = 0; i < 16; i++) {
640  uint8_t *const ptr = dest_y + block_offset[i];
641  const int dir = s->intra4x4_pred_mode_cache[scan8[i]];
642 
643  uint8_t *topright;
644  int nnz;
645  if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
646  av_assert2(s->mb_y || linesize <= block_offset[i]);
647  topright = ptr + 4 - linesize;
648  } else
649  topright = NULL;
650 
651  s->hpc.pred4x4[dir](ptr, topright, linesize);
652  nnz = s->non_zero_count_cache[scan8[i]];
653  if (nnz) {
654  svq3_add_idct_c(ptr, s->mb + i * 16, linesize, qscale, 0);
655  }
656  }
657  } else {
658  s->hpc.pred16x16[s->intra16x16_pred_mode](dest_y, linesize);
659  svq3_luma_dc_dequant_idct_c(s->mb, s->mb_luma_dc[0], qscale);
660  }
661 }
662 
664 {
665  const int mb_x = s->mb_x;
666  const int mb_y = s->mb_y;
667  const int mb_xy = s->mb_xy;
668  const int mb_type = s->cur_pic->mb_type[mb_xy];
669  uint8_t *dest_y, *dest_cb, *dest_cr;
670  int linesize, uvlinesize;
671  int i, j;
672  const int *block_offset = &s->block_offset[0];
673  const int block_h = 16 >> 1;
674 
675  linesize = s->cur_pic->f->linesize[0];
676  uvlinesize = s->cur_pic->f->linesize[1];
677 
678  dest_y = s->cur_pic->f->data[0] + (mb_x + mb_y * linesize) * 16;
679  dest_cb = s->cur_pic->f->data[1] + mb_x * 8 + mb_y * uvlinesize * block_h;
680  dest_cr = s->cur_pic->f->data[2] + mb_x * 8 + mb_y * uvlinesize * block_h;
681 
682  s->vdsp.prefetch(dest_y + (s->mb_x & 3) * 4 * linesize + 64, linesize, 4);
683  s->vdsp.prefetch(dest_cb + (s->mb_x & 7) * uvlinesize + 64, dest_cr - dest_cb, 2);
684 
685  if (IS_INTRA(mb_type)) {
686  s->hpc.pred8x8[s->chroma_pred_mode](dest_cb, uvlinesize);
687  s->hpc.pred8x8[s->chroma_pred_mode](dest_cr, uvlinesize);
688 
689  hl_decode_mb_predict_luma(s, mb_type, block_offset, linesize, dest_y);
690  }
691 
692  hl_decode_mb_idct_luma(s, mb_type, block_offset, linesize, dest_y);
693 
694  if (s->cbp & 0x30) {
695  uint8_t *dest[2] = { dest_cb, dest_cr };
696  s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 1,
697  s->dequant4_coeff[4][0]);
698  s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 2,
699  s->dequant4_coeff[4][0]);
700  for (j = 1; j < 3; j++) {
701  for (i = j * 16; i < j * 16 + 4; i++)
702  if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
703  uint8_t *const ptr = dest[j - 1] + block_offset[i];
704  svq3_add_idct_c(ptr, s->mb + i * 16,
705  uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
706  }
707  }
708  }
709 }
710 
711 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
712 {
713  int i, j, k, m, dir, mode;
714  int cbp = 0;
715  uint32_t vlc;
716  int8_t *top, *left;
717  const int mb_xy = s->mb_xy;
718  const int b_xy = 4 * s->mb_x + 4 * s->mb_y * s->b_stride;
719 
720  s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
721  s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
722 
723  if (mb_type == 0) { /* SKIP */
724  if (s->pict_type == AV_PICTURE_TYPE_P ||
725  s->next_pic->mb_type[mb_xy] == -1) {
726  svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
727  0, 0, 0, 0, 0, 0);
728 
729  if (s->pict_type == AV_PICTURE_TYPE_B)
730  svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
731  0, 0, 0, 0, 1, 1);
732 
733  mb_type = MB_TYPE_SKIP;
734  } else {
735  mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
736  if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
737  return -1;
738  if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
739  return -1;
740 
741  mb_type = MB_TYPE_16x16;
742  }
743  } else if (mb_type < 8) { /* INTER */
744  if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&s->gb_slice))
746  else if (s->halfpel_flag &&
747  s->thirdpel_flag == !get_bits1(&s->gb_slice))
748  mode = HALFPEL_MODE;
749  else
750  mode = FULLPEL_MODE;
751 
752  /* fill caches */
753  /* note ref_cache should contain here:
754  * ????????
755  * ???11111
756  * N??11111
757  * N??11111
758  * N??11111
759  */
760 
761  for (m = 0; m < 2; m++) {
762  if (s->mb_x > 0 && s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6] != -1) {
763  for (i = 0; i < 4; i++)
764  AV_COPY32(s->mv_cache[m][scan8[0] - 1 + i * 8],
765  s->cur_pic->motion_val[m][b_xy - 1 + i * s->b_stride]);
766  } else {
767  for (i = 0; i < 4; i++)
768  AV_ZERO32(s->mv_cache[m][scan8[0] - 1 + i * 8]);
769  }
770  if (s->mb_y > 0) {
771  memcpy(s->mv_cache[m][scan8[0] - 1 * 8],
772  s->cur_pic->motion_val[m][b_xy - s->b_stride],
773  4 * 2 * sizeof(int16_t));
774  memset(&s->ref_cache[m][scan8[0] - 1 * 8],
775  (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
776 
777  if (s->mb_x < s->mb_width - 1) {
778  AV_COPY32(s->mv_cache[m][scan8[0] + 4 - 1 * 8],
779  s->cur_pic->motion_val[m][b_xy - s->b_stride + 4]);
780  s->ref_cache[m][scan8[0] + 4 - 1 * 8] =
781  (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
782  s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
783  } else
784  s->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
785  if (s->mb_x > 0) {
786  AV_COPY32(s->mv_cache[m][scan8[0] - 1 - 1 * 8],
787  s->cur_pic->motion_val[m][b_xy - s->b_stride - 1]);
788  s->ref_cache[m][scan8[0] - 1 - 1 * 8] =
789  (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
790  } else
791  s->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
792  } else
793  memset(&s->ref_cache[m][scan8[0] - 1 * 8 - 1],
794  PART_NOT_AVAILABLE, 8);
795 
796  if (s->pict_type != AV_PICTURE_TYPE_B)
797  break;
798  }
799 
800  /* decode motion vector(s) and form prediction(s) */
801  if (s->pict_type == AV_PICTURE_TYPE_P) {
802  if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
803  return -1;
804  } else { /* AV_PICTURE_TYPE_B */
805  if (mb_type != 2) {
806  if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
807  return -1;
808  } else {
809  for (i = 0; i < 4; i++)
810  memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
811  0, 4 * 2 * sizeof(int16_t));
812  }
813  if (mb_type != 1) {
814  if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
815  return -1;
816  } else {
817  for (i = 0; i < 4; i++)
818  memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
819  0, 4 * 2 * sizeof(int16_t));
820  }
821  }
822 
823  mb_type = MB_TYPE_16x16;
824  } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
825  int8_t *i4x4 = s->intra4x4_pred_mode + s->mb2br_xy[s->mb_xy];
826  int8_t *i4x4_cache = s->intra4x4_pred_mode_cache;
827 
828  memset(s->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
829 
830  if (mb_type == 8) {
831  if (s->mb_x > 0) {
832  for (i = 0; i < 4; i++)
833  s->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6 - i];
834  if (s->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
835  s->left_samples_available = 0x5F5F;
836  }
837  if (s->mb_y > 0) {
838  s->intra4x4_pred_mode_cache[4 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 0];
839  s->intra4x4_pred_mode_cache[5 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 1];
840  s->intra4x4_pred_mode_cache[6 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 2];
841  s->intra4x4_pred_mode_cache[7 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 3];
842 
843  if (s->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
844  s->top_samples_available = 0x33FF;
845  }
846 
847  /* decode prediction codes for luma blocks */
848  for (i = 0; i < 16; i += 2) {
849  vlc = get_interleaved_ue_golomb(&s->gb_slice);
850 
851  if (vlc >= 25U) {
852  av_log(s->avctx, AV_LOG_ERROR,
853  "luma prediction:%"PRIu32"\n", vlc);
854  return -1;
855  }
856 
857  left = &s->intra4x4_pred_mode_cache[scan8[i] - 1];
858  top = &s->intra4x4_pred_mode_cache[scan8[i] - 8];
859 
860  left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
861  left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
862 
863  if (left[1] == -1 || left[2] == -1) {
864  av_log(s->avctx, AV_LOG_ERROR, "weird prediction\n");
865  return -1;
866  }
867  }
868  } else { /* mb_type == 33, DC_128_PRED block type */
869  for (i = 0; i < 4; i++)
870  memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
871  }
872 
873  AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
874  i4x4[4] = i4x4_cache[7 + 8 * 3];
875  i4x4[5] = i4x4_cache[7 + 8 * 2];
876  i4x4[6] = i4x4_cache[7 + 8 * 1];
877 
878  if (mb_type == 8) {
879  ff_h264_check_intra4x4_pred_mode(s->intra4x4_pred_mode_cache,
880  s->avctx, s->top_samples_available,
881  s->left_samples_available);
882 
883  s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
884  s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
885  } else {
886  for (i = 0; i < 4; i++)
887  memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
888 
889  s->top_samples_available = 0x33FF;
890  s->left_samples_available = 0x5F5F;
891  }
892 
893  mb_type = MB_TYPE_INTRA4x4;
894  } else { /* INTRA16x16 */
895  dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
896  dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
897 
898  if ((s->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
899  s->left_samples_available, dir, 0)) < 0) {
900  av_log(s->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
901  return s->intra16x16_pred_mode;
902  }
903 
904  cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
905  mb_type = MB_TYPE_INTRA16x16;
906  }
907 
908  if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
909  for (i = 0; i < 4; i++)
910  memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
911  0, 4 * 2 * sizeof(int16_t));
912  if (s->pict_type == AV_PICTURE_TYPE_B) {
913  for (i = 0; i < 4; i++)
914  memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
915  0, 4 * 2 * sizeof(int16_t));
916  }
917  }
918  if (!IS_INTRA4x4(mb_type)) {
919  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy], DC_PRED, 8);
920  }
921  if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
922  memset(s->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
923  }
924 
925  if (!IS_INTRA16x16(mb_type) &&
926  (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
927  if ((vlc = get_interleaved_ue_golomb(&s->gb_slice)) >= 48U){
928  av_log(s->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
929  return -1;
930  }
931 
932  cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
934  }
935  if (IS_INTRA16x16(mb_type) ||
936  (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
937  s->qscale += get_interleaved_se_golomb(&s->gb_slice);
938 
939  if (s->qscale > 31u) {
940  av_log(s->avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
941  return -1;
942  }
943  }
944  if (IS_INTRA16x16(mb_type)) {
945  AV_ZERO128(s->mb_luma_dc[0] + 0);
946  AV_ZERO128(s->mb_luma_dc[0] + 8);
947  if (svq3_decode_block(&s->gb_slice, s->mb_luma_dc[0], 0, 1)) {
948  av_log(s->avctx, AV_LOG_ERROR,
949  "error while decoding intra luma dc\n");
950  return -1;
951  }
952  }
953 
954  if (cbp) {
955  const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
956  const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
957 
958  for (i = 0; i < 4; i++)
959  if ((cbp & (1 << i))) {
960  for (j = 0; j < 4; j++) {
961  k = index ? (1 * (j & 1) + 2 * (i & 1) +
962  2 * (j & 2) + 4 * (i & 2))
963  : (4 * i + j);
964  s->non_zero_count_cache[scan8[k]] = 1;
965 
966  if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], index, type)) {
967  av_log(s->avctx, AV_LOG_ERROR,
968  "error while decoding block\n");
969  return -1;
970  }
971  }
972  }
973 
974  if ((cbp & 0x30)) {
975  for (i = 1; i < 3; ++i)
976  if (svq3_decode_block(&s->gb_slice, &s->mb[16 * 16 * i], 0, 3)) {
977  av_log(s->avctx, AV_LOG_ERROR,
978  "error while decoding chroma dc block\n");
979  return -1;
980  }
981 
982  if ((cbp & 0x20)) {
983  for (i = 1; i < 3; i++) {
984  for (j = 0; j < 4; j++) {
985  k = 16 * i + j;
986  s->non_zero_count_cache[scan8[k]] = 1;
987 
988  if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], 1, 1)) {
989  av_log(s->avctx, AV_LOG_ERROR,
990  "error while decoding chroma ac block\n");
991  return -1;
992  }
993  }
994  }
995  }
996  }
997  }
998 
999  s->cbp = cbp;
1000  s->cur_pic->mb_type[mb_xy] = mb_type;
1001 
1002  if (IS_INTRA(mb_type))
1003  s->chroma_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
1004  s->left_samples_available, DC_PRED8x8, 1);
1005 
1006  return 0;
1007 }
1008 
1010 {
1011  SVQ3Context *s = avctx->priv_data;
1012  const int mb_xy = s->mb_xy;
1013  int i, header;
1014  unsigned slice_id;
1015 
1016  header = get_bits(&s->gb, 8);
1017 
1018  if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
1019  /* TODO: what? */
1020  av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
1021  return -1;
1022  } else {
1023  int slice_bits, slice_bytes, slice_length;
1024  int length = header >> 5 & 3;
1025 
1026  slice_length = show_bits(&s->gb, 8 * length);
1027  slice_bits = slice_length * 8;
1028  slice_bytes = slice_length + length - 1;
1029 
1030  skip_bits(&s->gb, 8);
1031 
1032  av_fast_padded_malloc(&s->slice_buf, &s->slice_buf_size, slice_bytes);
1033  if (!s->slice_buf)
1034  return AVERROR(ENOMEM);
1035 
1036  if (slice_bytes * 8LL > get_bits_left(&s->gb)) {
1037  av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1038  return AVERROR_INVALIDDATA;
1039  }
1040  memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
1041 
1042  if (s->watermark_key) {
1043  uint32_t header = AV_RL32(&s->slice_buf[1]);
1044  AV_WL32(&s->slice_buf[1], header ^ s->watermark_key);
1045  }
1046  init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
1047 
1048  if (length > 0) {
1049  memmove(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1050  }
1051  skip_bits_long(&s->gb, slice_bytes * 8);
1052  }
1053 
1054  if ((slice_id = get_interleaved_ue_golomb(&s->gb_slice)) >= 3) {
1055  av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
1056  return -1;
1057  }
1058 
1059  s->slice_type = ff_h264_golomb_to_pict_type[slice_id];
1060 
1061  if ((header & 0x9F) == 2) {
1062  i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
1063  get_bits(&s->gb_slice, i);
1064  } else if (get_bits1(&s->gb_slice)) {
1065  avpriv_report_missing_feature(s->avctx, "Media key encryption");
1066  return AVERROR_PATCHWELCOME;
1067  }
1068 
1069  s->slice_num = get_bits(&s->gb_slice, 8);
1070  s->qscale = get_bits(&s->gb_slice, 5);
1071  s->adaptive_quant = get_bits1(&s->gb_slice);
1072 
1073  /* unknown fields */
1074  skip_bits1(&s->gb_slice);
1075 
1076  if (s->has_watermark)
1077  skip_bits1(&s->gb_slice);
1078 
1079  skip_bits1(&s->gb_slice);
1080  skip_bits(&s->gb_slice, 2);
1081 
1082  if (skip_1stop_8data_bits(&s->gb_slice) < 0)
1083  return AVERROR_INVALIDDATA;
1084 
1085  /* reset intra predictors and invalidate motion vector references */
1086  if (s->mb_x > 0) {
1087  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - 1] + 3,
1088  -1, 4 * sizeof(int8_t));
1089  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_x],
1090  -1, 8 * sizeof(int8_t) * s->mb_x);
1091  }
1092  if (s->mb_y > 0) {
1093  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_stride],
1094  -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
1095 
1096  if (s->mb_x > 0)
1097  s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1098  }
1099 
1100  return 0;
1101 }
1102 
1104 {
1105  int q, x;
1106  const int max_qp = 51;
1107 
1108  for (q = 0; q < max_qp + 1; q++) {
1109  int shift = ff_h264_quant_div6[q] + 2;
1110  int idx = ff_h264_quant_rem6[q];
1111  for (x = 0; x < 16; x++)
1112  s->dequant4_coeff[q][(x >> 2) | ((x << 2) & 0xF)] =
1113  ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] * 16) << shift;
1114  }
1115 }
1116 
1118 {
1119  SVQ3Context *s = avctx->priv_data;
1120  int m, x, y;
1121  unsigned char *extradata;
1122  unsigned char *extradata_end;
1123  unsigned int size;
1124  int marker_found = 0;
1125  int ret;
1126 
1127  s->cur_pic = &s->frames[0];
1128  s->last_pic = &s->frames[1];
1129  s->next_pic = &s->frames[2];
1130 
1131  s->cur_pic->f = av_frame_alloc();
1132  s->last_pic->f = av_frame_alloc();
1133  s->next_pic->f = av_frame_alloc();
1134  if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1135  return AVERROR(ENOMEM);
1136 
1137  ff_h264dsp_init(&s->h264dsp, 8, 1);
1138  ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1139  ff_videodsp_init(&s->vdsp, 8);
1140 
1141 
1142  avctx->bits_per_raw_sample = 8;
1143 
1144  ff_hpeldsp_init(&s->hdsp, avctx->flags);
1145  ff_tpeldsp_init(&s->tdsp);
1146 
1147  avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1148  avctx->color_range = AVCOL_RANGE_JPEG;
1149 
1150  s->avctx = avctx;
1151  s->halfpel_flag = 1;
1152  s->thirdpel_flag = 1;
1153  s->has_watermark = 0;
1154 
1155  /* prowl for the "SEQH" marker in the extradata */
1156  extradata = (unsigned char *)avctx->extradata;
1157  extradata_end = avctx->extradata + avctx->extradata_size;
1158  if (extradata) {
1159  for (m = 0; m + 8 < avctx->extradata_size; m++) {
1160  if (!memcmp(extradata, "SEQH", 4)) {
1161  marker_found = 1;
1162  break;
1163  }
1164  extradata++;
1165  }
1166  }
1167 
1168  /* if a match was found, parse the extra data */
1169  if (marker_found) {
1170  GetBitContext gb;
1171  int frame_size_code;
1172  int unk0, unk1, unk2, unk3, unk4;
1173  int w,h;
1174 
1175  size = AV_RB32(&extradata[4]);
1176  if (size > extradata_end - extradata - 8)
1177  return AVERROR_INVALIDDATA;
1178  init_get_bits(&gb, extradata + 8, size * 8);
1179 
1180  /* 'frame size code' and optional 'width, height' */
1181  frame_size_code = get_bits(&gb, 3);
1182  switch (frame_size_code) {
1183  case 0:
1184  w = 160;
1185  h = 120;
1186  break;
1187  case 1:
1188  w = 128;
1189  h = 96;
1190  break;
1191  case 2:
1192  w = 176;
1193  h = 144;
1194  break;
1195  case 3:
1196  w = 352;
1197  h = 288;
1198  break;
1199  case 4:
1200  w = 704;
1201  h = 576;
1202  break;
1203  case 5:
1204  w = 240;
1205  h = 180;
1206  break;
1207  case 6:
1208  w = 320;
1209  h = 240;
1210  break;
1211  case 7:
1212  w = get_bits(&gb, 12);
1213  h = get_bits(&gb, 12);
1214  break;
1215  }
1216  ret = ff_set_dimensions(avctx, w, h);
1217  if (ret < 0)
1218  return ret;
1219 
1220  s->halfpel_flag = get_bits1(&gb);
1221  s->thirdpel_flag = get_bits1(&gb);
1222 
1223  /* unknown fields */
1224  unk0 = get_bits1(&gb);
1225  unk1 = get_bits1(&gb);
1226  unk2 = get_bits1(&gb);
1227  unk3 = get_bits1(&gb);
1228 
1229  s->low_delay = get_bits1(&gb);
1230 
1231  /* unknown field */
1232  unk4 = get_bits1(&gb);
1233 
1234  av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1235  unk0, unk1, unk2, unk3, unk4);
1236 
1237  if (skip_1stop_8data_bits(&gb) < 0)
1238  return AVERROR_INVALIDDATA;
1239 
1240  s->has_watermark = get_bits1(&gb);
1241  avctx->has_b_frames = !s->low_delay;
1242  if (s->has_watermark) {
1243 #if CONFIG_ZLIB
1244  unsigned watermark_width = get_interleaved_ue_golomb(&gb);
1245  unsigned watermark_height = get_interleaved_ue_golomb(&gb);
1246  int u1 = get_interleaved_ue_golomb(&gb);
1247  int u2 = get_bits(&gb, 8);
1248  int u3 = get_bits(&gb, 2);
1249  int u4 = get_interleaved_ue_golomb(&gb);
1250  unsigned long buf_len = watermark_width *
1251  watermark_height * 4;
1252  int offset = get_bits_count(&gb) + 7 >> 3;
1253  uint8_t *buf;
1254 
1255  if (watermark_height <= 0 ||
1256  (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
1257  return AVERROR_INVALIDDATA;
1258 
1259  buf = av_malloc(buf_len);
1260  if (!buf)
1261  return AVERROR(ENOMEM);
1262 
1263  av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1264  watermark_width, watermark_height);
1265  av_log(avctx, AV_LOG_DEBUG,
1266  "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1267  u1, u2, u3, u4, offset);
1268  if (uncompress(buf, &buf_len, extradata + 8 + offset,
1269  size - offset) != Z_OK) {
1270  av_log(avctx, AV_LOG_ERROR,
1271  "could not uncompress watermark logo\n");
1272  av_free(buf);
1273  return -1;
1274  }
1275  s->watermark_key = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), 0, buf, buf_len));
1276 
1277  s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1278  av_log(avctx, AV_LOG_DEBUG,
1279  "watermark key %#"PRIx32"\n", s->watermark_key);
1280  av_free(buf);
1281 #else
1282  av_log(avctx, AV_LOG_ERROR,
1283  "this svq3 file contains watermark which need zlib support compiled in\n");
1284  return AVERROR(ENOSYS);
1285 #endif
1286  }
1287  }
1288 
1289  s->mb_width = (avctx->width + 15) / 16;
1290  s->mb_height = (avctx->height + 15) / 16;
1291  s->mb_stride = s->mb_width + 1;
1292  s->mb_num = s->mb_width * s->mb_height;
1293  s->b_stride = 4 * s->mb_width;
1294  s->h_edge_pos = s->mb_width * 16;
1295  s->v_edge_pos = s->mb_height * 16;
1296 
1297  s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1298  if (!s->intra4x4_pred_mode)
1299  return AVERROR(ENOMEM);
1300 
1301  s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1302  sizeof(*s->mb2br_xy));
1303  if (!s->mb2br_xy)
1304  return AVERROR(ENOMEM);
1305 
1306  for (y = 0; y < s->mb_height; y++)
1307  for (x = 0; x < s->mb_width; x++) {
1308  const int mb_xy = x + y * s->mb_stride;
1309 
1310  s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1311  }
1312 
1314 
1315  return 0;
1316 }
1317 
1318 static void free_picture(SVQ3Frame *pic)
1319 {
1320  int i;
1321  for (i = 0; i < 2; i++) {
1322  av_freep(&pic->motion_val_buf[i]);
1323  }
1324  av_freep(&pic->mb_type_buf);
1325 
1326  av_frame_unref(pic->f);
1327 }
1328 
1329 static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
1330 {
1331  SVQ3Context *s = avctx->priv_data;
1332  const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
1333  const int b4_stride = s->mb_width * 4 + 1;
1334  const int b4_array_size = b4_stride * s->mb_height * 4;
1335  int ret;
1336 
1337  if (!pic->motion_val_buf[0]) {
1338  int i;
1339 
1340  pic->mb_type_buf = av_calloc(big_mb_num + s->mb_stride, sizeof(uint32_t));
1341  if (!pic->mb_type_buf)
1342  return AVERROR(ENOMEM);
1343  pic->mb_type = pic->mb_type_buf + 2 * s->mb_stride + 1;
1344 
1345  for (i = 0; i < 2; i++) {
1346  pic->motion_val_buf[i] = av_calloc(b4_array_size + 4, 2 * sizeof(int16_t));
1347  if (!pic->motion_val_buf[i]) {
1348  ret = AVERROR(ENOMEM);
1349  goto fail;
1350  }
1351 
1352  pic->motion_val[i] = pic->motion_val_buf[i] + 4;
1353  }
1354  }
1355 
1356  ret = ff_get_buffer(avctx, pic->f,
1357  (s->pict_type != AV_PICTURE_TYPE_B) ?
1359  if (ret < 0)
1360  goto fail;
1361 
1362  if (!s->edge_emu_buffer) {
1363  s->edge_emu_buffer = av_calloc(pic->f->linesize[0], 17);
1364  if (!s->edge_emu_buffer)
1365  return AVERROR(ENOMEM);
1366  }
1367 
1368  return 0;
1369 fail:
1370  free_picture(pic);
1371  return ret;
1372 }
1373 
1374 static int svq3_decode_frame(AVCodecContext *avctx, AVFrame *rframe,
1375  int *got_frame, AVPacket *avpkt)
1376 {
1377  SVQ3Context *s = avctx->priv_data;
1378  int buf_size = avpkt->size;
1379  int left;
1380  int ret, m, i;
1381 
1382  /* special case for last picture */
1383  if (buf_size == 0) {
1384  if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1385  ret = av_frame_ref(rframe, s->next_pic->f);
1386  if (ret < 0)
1387  return ret;
1388  s->last_frame_output = 1;
1389  *got_frame = 1;
1390  }
1391  return 0;
1392  }
1393 
1394  s->mb_x = s->mb_y = s->mb_xy = 0;
1395 
1396  ret = init_get_bits8(&s->gb, avpkt->data, avpkt->size);
1397  if (ret < 0)
1398  return ret;
1399 
1400  if (svq3_decode_slice_header(avctx))
1401  return -1;
1402 
1403  s->pict_type = s->slice_type;
1404 
1405  if (s->pict_type != AV_PICTURE_TYPE_B)
1406  FFSWAP(SVQ3Frame*, s->next_pic, s->last_pic);
1407 
1408  av_frame_unref(s->cur_pic->f);
1409 
1410  /* for skipping the frame */
1411  s->cur_pic->f->pict_type = s->pict_type;
1412  s->cur_pic->f->key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1413 
1414  ret = get_buffer(avctx, s->cur_pic);
1415  if (ret < 0)
1416  return ret;
1417 
1418  for (i = 0; i < 16; i++) {
1419  s->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1420  s->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1421  }
1422  for (i = 0; i < 16; i++) {
1423  s->block_offset[16 + i] =
1424  s->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1425  s->block_offset[48 + 16 + i] =
1426  s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1427  }
1428 
1429  if (s->pict_type != AV_PICTURE_TYPE_I) {
1430  if (!s->last_pic->f->data[0]) {
1431  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1432  av_frame_unref(s->last_pic->f);
1433  ret = get_buffer(avctx, s->last_pic);
1434  if (ret < 0)
1435  return ret;
1436  memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1437  memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1438  s->last_pic->f->linesize[1]);
1439  memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1440  s->last_pic->f->linesize[2]);
1441  }
1442 
1443  if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1444  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1445  av_frame_unref(s->next_pic->f);
1446  ret = get_buffer(avctx, s->next_pic);
1447  if (ret < 0)
1448  return ret;
1449  memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1450  memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1451  s->next_pic->f->linesize[1]);
1452  memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1453  s->next_pic->f->linesize[2]);
1454  }
1455  }
1456 
1457  if (avctx->debug & FF_DEBUG_PICT_INFO)
1458  av_log(s->avctx, AV_LOG_DEBUG,
1459  "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1460  av_get_picture_type_char(s->pict_type),
1461  s->halfpel_flag, s->thirdpel_flag,
1462  s->adaptive_quant, s->qscale, s->slice_num);
1463 
1464  if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1465  avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1466  avctx->skip_frame >= AVDISCARD_ALL)
1467  return 0;
1468 
1469  if (s->pict_type == AV_PICTURE_TYPE_B) {
1470  s->frame_num_offset = s->slice_num - s->prev_frame_num;
1471 
1472  if (s->frame_num_offset < 0)
1473  s->frame_num_offset += 256;
1474  if (s->frame_num_offset == 0 ||
1475  s->frame_num_offset >= s->prev_frame_num_offset) {
1476  av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1477  return -1;
1478  }
1479  } else {
1480  s->prev_frame_num = s->frame_num;
1481  s->frame_num = s->slice_num;
1482  s->prev_frame_num_offset = s->frame_num - s->prev_frame_num;
1483 
1484  if (s->prev_frame_num_offset < 0)
1485  s->prev_frame_num_offset += 256;
1486  }
1487 
1488  for (m = 0; m < 2; m++) {
1489  int i;
1490  for (i = 0; i < 4; i++) {
1491  int j;
1492  for (j = -1; j < 4; j++)
1493  s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1494  if (i < 3)
1495  s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1496  }
1497  }
1498 
1499  for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1500  for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1501  unsigned mb_type;
1502  s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1503 
1504  if ((get_bits_left(&s->gb_slice)) <= 7) {
1505  if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1506  show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1507 
1508  if (svq3_decode_slice_header(avctx))
1509  return -1;
1510  }
1511  if (s->slice_type != s->pict_type) {
1512  avpriv_request_sample(avctx, "non constant slice type");
1513  }
1514  /* TODO: support s->mb_skip_run */
1515  }
1516 
1517  mb_type = get_interleaved_ue_golomb(&s->gb_slice);
1518 
1519  if (s->pict_type == AV_PICTURE_TYPE_I)
1520  mb_type += 8;
1521  else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1522  mb_type += 4;
1523  if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1524  av_log(s->avctx, AV_LOG_ERROR,
1525  "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1526  return -1;
1527  }
1528 
1529  if (mb_type != 0 || s->cbp)
1530  hl_decode_mb(s);
1531 
1532  if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1533  s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1534  (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1535  }
1536 
1537  ff_draw_horiz_band(avctx, s->cur_pic->f,
1538  s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1539  16 * s->mb_y, 16, PICT_FRAME, 0,
1540  s->low_delay);
1541  }
1542 
1543  left = buf_size*8 - get_bits_count(&s->gb_slice);
1544 
1545  if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1546  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);
1547  //av_hex_dump(stderr, buf+buf_size-8, 8);
1548  }
1549 
1550  if (left < 0) {
1551  av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1552  return -1;
1553  }
1554 
1555  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1556  ret = av_frame_ref(rframe, s->cur_pic->f);
1557  else if (s->last_pic->f->data[0])
1558  ret = av_frame_ref(rframe, s->last_pic->f);
1559  if (ret < 0)
1560  return ret;
1561 
1562  /* Do not output the last pic after seeking. */
1563  if (s->last_pic->f->data[0] || s->low_delay)
1564  *got_frame = 1;
1565 
1566  if (s->pict_type != AV_PICTURE_TYPE_B) {
1567  FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1568  } else {
1569  av_frame_unref(s->cur_pic->f);
1570  }
1571 
1572  return buf_size;
1573 }
1574 
1576 {
1577  SVQ3Context *s = avctx->priv_data;
1578 
1579  for (int i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
1580  free_picture(&s->frames[i]);
1581  av_frame_free(&s->frames[i].f);
1582  }
1583  av_freep(&s->slice_buf);
1584  av_freep(&s->intra4x4_pred_mode);
1585  av_freep(&s->edge_emu_buffer);
1586  av_freep(&s->mb2br_xy);
1587 
1588  return 0;
1589 }
1590 
1592  .p.name = "svq3",
1593  .p.long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1594  .p.type = AVMEDIA_TYPE_VIDEO,
1595  .p.id = AV_CODEC_ID_SVQ3,
1596  .priv_data_size = sizeof(SVQ3Context),
1598  .close = svq3_decode_end,
1600  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1603  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1604  AV_PIX_FMT_NONE},
1606 };
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
SVQ3Context::frame_num
int frame_num
Definition: svq3.c:111
SVQ3Context::edge_emu_buffer
uint8_t * edge_emu_buffer
Definition: svq3.c:137
IS_INTRA4x4
#define IS_INTRA4x4(a)
Definition: mpegutils.h:68
svq3_dequant_coeff
static const uint32_t svq3_dequant_coeff[32]
Definition: svq3.c:214
SVQ3Context::next_pic
SVQ3Frame * next_pic
Definition: svq3.c:94
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:292
SVQ3Context::slice_type
enum AVPictureType slice_type
Definition: svq3.c:117
SVQ3Context::gb_slice
GetBitContext gb_slice
Definition: svq3.c:97
SVQ3Context::vdsp
VideoDSPContext vdsp
Definition: svq3.c:91
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
SVQ3Context::slice_num
int slice_num
Definition: svq3.c:108
level
uint8_t level
Definition: svq3.c:206
av_clip
#define av_clip
Definition: common.h:95
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:39
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
DC_PRED8x8
#define DC_PRED8x8
Definition: h264pred.h:68
svq3_decode_slice_header
static int svq3_decode_slice_header(AVCodecContext *avctx)
Definition: svq3.c:1009
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
mem_internal.h
SVQ3Context::avctx
AVCodecContext * avctx
Definition: svq3.c:85
DC_128_PRED
@ DC_128_PRED
Definition: vp9.h:58
SVQ3Context::mb_num
int mb_num
Definition: svq3.c:123
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
SVQ3Context::v_edge_pos
int v_edge_pos
Definition: svq3.c:106
AVPictureType
AVPictureType
Definition: avutil.h:272
ff_h264_chroma_qp
const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1]
Definition: h264data.c:203
mv
static const int8_t mv[256][2]
Definition: 4xm.c:80
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
SVQ3Context::left_samples_available
unsigned int left_samples_available
Definition: svq3.c:135
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
get_interleaved_ue_golomb
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
Definition: golomb.h:143
ff_h264_golomb_to_inter_cbp
const uint8_t ff_h264_golomb_to_inter_cbp[48]
Definition: h264data.c:48
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
h264_parse.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
SVQ3Context::h_edge_pos
int h_edge_pos
Definition: svq3.c:105
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:599
IMbInfo::cbp
uint8_t cbp
Definition: h264data.h:37
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
DC_PRED
@ DC_PRED
Definition: vp9.h:48
MB_TYPE_INTRA4x4
#define MB_TYPE_INTRA4x4
Definition: mpegutils.h:44
SVQ3Context::slice_buf
uint8_t * slice_buf
Definition: svq3.c:98
VERT_LEFT_PRED
@ VERT_LEFT_PRED
Definition: vp9.h:53
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:47
SVQ3Context::mb
int16_t mb[16 *48 *2]
Definition: svq3.c:141
PREDICT_MODE
#define PREDICT_MODE
Definition: svq3.c:152
FFCodec
Definition: codec_internal.h:112
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
ff_h264_golomb_to_intra4x4_cbp
const uint8_t ff_h264_golomb_to_intra4x4_cbp[48]
Definition: h264data.c:42
SVQ3Context::frame_num_offset
int frame_num_offset
Definition: svq3.c:112
mpegutils.h
MB_TYPE_INTRA16x16
#define MB_TYPE_INTRA16x16
Definition: mpegutils.h:45
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
SVQ3Context::slice_buf_size
unsigned slice_buf_size
Definition: svq3.c:99
SVQ3Context::last_frame_output
int last_frame_output
Definition: svq3.c:107
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1323
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
get_buffer
static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
Definition: svq3.c:1329
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
init
static int init
Definition: av_tx.c:47
A
#define A(x)
Definition: vp56_arith.h:28
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
SVQ3Context::last_pic
SVQ3Frame * last_pic
Definition: svq3.c:95
SVQ3Context::qscale
int qscale
Definition: svq3.c:109
U
#define U(x)
Definition: vp56_arith.h:37
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1696
fail
#define fail()
Definition: checkasm.h:130
GetBitContext
Definition: get_bits.h:62
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:469
SVQ3Context::tdsp
TpelDSPContext tdsp
Definition: svq3.c:90
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:39
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
scan8
static const uint8_t scan8[16 *3+3]
Definition: h264_parse.h:40
SVQ3Context::thirdpel_flag
int thirdpel_flag
Definition: svq3.c:101
ff_h264_golomb_to_pict_type
const uint8_t ff_h264_golomb_to_pict_type[5]
Definition: h264data.c:37
pack16to32
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264_parse.h:127
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
SVQ3Context::intra4x4_pred_mode_cache
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: svq3.c:131
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
SVQ3Context::gb
GetBitContext gb
Definition: svq3.c:96
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
SVQ3Context::frames
SVQ3Frame frames[3]
Definition: svq3.c:146
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
SVQ3Context::cbp
int cbp
Definition: svq3.c:110
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
FULLPEL_MODE
#define FULLPEL_MODE
Definition: svq3.c:149
SVQ3Context::mb_y
int mb_y
Definition: svq3.c:120
SVQ3Context::mb_x
int mb_x
Definition: svq3.c:120
SVQ3Context::adaptive_quant
int adaptive_quant
Definition: svq3.c:104
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:491
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:685
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
s
#define s(width, name)
Definition: cbs_vp9.c:256
TpelDSPContext
thirdpel DSP context
Definition: tpeldsp.h:42
SVQ3Context::pict_type
enum AVPictureType pict_type
Definition: svq3.c:116
AV_ZERO32
#define AV_ZERO32(d)
Definition: intreadwrite.h:629
svq3_mc_dir
static int svq3_mc_dir(SVQ3Context *s, int size, int mode, int dir, int avg)
Definition: svq3.c:501
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:367
ff_tpeldsp_init
av_cold void ff_tpeldsp_init(TpelDSPContext *c)
Definition: tpeldsp.c:312
QP_MAX_NUM
#define QP_MAX_NUM
Definition: h264.h:27
h264data.h
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1448
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
svq3_pred_motion
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:377
IS_SKIP
#define IS_SKIP(a)
Definition: mpegutils.h:74
SVQ3Context::top_samples_available
unsigned int top_samples_available
Definition: svq3.c:134
IS_INTRA
#define IS_INTRA(x, y)
AV_CODEC_ID_SVQ3
@ AV_CODEC_ID_SVQ3
Definition: codec_id.h:73
SVQ3Context::b_stride
int b_stride
Definition: svq3.c:124
SVQ3Context::prev_frame_num_offset
int prev_frame_num_offset
Definition: svq3.c:113
SVQ3Frame::mb_type_buf
uint32_t * mb_type_buf
Definition: svq3.c:81
SVQ3Context::h264dsp
H264DSPContext h264dsp
Definition: svq3.c:87
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
IMbInfo::pred_mode
uint8_t pred_mode
Definition: h264data.h:36
if
if(ret)
Definition: filter_design.txt:179
SVQ3Frame::motion_val
int16_t(*[2] motion_val)[2]
Definition: svq3.c:79
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:205
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:973
SVQ3Context::mb_width
int mb_width
Definition: svq3.c:122
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
SVQ3Context::mb2br_xy
uint32_t * mb2br_xy
Definition: svq3.c:126
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
h264dsp.h
mathops.h
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
ff_h264_chroma_dc_scan
const uint8_t ff_h264_chroma_dc_scan[4]
Definition: h264data.c:54
SVQ3Context
Definition: svq3.c:84
AV_ZERO128
#define AV_ZERO128(d)
Definition: intreadwrite.h:637
SVQ3Context::mb_luma_dc
int16_t mb_luma_dc[3][16 *2]
Definition: svq3.c:142
tpeldsp.h
index
int index
Definition: gxfenc.c:89
hl_decode_mb_idct_luma
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:614
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
H264DSPContext
Context for storing H.264 DSP functions.
Definition: h264dsp.h:42
SVQ3Context::intra16x16_pred_mode
int intra16x16_pred_mode
Definition: svq3.c:129
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:53
SVQ3Context::hpc
H264PredContext hpc
Definition: svq3.c:88
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1403
init_dequant4_coeff_table
static void init_dequant4_coeff_table(SVQ3Context *s)
Definition: svq3.c:1103
ff_zigzag_scan
const uint8_t ff_zigzag_scan[16+1]
Definition: mathtables.c:109
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
svq3_fetch_diagonal_mv
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:356
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:249
AVPacket::size
int size
Definition: packet.h:375
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:116
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:343
codec_internal.h
ff_draw_horiz_band
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
rectangle.h
hl_decode_mb
static void hl_decode_mb(SVQ3Context *s)
Definition: svq3.c:663
get_interleaved_se_golomb
static int get_interleaved_se_golomb(GetBitContext *gb)
Definition: golomb.h:301
free_picture
static void free_picture(SVQ3Frame *pic)
Definition: svq3.c:1318
size
int size
Definition: twinvq_data.h:10344
SVQ3Frame::mb_type
uint32_t * mb_type
Definition: svq3.c:81
AV_RB32
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:96
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:55
avg
#define avg(a, b, c, d)
Definition: colorspacedsp_template.c:28
header
static const uint8_t header[24]
Definition: sdr2.c:67
height
#define height
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
av_bswap16
#define av_bswap16
Definition: bswap.h:31
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
attributes.h
ff_h264_quant_rem6
const uint8_t ff_h264_quant_rem6[QP_MAX_NUM+1]
Definition: h264data.c:174
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:539
IS_INTRA16x16
#define IS_INTRA16x16(a)
Definition: mpegutils.h:69
hl_decode_mb_predict_luma
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:629
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
SVQ3Frame::motion_val_buf
int16_t(*[2] motion_val_buf)[2]
Definition: svq3.c:78
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
SVQ3Context::prev_frame_num
int prev_frame_num
Definition: svq3.c:114
svq3_add_idct_c
static void svq3_add_idct_c(uint8_t *dst, int16_t *block, int stride, int qp, int dc)
Definition: svq3.c:256
av_get_picture_type_char
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:40
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
svq3_luma_dc_dequant_idct_c
static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
Definition: svq3.c:221
stride
#define stride
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AV_CRC_16_CCITT
@ AV_CRC_16_CCITT
Definition: crc.h:51
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:490
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:447
SVQ3Frame
Definition: svq3.c:75
THIRDPEL_MODE
#define THIRDPEL_MODE
Definition: svq3.c:151
SVQ3Context::mv_cache
int16_t mv_cache[2][5 *8][2]
Definition: svq3.c:139
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:48
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: codec_internal.h:31
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:477
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AV_COPY32
#define AV_COPY32(d, s)
Definition: intreadwrite.h:601
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
svq3_decode_frame
static int svq3_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
Definition: svq3.c:1374
SVQ3Context::non_zero_count_cache
uint8_t non_zero_count_cache[15 *8]
Definition: svq3.c:143
AVCodecContext::height
int height
Definition: avcodec.h:562
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
svq3_dct_tables
static const struct @132 svq3_dct_tables[2][16]
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
svq3_decode_mb
static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
Definition: svq3.c:711
svq3_scan
static const uint8_t svq3_scan[16]
Definition: svq3.c:163
avcodec.h
limit
static double limit(double x)
Definition: vf_pseudocolor.c:128
ff_h264dsp_init
av_cold void ff_h264dsp_init(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)
Definition: h264dsp.c:66
SVQ3Context::halfpel_flag
int halfpel_flag
Definition: svq3.c:100
mid_pred
#define mid_pred
Definition: mathops.h:97
svq3_pred_1
static const int8_t svq3_pred_1[6][6][5]
Definition: svq3.c:189
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
SVQ3Context::mb_height
int mb_height
Definition: svq3.c:122
SVQ3Context::hdsp
HpelDSPContext hdsp
Definition: svq3.c:89
SVQ3Context::low_delay
int low_delay
Definition: svq3.c:118
h264pred.h
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
svq3_decode_block
static int svq3_decode_block(GetBitContext *gb, int16_t *block, int index, const int type)
Definition: svq3.c:296
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
B
#define B
Definition: huffyuvdsp.h:32
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:855
AVCodecContext
main external API structure.
Definition: avcodec.h:389
ff_h264_dequant4_coeff_init
const uint8_t ff_h264_dequant4_coeff_init[6][3]
Definition: h264data.c:152
SVQ3Frame::f
AVFrame * f
Definition: svq3.c:76
SVQ3Context::block_offset
int block_offset[2 *(16 *3)]
Definition: svq3.c:145
ff_h264_pred_init
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:437
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
mode
mode
Definition: ebur128.h:83
ff_h264_check_intra4x4_pred_mode
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:133
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
ff_h264_i_mb_type_info
const IMbInfo ff_h264_i_mb_type_info[26]
Definition: h264data.c:66
fill_rectangle
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:814
svq1.h
SVQ3Context::chroma_pred_mode
int chroma_pred_mode
Definition: svq3.c:128
SVQ3Context::watermark_key
uint32_t watermark_key
Definition: svq3.c:103
SVQ3Context::mb_xy
int mb_xy
Definition: svq3.c:121
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
temp
else temp
Definition: vf_mcdeint.c:248
AV_CODEC_CAP_DELAY
#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: codec.h:82
luma_dc_zigzag_scan
static const uint8_t luma_dc_zigzag_scan[16]
Definition: svq3.c:170
PART_NOT_AVAILABLE
#define PART_NOT_AVAILABLE
Definition: h264pred.h:89
av_clip_uint8
#define av_clip_uint8
Definition: common.h:101
ff_h264_quant_div6
const uint8_t ff_h264_quant_div6[QP_MAX_NUM+1]
Definition: h264data.c:182
VideoDSPContext
Definition: videodsp.h:41
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1322
H264PredContext
Context for storing H.264 prediction functions.
Definition: h264pred.h:94
shift
static int shift(int a, int b)
Definition: sonic.c:88
svq3_mc_dir_part
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:426
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
IS_INTER
#define IS_INTER(a)
Definition: mpegutils.h:72
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:90
svq3_decode_end
static av_cold int svq3_decode_end(AVCodecContext *avctx)
Definition: svq3.c:1575
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1037
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
SVQ3Context::dequant4_coeff
uint32_t dequant4_coeff[QP_MAX_NUM+1][16]
Definition: svq3.c:144
SVQ3Context::ref_cache
int8_t ref_cache[2][5 *8]
Definition: svq3.c:140
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
videodsp.h
SVQ3Context::mb_stride
int mb_stride
Definition: svq3.c:123
DIAG_DOWN_LEFT_PRED
@ DIAG_DOWN_LEFT_PRED
Definition: vp9.h:49
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:562
int32_t
int32_t
Definition: audioconvert.c:56
hpeldsp.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
svq3_decode_init
static av_cold int svq3_decode_init(AVCodecContext *avctx)
Definition: svq3.c:1117
h
h
Definition: vp9dsp_template.c:2038
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:50
ff_svq3_decoder
const FFCodec ff_svq3_decoder
Definition: svq3.c:1591
int
int
Definition: ffmpeg_filter.c:153
SVQ3Context::cur_pic
SVQ3Frame * cur_pic
Definition: svq3.c:93
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
SVQ3Context::has_watermark
int has_watermark
Definition: svq3.c:102
SVQ3Context::intra4x4_pred_mode
int8_t * intra4x4_pred_mode
Definition: svq3.c:132
svq3_pred_0
static const uint8_t svq3_pred_0[25][2]
Definition: svq3.c:177
HALFPEL_MODE
#define HALFPEL_MODE
Definition: svq3.c:150
ff_h264_check_intra_pred_mode
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:181