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.h"
48 #include "libavutil/mem_internal.h"
49 
50 #include "codec_internal.h"
51 #include "decode.h"
52 #include "avcodec.h"
53 #include "mpegutils.h"
54 #include "h264data.h"
55 #include "h264dsp.h"
56 #include "h264pred.h"
57 #include "h264_parse.h"
58 #include "golomb.h"
59 #include "hpeldsp.h"
60 #include "mathops.h"
61 #include "rectangle.h"
62 #include "tpeldsp.h"
63 #include "videodsp.h"
64 
65 #if CONFIG_ZLIB
66 #include <zlib.h>
67 #endif
68 
69 /**
70  * @file
71  * svq3 decoder.
72  */
73 
74 typedef struct SVQ3Frame {
76 
77  int16_t (*motion_val_buf[2])[2];
78  int16_t (*motion_val[2])[2];
79 
80  uint32_t *mb_type_buf, *mb_type;
81 } SVQ3Frame;
82 
83 typedef struct SVQ3Context {
85 
91 
97  uint8_t *slice_buf;
98  unsigned slice_buf_size;
102  uint32_t watermark_key;
108  int qscale;
109  int cbp;
114 
118 
119  int mb_x, mb_y;
120  int mb_xy;
123  int b_stride;
124 
125  uint32_t *mb2br_xy;
126 
129 
132 
133  unsigned int top_samples_available;
135 
136  uint8_t *edge_emu_buffer;
137 
138  DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
139  DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8];
140  DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
141  DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
142  DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
143  uint32_t dequant4_coeff[QP_MAX_NUM + 1][16];
144  int block_offset[2 * (16 * 3)];
146 } SVQ3Context;
147 
148 #define FULLPEL_MODE 1
149 #define HALFPEL_MODE 2
150 #define THIRDPEL_MODE 3
151 #define PREDICT_MODE 4
152 
153 /* dual scan (from some older H.264 draft)
154  * o-->o-->o o
155  * | /|
156  * o o o / o
157  * | / | |/ |
158  * o o o o
159  * /
160  * o-->o-->o-->o
161  */
162 static const uint8_t svq3_scan[16] = {
163  0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
164  2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
165  0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
166  0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
167 };
168 
169 static const uint8_t luma_dc_zigzag_scan[16] = {
170  0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
171  3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
172  1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
173  3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
174 };
175 
176 static const uint8_t svq3_pred_0[25][2] = {
177  { 0, 0 },
178  { 1, 0 }, { 0, 1 },
179  { 0, 2 }, { 1, 1 }, { 2, 0 },
180  { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
181  { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
182  { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
183  { 2, 4 }, { 3, 3 }, { 4, 2 },
184  { 4, 3 }, { 3, 4 },
185  { 4, 4 }
186 };
187 
188 static const int8_t svq3_pred_1[6][6][5] = {
189  { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
190  { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
191  { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
192  { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
193  { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
194  { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
195  { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
196  { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
197  { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
198  { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
199  { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
200  { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
201 };
202 
203 static const struct {
204  uint8_t run;
205  uint8_t level;
206 } svq3_dct_tables[2][16] = {
207  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
208  { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
209  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
210  { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
211 };
212 
213 static const uint32_t svq3_dequant_coeff[32] = {
214  3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
215  9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
216  24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
217  61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
218 };
219 
220 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
221 {
222  const unsigned qmul = svq3_dequant_coeff[qp];
223 #define stride 16
224  int i;
225  int temp[16];
226  static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
227 
228  for (i = 0; i < 4; i++) {
229  const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
230  const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
231  const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
232  const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
233 
234  temp[4 * i + 0] = z0 + z3;
235  temp[4 * i + 1] = z1 + z2;
236  temp[4 * i + 2] = z1 - z2;
237  temp[4 * i + 3] = z0 - z3;
238  }
239 
240  for (i = 0; i < 4; i++) {
241  const int offset = x_offset[i];
242  const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
243  const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
244  const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
245  const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
246 
247  output[stride * 0 + offset] = (int)((z0 + z3) * qmul + 0x80000) >> 20;
248  output[stride * 2 + offset] = (int)((z1 + z2) * qmul + 0x80000) >> 20;
249  output[stride * 8 + offset] = (int)((z1 - z2) * qmul + 0x80000) >> 20;
250  output[stride * 10 + offset] = (int)((z0 - z3) * qmul + 0x80000) >> 20;
251  }
252 }
253 #undef stride
254 
255 static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
256  int stride, int qp, int dc)
257 {
258  const int qmul = svq3_dequant_coeff[qp];
259  int i;
260 
261  if (dc) {
262  dc = 13 * 13 * (dc == 1 ? 1538U* block[0]
263  : qmul * (block[0] >> 3) / 2);
264  block[0] = 0;
265  }
266 
267  for (i = 0; i < 4; i++) {
268  const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
269  const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
270  const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
271  const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
272 
273  block[0 + 4 * i] = z0 + z3;
274  block[1 + 4 * i] = z1 + z2;
275  block[2 + 4 * i] = z1 - z2;
276  block[3 + 4 * i] = z0 - z3;
277  }
278 
279  for (i = 0; i < 4; i++) {
280  const unsigned z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
281  const unsigned z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
282  const unsigned z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
283  const unsigned z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
284  const int rr = (dc + 0x80000u);
285 
286  dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((int)((z0 + z3) * qmul + rr) >> 20));
287  dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((int)((z1 + z2) * qmul + rr) >> 20));
288  dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((int)((z1 - z2) * qmul + rr) >> 20));
289  dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((int)((z0 - z3) * qmul + rr) >> 20));
290  }
291 
292  memset(block, 0, 16 * sizeof(int16_t));
293 }
294 
295 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
296  int index, const int type)
297 {
298  static const uint8_t *const scan_patterns[4] = {
300  };
301 
302  int run, level, sign, limit;
303  unsigned vlc;
304  const int intra = 3 * type >> 2;
305  const uint8_t *const scan = scan_patterns[type];
306 
307  for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
308  for (; (vlc = get_interleaved_ue_golomb(gb)) != 0; index++) {
309  if ((int32_t)vlc < 0)
310  return -1;
311 
312  sign = (vlc & 1) ? 0 : -1;
313  vlc = vlc + 1 >> 1;
314 
315  if (type == 3) {
316  if (vlc < 3) {
317  run = 0;
318  level = vlc;
319  } else if (vlc < 4) {
320  run = 1;
321  level = 1;
322  } else {
323  run = vlc & 0x3;
324  level = (vlc + 9 >> 2) - run;
325  }
326  } else {
327  if (vlc < 16U) {
328  run = svq3_dct_tables[intra][vlc].run;
329  level = svq3_dct_tables[intra][vlc].level;
330  } else if (intra) {
331  run = vlc & 0x7;
332  level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
333  } else {
334  run = vlc & 0xF;
335  level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
336  }
337  }
338 
339 
340  if ((index += run) >= limit)
341  return -1;
342 
343  block[scan[index]] = (level ^ sign) - sign;
344  }
345 
346  if (type != 2) {
347  break;
348  }
349  }
350 
351  return 0;
352 }
353 
354 static av_always_inline int
355 svq3_fetch_diagonal_mv(const SVQ3Context *s, const int16_t **C,
356  int i, int list, int part_width)
357 {
358  const int topright_ref = s->ref_cache[list][i - 8 + part_width];
359 
360  if (topright_ref != PART_NOT_AVAILABLE) {
361  *C = s->mv_cache[list][i - 8 + part_width];
362  return topright_ref;
363  } else {
364  *C = s->mv_cache[list][i - 8 - 1];
365  return s->ref_cache[list][i - 8 - 1];
366  }
367 }
368 
369 /**
370  * Get the predicted MV.
371  * @param n the block index
372  * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
373  * @param mx the x component of the predicted motion vector
374  * @param my the y component of the predicted motion vector
375  */
376 static av_always_inline void svq3_pred_motion(const SVQ3Context *s, int n,
377  int part_width, int list,
378  int ref, int *const mx, int *const my)
379 {
380  const int index8 = scan8[n];
381  const int top_ref = s->ref_cache[list][index8 - 8];
382  const int left_ref = s->ref_cache[list][index8 - 1];
383  const int16_t *const A = s->mv_cache[list][index8 - 1];
384  const int16_t *const B = s->mv_cache[list][index8 - 8];
385  const int16_t *C;
386  int diagonal_ref, match_count;
387 
388 /* mv_cache
389  * B . . A T T T T
390  * U . . L . . , .
391  * U . . L . . . .
392  * U . . L . . , .
393  * . . . L . . . .
394  */
395 
396  diagonal_ref = svq3_fetch_diagonal_mv(s, &C, index8, list, part_width);
397  match_count = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
398  if (match_count > 1) { //most common
399  *mx = mid_pred(A[0], B[0], C[0]);
400  *my = mid_pred(A[1], B[1], C[1]);
401  } else if (match_count == 1) {
402  if (left_ref == ref) {
403  *mx = A[0];
404  *my = A[1];
405  } else if (top_ref == ref) {
406  *mx = B[0];
407  *my = B[1];
408  } else {
409  *mx = C[0];
410  *my = C[1];
411  }
412  } else {
413  if (top_ref == PART_NOT_AVAILABLE &&
414  diagonal_ref == PART_NOT_AVAILABLE &&
415  left_ref != PART_NOT_AVAILABLE) {
416  *mx = A[0];
417  *my = A[1];
418  } else {
419  *mx = mid_pred(A[0], B[0], C[0]);
420  *my = mid_pred(A[1], B[1], C[1]);
421  }
422  }
423 }
424 
425 static inline void svq3_mc_dir_part(SVQ3Context *s,
426  int x, int y, int width, int height,
427  int mx, int my, int dxy,
428  int thirdpel, int dir, int avg)
429 {
430  const SVQ3Frame *pic = (dir == 0) ? s->last_pic : s->next_pic;
431  uint8_t *src, *dest;
432  int i, emu = 0;
433  int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
434  int linesize = s->cur_pic->f->linesize[0];
435  int uvlinesize = s->cur_pic->f->linesize[1];
436 
437  mx += x;
438  my += y;
439 
440  if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
441  my < 0 || my >= s->v_edge_pos - height - 1) {
442  emu = 1;
443  mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
444  my = av_clip(my, -16, s->v_edge_pos - height + 15);
445  }
446 
447  /* form component predictions */
448  dest = s->cur_pic->f->data[0] + x + y * linesize;
449  src = pic->f->data[0] + mx + my * linesize;
450 
451  if (emu) {
452  s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
453  linesize, linesize,
454  width + 1, height + 1,
455  mx, my, s->h_edge_pos, s->v_edge_pos);
456  src = s->edge_emu_buffer;
457  }
458  if (thirdpel)
459  (avg ? s->tdsp.avg_tpel_pixels_tab
460  : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, linesize,
461  width, height);
462  else
463  (avg ? s->hdsp.avg_pixels_tab
464  : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, linesize,
465  height);
466 
467  if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
468  mx = mx + (mx < (int) x) >> 1;
469  my = my + (my < (int) y) >> 1;
470  width = width >> 1;
471  height = height >> 1;
472  blocksize++;
473 
474  for (i = 1; i < 3; i++) {
475  dest = s->cur_pic->f->data[i] + (x >> 1) + (y >> 1) * uvlinesize;
476  src = pic->f->data[i] + mx + my * uvlinesize;
477 
478  if (emu) {
479  s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
480  uvlinesize, uvlinesize,
481  width + 1, height + 1,
482  mx, my, (s->h_edge_pos >> 1),
483  s->v_edge_pos >> 1);
484  src = s->edge_emu_buffer;
485  }
486  if (thirdpel)
487  (avg ? s->tdsp.avg_tpel_pixels_tab
488  : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
489  uvlinesize,
490  width, height);
491  else
492  (avg ? s->hdsp.avg_pixels_tab
493  : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
494  uvlinesize,
495  height);
496  }
497  }
498 }
499 
500 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
501  int dir, int avg)
502 {
503  int i, j, k, mx, my, dx, dy, x, y;
504  const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
505  const int part_height = 16 >> ((unsigned)(size + 1) / 3);
506  const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
507  const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
508  const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
509 
510  for (i = 0; i < 16; i += part_height)
511  for (j = 0; j < 16; j += part_width) {
512  const int b_xy = (4 * s->mb_x + (j >> 2)) +
513  (4 * s->mb_y + (i >> 2)) * s->b_stride;
514  int dxy;
515  x = 16 * s->mb_x + j;
516  y = 16 * s->mb_y + i;
517  k = (j >> 2 & 1) + (i >> 1 & 2) +
518  (j >> 1 & 4) + (i & 8);
519 
520  if (mode != PREDICT_MODE) {
521  svq3_pred_motion(s, k, part_width >> 2, dir, 1, &mx, &my);
522  } else {
523  mx = s->next_pic->motion_val[0][b_xy][0] * 2;
524  my = s->next_pic->motion_val[0][b_xy][1] * 2;
525 
526  if (dir == 0) {
527  mx = mx * s->frame_num_offset /
528  s->prev_frame_num_offset + 1 >> 1;
529  my = my * s->frame_num_offset /
530  s->prev_frame_num_offset + 1 >> 1;
531  } else {
532  mx = mx * (s->frame_num_offset - s->prev_frame_num_offset) /
533  s->prev_frame_num_offset + 1 >> 1;
534  my = my * (s->frame_num_offset - s->prev_frame_num_offset) /
535  s->prev_frame_num_offset + 1 >> 1;
536  }
537  }
538 
539  /* clip motion vector prediction to frame border */
540  mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
541  my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
542 
543  /* get (optional) motion vector differential */
544  if (mode == PREDICT_MODE) {
545  dx = dy = 0;
546  } else {
547  dy = get_interleaved_se_golomb(&s->gb_slice);
548  dx = get_interleaved_se_golomb(&s->gb_slice);
549 
550  if (dx != (int16_t)dx || dy != (int16_t)dy) {
551  av_log(s->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
552  return -1;
553  }
554  }
555 
556  /* compute motion vector */
557  if (mode == THIRDPEL_MODE) {
558  int fx, fy;
559  mx = (mx + 1 >> 1) + dx;
560  my = (my + 1 >> 1) + dy;
561  fx = (unsigned)(mx + 0x30000) / 3 - 0x10000;
562  fy = (unsigned)(my + 0x30000) / 3 - 0x10000;
563  dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
564 
565  svq3_mc_dir_part(s, x, y, part_width, part_height,
566  fx, fy, dxy, 1, dir, avg);
567  mx += mx;
568  my += my;
569  } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
570  mx = (unsigned)(mx + 1 + 0x30000) / 3 + dx - 0x10000;
571  my = (unsigned)(my + 1 + 0x30000) / 3 + dy - 0x10000;
572  dxy = (mx & 1) + 2 * (my & 1);
573 
574  svq3_mc_dir_part(s, x, y, part_width, part_height,
575  mx >> 1, my >> 1, dxy, 0, dir, avg);
576  mx *= 3;
577  my *= 3;
578  } else {
579  mx = (unsigned)(mx + 3 + 0x60000) / 6 + dx - 0x10000;
580  my = (unsigned)(my + 3 + 0x60000) / 6 + dy - 0x10000;
581 
582  svq3_mc_dir_part(s, x, y, part_width, part_height,
583  mx, my, 0, 0, dir, avg);
584  mx *= 6;
585  my *= 6;
586  }
587 
588  /* update mv_cache */
589  if (mode != PREDICT_MODE) {
590  int32_t mv = pack16to32(mx, my);
591 
592  if (part_height == 8 && i < 8) {
593  AV_WN32A(s->mv_cache[dir][scan8[k] + 1 * 8], mv);
594 
595  if (part_width == 8 && j < 8)
596  AV_WN32A(s->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
597  }
598  if (part_width == 8 && j < 8)
599  AV_WN32A(s->mv_cache[dir][scan8[k] + 1], mv);
600  if (part_width == 4 || part_height == 4)
601  AV_WN32A(s->mv_cache[dir][scan8[k]], mv);
602  }
603 
604  /* write back motion vectors */
605  fill_rectangle(s->cur_pic->motion_val[dir][b_xy],
606  part_width >> 2, part_height >> 2, s->b_stride,
607  pack16to32(mx, my), 4);
608  }
609 
610  return 0;
611 }
612 
614  int mb_type, const int *block_offset,
615  int linesize, uint8_t *dest_y)
616 {
617  int i;
618  if (!IS_INTRA4x4(mb_type)) {
619  for (i = 0; i < 16; i++)
620  if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
621  uint8_t *const ptr = dest_y + block_offset[i];
622  svq3_add_idct_c(ptr, s->mb + i * 16, linesize,
623  s->qscale, IS_INTRA(mb_type) ? 1 : 0);
624  }
625  }
626 }
627 
629  int mb_type,
630  const int *block_offset,
631  int linesize,
632  uint8_t *dest_y)
633 {
634  int i;
635  int qscale = s->qscale;
636 
637  if (IS_INTRA4x4(mb_type)) {
638  for (i = 0; i < 16; i++) {
639  uint8_t *const ptr = dest_y + block_offset[i];
640  const int dir = s->intra4x4_pred_mode_cache[scan8[i]];
641 
642  uint8_t *topright;
643  int nnz;
644  if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
645  av_assert2(s->mb_y || linesize <= block_offset[i]);
646  topright = ptr + 4 - linesize;
647  } else
648  topright = NULL;
649 
650  s->hpc.pred4x4[dir](ptr, topright, linesize);
651  nnz = s->non_zero_count_cache[scan8[i]];
652  if (nnz) {
653  svq3_add_idct_c(ptr, s->mb + i * 16, linesize, qscale, 0);
654  }
655  }
656  } else {
657  s->hpc.pred16x16[s->intra16x16_pred_mode](dest_y, linesize);
658  svq3_luma_dc_dequant_idct_c(s->mb, s->mb_luma_dc[0], qscale);
659  }
660 }
661 
663 {
664  const int mb_x = s->mb_x;
665  const int mb_y = s->mb_y;
666  const int mb_xy = s->mb_xy;
667  const int mb_type = s->cur_pic->mb_type[mb_xy];
668  uint8_t *dest_y, *dest_cb, *dest_cr;
669  int linesize, uvlinesize;
670  int i, j;
671  const int *block_offset = &s->block_offset[0];
672  const int block_h = 16 >> 1;
673 
674  linesize = s->cur_pic->f->linesize[0];
675  uvlinesize = s->cur_pic->f->linesize[1];
676 
677  dest_y = s->cur_pic->f->data[0] + (mb_x + mb_y * linesize) * 16;
678  dest_cb = s->cur_pic->f->data[1] + mb_x * 8 + mb_y * uvlinesize * block_h;
679  dest_cr = s->cur_pic->f->data[2] + mb_x * 8 + mb_y * uvlinesize * block_h;
680 
681  s->vdsp.prefetch(dest_y + (s->mb_x & 3) * 4 * linesize + 64, linesize, 4);
682  s->vdsp.prefetch(dest_cb + (s->mb_x & 7) * uvlinesize + 64, dest_cr - dest_cb, 2);
683 
684  if (IS_INTRA(mb_type)) {
685  s->hpc.pred8x8[s->chroma_pred_mode](dest_cb, uvlinesize);
686  s->hpc.pred8x8[s->chroma_pred_mode](dest_cr, uvlinesize);
687 
688  hl_decode_mb_predict_luma(s, mb_type, block_offset, linesize, dest_y);
689  }
690 
691  hl_decode_mb_idct_luma(s, mb_type, block_offset, linesize, dest_y);
692 
693  if (s->cbp & 0x30) {
694  uint8_t *dest[2] = { dest_cb, dest_cr };
695  s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 1,
696  s->dequant4_coeff[4][0]);
697  s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 2,
698  s->dequant4_coeff[4][0]);
699  for (j = 1; j < 3; j++) {
700  for (i = j * 16; i < j * 16 + 4; i++)
701  if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
702  uint8_t *const ptr = dest[j - 1] + block_offset[i];
703  svq3_add_idct_c(ptr, s->mb + i * 16,
704  uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
705  }
706  }
707  }
708 }
709 
710 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
711 {
712  int i, j, k, m, dir, mode;
713  int cbp = 0;
714  uint32_t vlc;
715  int8_t *top, *left;
716  const int mb_xy = s->mb_xy;
717  const int b_xy = 4 * s->mb_x + 4 * s->mb_y * s->b_stride;
718 
719  s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
720  s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
721 
722  if (mb_type == 0) { /* SKIP */
723  if (s->pict_type == AV_PICTURE_TYPE_P ||
724  s->next_pic->mb_type[mb_xy] == -1) {
725  svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
726  0, 0, 0, 0, 0, 0);
727 
728  if (s->pict_type == AV_PICTURE_TYPE_B)
729  svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
730  0, 0, 0, 0, 1, 1);
731 
732  mb_type = MB_TYPE_SKIP;
733  } else {
734  mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
735  if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
736  return -1;
737  if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
738  return -1;
739 
740  mb_type = MB_TYPE_16x16;
741  }
742  } else if (mb_type < 8) { /* INTER */
743  if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&s->gb_slice))
745  else if (s->halfpel_flag &&
746  s->thirdpel_flag == !get_bits1(&s->gb_slice))
747  mode = HALFPEL_MODE;
748  else
749  mode = FULLPEL_MODE;
750 
751  /* fill caches */
752  /* note ref_cache should contain here:
753  * ????????
754  * ???11111
755  * N??11111
756  * N??11111
757  * N??11111
758  */
759 
760  for (m = 0; m < 2; m++) {
761  if (s->mb_x > 0 && s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6] != -1) {
762  for (i = 0; i < 4; i++)
763  AV_COPY32(s->mv_cache[m][scan8[0] - 1 + i * 8],
764  s->cur_pic->motion_val[m][b_xy - 1 + i * s->b_stride]);
765  } else {
766  for (i = 0; i < 4; i++)
767  AV_ZERO32(s->mv_cache[m][scan8[0] - 1 + i * 8]);
768  }
769  if (s->mb_y > 0) {
770  memcpy(s->mv_cache[m][scan8[0] - 1 * 8],
771  s->cur_pic->motion_val[m][b_xy - s->b_stride],
772  4 * 2 * sizeof(int16_t));
773  memset(&s->ref_cache[m][scan8[0] - 1 * 8],
774  (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
775 
776  if (s->mb_x < s->mb_width - 1) {
777  AV_COPY32(s->mv_cache[m][scan8[0] + 4 - 1 * 8],
778  s->cur_pic->motion_val[m][b_xy - s->b_stride + 4]);
779  s->ref_cache[m][scan8[0] + 4 - 1 * 8] =
780  (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
781  s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
782  } else
783  s->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
784  if (s->mb_x > 0) {
785  AV_COPY32(s->mv_cache[m][scan8[0] - 1 - 1 * 8],
786  s->cur_pic->motion_val[m][b_xy - s->b_stride - 1]);
787  s->ref_cache[m][scan8[0] - 1 - 1 * 8] =
788  (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
789  } else
790  s->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
791  } else
792  memset(&s->ref_cache[m][scan8[0] - 1 * 8 - 1],
793  PART_NOT_AVAILABLE, 8);
794 
795  if (s->pict_type != AV_PICTURE_TYPE_B)
796  break;
797  }
798 
799  /* decode motion vector(s) and form prediction(s) */
800  if (s->pict_type == AV_PICTURE_TYPE_P) {
801  if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
802  return -1;
803  } else { /* AV_PICTURE_TYPE_B */
804  if (mb_type != 2) {
805  if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
806  return -1;
807  } else {
808  for (i = 0; i < 4; i++)
809  memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
810  0, 4 * 2 * sizeof(int16_t));
811  }
812  if (mb_type != 1) {
813  if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
814  return -1;
815  } else {
816  for (i = 0; i < 4; i++)
817  memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
818  0, 4 * 2 * sizeof(int16_t));
819  }
820  }
821 
822  mb_type = MB_TYPE_16x16;
823  } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
824  int8_t *i4x4 = s->intra4x4_pred_mode + s->mb2br_xy[s->mb_xy];
825  int8_t *i4x4_cache = s->intra4x4_pred_mode_cache;
826 
827  memset(s->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
828 
829  if (mb_type == 8) {
830  if (s->mb_x > 0) {
831  for (i = 0; i < 4; i++)
832  s->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6 - i];
833  if (s->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
834  s->left_samples_available = 0x5F5F;
835  }
836  if (s->mb_y > 0) {
837  s->intra4x4_pred_mode_cache[4 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 0];
838  s->intra4x4_pred_mode_cache[5 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 1];
839  s->intra4x4_pred_mode_cache[6 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 2];
840  s->intra4x4_pred_mode_cache[7 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 3];
841 
842  if (s->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
843  s->top_samples_available = 0x33FF;
844  }
845 
846  /* decode prediction codes for luma blocks */
847  for (i = 0; i < 16; i += 2) {
848  vlc = get_interleaved_ue_golomb(&s->gb_slice);
849 
850  if (vlc >= 25U) {
851  av_log(s->avctx, AV_LOG_ERROR,
852  "luma prediction:%"PRIu32"\n", vlc);
853  return -1;
854  }
855 
856  left = &s->intra4x4_pred_mode_cache[scan8[i] - 1];
857  top = &s->intra4x4_pred_mode_cache[scan8[i] - 8];
858 
859  left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
860  left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
861 
862  if (left[1] == -1 || left[2] == -1) {
863  av_log(s->avctx, AV_LOG_ERROR, "weird prediction\n");
864  return -1;
865  }
866  }
867  } else { /* mb_type == 33, DC_128_PRED block type */
868  for (i = 0; i < 4; i++)
869  memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
870  }
871 
872  AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
873  i4x4[4] = i4x4_cache[7 + 8 * 3];
874  i4x4[5] = i4x4_cache[7 + 8 * 2];
875  i4x4[6] = i4x4_cache[7 + 8 * 1];
876 
877  if (mb_type == 8) {
878  ff_h264_check_intra4x4_pred_mode(s->intra4x4_pred_mode_cache,
879  s->avctx, s->top_samples_available,
880  s->left_samples_available);
881 
882  s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
883  s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
884  } else {
885  for (i = 0; i < 4; i++)
886  memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
887 
888  s->top_samples_available = 0x33FF;
889  s->left_samples_available = 0x5F5F;
890  }
891 
892  mb_type = MB_TYPE_INTRA4x4;
893  } else { /* INTRA16x16 */
894  dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
895  dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
896 
897  if ((s->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
898  s->left_samples_available, dir, 0)) < 0) {
899  av_log(s->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
900  return s->intra16x16_pred_mode;
901  }
902 
903  cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
904  mb_type = MB_TYPE_INTRA16x16;
905  }
906 
907  if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
908  for (i = 0; i < 4; i++)
909  memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
910  0, 4 * 2 * sizeof(int16_t));
911  if (s->pict_type == AV_PICTURE_TYPE_B) {
912  for (i = 0; i < 4; i++)
913  memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
914  0, 4 * 2 * sizeof(int16_t));
915  }
916  }
917  if (!IS_INTRA4x4(mb_type)) {
918  memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy], DC_PRED, 8);
919  }
920  if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
921  memset(s->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
922  }
923 
924  if (!IS_INTRA16x16(mb_type) &&
925  (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
926  if ((vlc = get_interleaved_ue_golomb(&s->gb_slice)) >= 48U){
927  av_log(s->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
928  return -1;
929  }
930 
931  cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
933  }
934  if (IS_INTRA16x16(mb_type) ||
935  (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
936  s->qscale += get_interleaved_se_golomb(&s->gb_slice);
937 
938  if (s->qscale > 31u) {
939  av_log(s->avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
940  return -1;
941  }
942  }
943  if (IS_INTRA16x16(mb_type)) {
944  AV_ZERO128(s->mb_luma_dc[0] + 0);
945  AV_ZERO128(s->mb_luma_dc[0] + 8);
946  if (svq3_decode_block(&s->gb_slice, s->mb_luma_dc[0], 0, 1)) {
947  av_log(s->avctx, AV_LOG_ERROR,
948  "error while decoding intra luma dc\n");
949  return -1;
950  }
951  }
952 
953  if (cbp) {
954  const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
955  const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
956 
957  for (i = 0; i < 4; i++)
958  if ((cbp & (1 << i))) {
959  for (j = 0; j < 4; j++) {
960  k = index ? (1 * (j & 1) + 2 * (i & 1) +
961  2 * (j & 2) + 4 * (i & 2))
962  : (4 * i + j);
963  s->non_zero_count_cache[scan8[k]] = 1;
964 
965  if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], index, type)) {
966  av_log(s->avctx, AV_LOG_ERROR,
967  "error while decoding block\n");
968  return -1;
969  }
970  }
971  }
972 
973  if ((cbp & 0x30)) {
974  for (i = 1; i < 3; ++i)
975  if (svq3_decode_block(&s->gb_slice, &s->mb[16 * 16 * i], 0, 3)) {
976  av_log(s->avctx, AV_LOG_ERROR,
977  "error while decoding chroma dc block\n");
978  return -1;
979  }
980 
981  if ((cbp & 0x20)) {
982  for (i = 1; i < 3; i++) {
983  for (j = 0; j < 4; j++) {
984  k = 16 * i + j;
985  s->non_zero_count_cache[scan8[k]] = 1;
986 
987  if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], 1, 1)) {
988  av_log(s->avctx, AV_LOG_ERROR,
989  "error while decoding chroma ac block\n");
990  return -1;
991  }
992  }
993  }
994  }
995  }
996  }
997 
998  s->cbp = cbp;
999  s->cur_pic->mb_type[mb_xy] = mb_type;
1000 
1001  if (IS_INTRA(mb_type))
1002  s->chroma_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
1003  s->left_samples_available, DC_PRED8x8, 1);
1004 
1005  return 0;
1006 }
1007 
1009 {
1010  SVQ3Context *s = avctx->priv_data;
1011  const int mb_xy = s->mb_xy;
1012  int i, header;
1013  unsigned slice_id;
1014 
1015  header = get_bits(&s->gb, 8);
1016 
1017  if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
1018  /* TODO: what? */
1019  av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
1020  return -1;
1021  } else {
1022  int slice_bits, slice_bytes, slice_length;
1023  int length = header >> 5 & 3;
1024 
1025  slice_length = show_bits(&s->gb, 8 * length);
1026  slice_bits = slice_length * 8;
1027  slice_bytes = slice_length + length - 1;
1028 
1029  skip_bits(&s->gb, 8);
1030 
1031  av_fast_padded_malloc(&s->slice_buf, &s->slice_buf_size, slice_bytes);
1032  if (!s->slice_buf)
1033  return AVERROR(ENOMEM);
1034 
1035  if (slice_bytes * 8LL > get_bits_left(&s->gb)) {
1036  av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1037  return AVERROR_INVALIDDATA;
1038  }
1039  memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
1040 
1041  if (length > 0) {
1042  memmove(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1043  }
1044 
1045  if (s->watermark_key) {
1046  uint32_t header = AV_RL32(&s->slice_buf[1]);
1047  AV_WL32(&s->slice_buf[1], header ^ s->watermark_key);
1048  }
1049  init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
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  if (s->pict_type == AV_PICTURE_TYPE_I)
1413  s->cur_pic->f->flags |= AV_FRAME_FLAG_KEY;
1414  else
1415  s->cur_pic->f->flags &= ~AV_FRAME_FLAG_KEY;
1416 
1417  ret = get_buffer(avctx, s->cur_pic);
1418  if (ret < 0)
1419  return ret;
1420 
1421  for (i = 0; i < 16; i++) {
1422  s->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1423  s->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1424  }
1425  for (i = 0; i < 16; i++) {
1426  s->block_offset[16 + i] =
1427  s->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1428  s->block_offset[48 + 16 + i] =
1429  s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1430  }
1431 
1432  if (s->pict_type != AV_PICTURE_TYPE_I) {
1433  if (!s->last_pic->f->data[0]) {
1434  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1435  av_frame_unref(s->last_pic->f);
1436  ret = get_buffer(avctx, s->last_pic);
1437  if (ret < 0)
1438  return ret;
1439  memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1440  memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1441  s->last_pic->f->linesize[1]);
1442  memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1443  s->last_pic->f->linesize[2]);
1444  }
1445 
1446  if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1447  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1448  av_frame_unref(s->next_pic->f);
1449  ret = get_buffer(avctx, s->next_pic);
1450  if (ret < 0)
1451  return ret;
1452  memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1453  memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1454  s->next_pic->f->linesize[1]);
1455  memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1456  s->next_pic->f->linesize[2]);
1457  }
1458  }
1459 
1460  if (avctx->debug & FF_DEBUG_PICT_INFO)
1461  av_log(s->avctx, AV_LOG_DEBUG,
1462  "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1463  av_get_picture_type_char(s->pict_type),
1464  s->halfpel_flag, s->thirdpel_flag,
1465  s->adaptive_quant, s->qscale, s->slice_num);
1466 
1467  if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1468  avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1469  avctx->skip_frame >= AVDISCARD_ALL)
1470  return 0;
1471 
1472  if (s->pict_type == AV_PICTURE_TYPE_B) {
1473  s->frame_num_offset = s->slice_num - s->prev_frame_num;
1474 
1475  if (s->frame_num_offset < 0)
1476  s->frame_num_offset += 256;
1477  if (s->frame_num_offset == 0 ||
1478  s->frame_num_offset >= s->prev_frame_num_offset) {
1479  av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1480  return -1;
1481  }
1482  } else {
1483  s->prev_frame_num = s->frame_num;
1484  s->frame_num = s->slice_num;
1485  s->prev_frame_num_offset = s->frame_num - s->prev_frame_num;
1486 
1487  if (s->prev_frame_num_offset < 0)
1488  s->prev_frame_num_offset += 256;
1489  }
1490 
1491  for (m = 0; m < 2; m++) {
1492  int i;
1493  for (i = 0; i < 4; i++) {
1494  int j;
1495  for (j = -1; j < 4; j++)
1496  s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1497  if (i < 3)
1498  s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1499  }
1500  }
1501 
1502  for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1503  for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1504  unsigned mb_type;
1505  s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1506 
1507  if ((get_bits_left(&s->gb_slice)) <= 7) {
1508  if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1509  show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1510 
1511  if (svq3_decode_slice_header(avctx))
1512  return -1;
1513  }
1514  if (s->slice_type != s->pict_type) {
1515  avpriv_request_sample(avctx, "non constant slice type");
1516  }
1517  /* TODO: support s->mb_skip_run */
1518  }
1519 
1520  mb_type = get_interleaved_ue_golomb(&s->gb_slice);
1521 
1522  if (s->pict_type == AV_PICTURE_TYPE_I)
1523  mb_type += 8;
1524  else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1525  mb_type += 4;
1526  if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1527  av_log(s->avctx, AV_LOG_ERROR,
1528  "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1529  return -1;
1530  }
1531 
1532  if (mb_type != 0 || s->cbp)
1533  hl_decode_mb(s);
1534 
1535  if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1536  s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1537  (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1538  }
1539 
1540  ff_draw_horiz_band(avctx, s->cur_pic->f,
1541  s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1542  16 * s->mb_y, 16, PICT_FRAME, 0,
1543  s->low_delay);
1544  }
1545 
1546  left = buf_size*8 - get_bits_count(&s->gb_slice);
1547 
1548  if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1549  av_log(avctx, AV_LOG_INFO, "frame num %"PRId64" incomplete pic x %d y %d left %d\n", avctx->frame_num, s->mb_y, s->mb_x, left);
1550  //av_hex_dump(stderr, buf+buf_size-8, 8);
1551  }
1552 
1553  if (left < 0) {
1554  av_log(avctx, AV_LOG_ERROR, "frame num %"PRId64" left %d\n", avctx->frame_num, left);
1555  return -1;
1556  }
1557 
1558  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1559  ret = av_frame_ref(rframe, s->cur_pic->f);
1560  else if (s->last_pic->f->data[0])
1561  ret = av_frame_ref(rframe, s->last_pic->f);
1562  if (ret < 0)
1563  return ret;
1564 
1565  /* Do not output the last pic after seeking. */
1566  if (s->last_pic->f->data[0] || s->low_delay)
1567  *got_frame = 1;
1568 
1569  if (s->pict_type != AV_PICTURE_TYPE_B) {
1570  FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1571  } else {
1572  av_frame_unref(s->cur_pic->f);
1573  }
1574 
1575  return buf_size;
1576 }
1577 
1579 {
1580  SVQ3Context *s = avctx->priv_data;
1581 
1582  for (int i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
1583  free_picture(&s->frames[i]);
1584  av_frame_free(&s->frames[i].f);
1585  }
1586  av_freep(&s->slice_buf);
1587  av_freep(&s->intra4x4_pred_mode);
1588  av_freep(&s->edge_emu_buffer);
1589  av_freep(&s->mb2br_xy);
1590 
1591  return 0;
1592 }
1593 
1595  .p.name = "svq3",
1596  CODEC_LONG_NAME("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1597  .p.type = AVMEDIA_TYPE_VIDEO,
1598  .p.id = AV_CODEC_ID_SVQ3,
1599  .priv_data_size = sizeof(SVQ3Context),
1601  .close = svq3_decode_end,
1603  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1606  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1607 };
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
SVQ3Context::frame_num
int frame_num
Definition: svq3.c:110
SVQ3Context::edge_emu_buffer
uint8_t * edge_emu_buffer
Definition: svq3.c:136
IS_INTRA4x4
#define IS_INTRA4x4(a)
Definition: mpegutils.h:70
A
#define A(x)
Definition: vpx_arith.h:28
ff_draw_horiz_band
void ff_draw_horiz_band(AVCodecContext *avctx, const AVFrame *cur, const AVFrame *last, int y, int h, int picture_structure, int first_field, int low_delay)
Draw a horizontal band if supported.
Definition: mpegutils.c:54
svq3_dequant_coeff
static const uint32_t svq3_dequant_coeff[32]
Definition: svq3.c:213
SVQ3Context::next_pic
SVQ3Frame * next_pic
Definition: svq3.c:93
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
SVQ3Context::slice_type
enum AVPictureType slice_type
Definition: svq3.c:116
SVQ3Context::gb_slice
GetBitContext gb_slice
Definition: svq3.c:96
SVQ3Context::vdsp
VideoDSPContext vdsp
Definition: svq3.c:90
SVQ3Context::slice_num
int slice_num
Definition: svq3.c:107
level
uint8_t level
Definition: svq3.c:205
av_clip
#define av_clip
Definition: common.h:100
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:42
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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:1008
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:420
mem_internal.h
SVQ3Context::avctx
AVCodecContext * avctx
Definition: svq3.c:84
DC_128_PRED
@ DC_128_PRED
Definition: vp9.h:58
svq3_dct_tables
static const struct @200 svq3_dct_tables[2][16]
SVQ3Context::mb_num
int mb_num
Definition: svq3.c:122
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:251
SVQ3Context::v_edge_pos
int v_edge_pos
Definition: svq3.c:105
AVPictureType
AVPictureType
Definition: avutil.h:277
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:81
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:134
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
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:160
h264_parse.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
SVQ3Context::h_edge_pos
int h_edge_pos
Definition: svq3.c:104
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:686
IMbInfo::cbp
uint8_t cbp
Definition: h264data.h:37
AVPacket::data
uint8_t * data
Definition: packet.h:520
DC_PRED
@ DC_PRED
Definition: vp9.h:48
MB_TYPE_INTRA4x4
#define MB_TYPE_INTRA4x4
Definition: mpegutils.h:39
SVQ3Context::slice_buf
uint8_t * slice_buf
Definition: svq3.c:97
VERT_LEFT_PRED
@ VERT_LEFT_PRED
Definition: vp9.h:53
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:42
SVQ3Context::mb
int16_t mb[16 *48 *2]
Definition: svq3.c:140
PREDICT_MODE
#define PREDICT_MODE
Definition: svq3.c:151
FFCodec
Definition: codec_internal.h:126
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:532
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:111
mpegutils.h
MB_TYPE_INTRA16x16
#define MB_TYPE_INTRA16x16
Definition: mpegutils.h:40
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:94
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
SVQ3Context::slice_buf_size
unsigned slice_buf_size
Definition: svq3.c:98
SVQ3Context::last_frame_output
int last_frame_output
Definition: svq3.c:106
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1397
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
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
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
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:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
SVQ3Context::last_pic
SVQ3Frame * last_pic
Definition: svq3.c:94
SVQ3Context::qscale
int qscale
Definition: svq3.c:108
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1820
fail
#define fail()
Definition: checkasm.h:185
GetBitContext
Definition: get_bits.h:108
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
SVQ3Context::tdsp
TpelDSPContext tdsp
Definition: svq3.c:89
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:100
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:148
SVQ3Context::intra4x4_pred_mode_cache
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: svq3.c:130
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:95
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:145
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:109
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
FULLPEL_MODE
#define FULLPEL_MODE
Definition: svq3.c:148
SVQ3Context::mb_y
int mb_y
Definition: svq3.c:119
SVQ3Context::mb_x
int mb_x
Definition: svq3.c:119
SVQ3Context::adaptive_quant
int adaptive_quant
Definition: svq3.c:103
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:723
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
s
#define s(width, name)
Definition: cbs_vp9.c:198
TpelDSPContext
thirdpel DSP context
Definition: tpeldsp.h:42
SVQ3Context::pict_type
enum AVPictureType pict_type
Definition: svq3.c:115
AV_ZERO32
#define AV_ZERO32(d)
Definition: intreadwrite.h:621
svq3_mc_dir
static int svq3_mc_dir(SVQ3Context *s, int size, int mode, int dir, int avg)
Definition: svq3.c:500
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:425
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
B
#define B
Definition: huffyuv.h:42
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1575
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:376
decode.h
IS_SKIP
#define IS_SKIP(a)
Definition: mpegutils.h:76
SVQ3Context::top_samples_available
unsigned int top_samples_available
Definition: svq3.c:133
AV_CODEC_ID_SVQ3
@ AV_CODEC_ID_SVQ3
Definition: codec_id.h:75
SVQ3Context::b_stride
int b_stride
Definition: svq3.c:123
SVQ3Context::prev_frame_num_offset
int prev_frame_num_offset
Definition: svq3.c:112
SVQ3Frame::mb_type_buf
uint32_t * mb_type_buf
Definition: svq3.c:80
SVQ3Context::h264dsp
H264DSPContext h264dsp
Definition: svq3.c:86
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
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:78
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:220
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:204
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
SVQ3Context::mb_width
int mb_width
Definition: svq3.c:121
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:85
SVQ3Context::mb2br_xy
uint32_t * mb2br_xy
Definition: svq3.c:125
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
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:83
AV_ZERO128
#define AV_ZERO128(d)
Definition: intreadwrite.h:629
SVQ3Context::mb_luma_dc
int16_t mb_luma_dc[3][16 *2]
Definition: svq3.c:141
tpeldsp.h
index
int index
Definition: gxfenc.c:90
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:613
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:128
IS_INTRA
#define IS_INTRA(x, y)
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:219
SVQ3Context::hpc
H264PredContext hpc
Definition: svq3.c:87
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1575
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:355
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
AVPacket::size
int size
Definition: packet.h:521
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
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:384
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
shift
static int shift(int a, int b)
Definition: bonk.c:261
rectangle.h
hl_decode_mb
static void hl_decode_mb(SVQ3Context *s)
Definition: svq3.c:662
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:80
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:62
avg
#define avg(a, b, c, d)
Definition: colorspacedsp_template.c:28
header
static const uint8_t header[24]
Definition: sdr2.c:68
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
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:413
IS_INTRA16x16
#define IS_INTRA16x16(a)
Definition: mpegutils.h:71
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:628
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:77
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
SVQ3Context::prev_frame_num
int prev_frame_num
Definition: svq3.c:113
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:255
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
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
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:220
stride
#define stride
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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:523
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
SVQ3Frame
Definition: svq3.c:74
THIRDPEL_MODE
#define THIRDPEL_MODE
Definition: svq3.c:150
SVQ3Context::mv_cache
int16_t mv_cache[2][5 *8][2]
Definition: svq3.c:138
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:52
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
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:256
AV_COPY32
#define AV_COPY32(d, s)
Definition: intreadwrite.h:593
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
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:142
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
svq3_decode_mb
static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
Definition: svq3.c:710
svq3_scan
static const uint8_t svq3_scan[16]
Definition: svq3.c:162
avcodec.h
limit
static double limit(double x)
Definition: vf_pseudocolor.c:142
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:99
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2031
mid_pred
#define mid_pred
Definition: mathops.h:96
svq3_pred_1
static const int8_t svq3_pred_1[6][6][5]
Definition: svq3.c:188
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:121
SVQ3Context::hdsp
HpelDSPContext hdsp
Definition: svq3.c:88
SVQ3Context::low_delay
int low_delay
Definition: svq3.c:117
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:295
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:700
AVCodecContext
main external API structure.
Definition: avcodec.h:445
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:75
SVQ3Context::block_offset
int block_offset[2 *(16 *3)]
Definition: svq3.c:144
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:281
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:134
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:826
SVQ3Context::chroma_pred_mode
int chroma_pred_mode
Definition: svq3.c:127
SVQ3Context::watermark_key
uint32_t watermark_key
Definition: svq3.c:102
SVQ3Context::mb_xy
int mb_xy
Definition: svq3.c:120
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
temp
else temp
Definition: vf_mcdeint.c:263
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:76
luma_dc_zigzag_scan
static const uint8_t luma_dc_zigzag_scan[16]
Definition: svq3.c:169
PART_NOT_AVAILABLE
#define PART_NOT_AVAILABLE
Definition: h264pred.h:89
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
ff_h264_quant_div6
const uint8_t ff_h264_quant_div6[QP_MAX_NUM+1]
Definition: h264data.c:182
VideoDSPContext
Definition: videodsp.h:40
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1396
H264PredContext
Context for storing H.264 prediction functions.
Definition: h264pred.h:94
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:425
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
IS_INTER
#define IS_INTER(a)
Definition: mpegutils.h:74
mem.h
svq3_decode_end
static av_cold int svq3_decode_end(AVCodecContext *avctx)
Definition: svq3.c:1578
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:143
SVQ3Context::ref_cache
int8_t ref_cache[2][5 *8]
Definition: svq3.c:139
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
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:122
DIAG_DOWN_LEFT_PRED
@ DIAG_DOWN_LEFT_PRED
Definition: vp9.h:49
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
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:419
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:216
av_bswap16
#define av_bswap16
Definition: bswap.h:28
ff_svq3_decoder
const FFCodec ff_svq3_decoder
Definition: svq3.c:1594
int
int
Definition: ffmpeg_filter.c:424
SVQ3Context::cur_pic
SVQ3Frame * cur_pic
Definition: svq3.c:92
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
SVQ3Context::has_watermark
int has_watermark
Definition: svq3.c:101
SVQ3Context::intra4x4_pred_mode
int8_t * intra4x4_pred_mode
Definition: svq3.c:131
svq3_pred_0
static const uint8_t svq3_pred_0[25][2]
Definition: svq3.c:176
HALFPEL_MODE
#define HALFPEL_MODE
Definition: svq3.c:149
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:182