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