FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
svq3.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2003 The FFmpeg Project
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /*
22  * How to use this decoder:
23  * SVQ3 data is transported within Apple Quicktime files. Quicktime files
24  * have stsd atoms to describe media trak properties. A stsd atom for a
25  * video trak contains 1 or more ImageDescription atoms. These atoms begin
26  * with the 4-byte length of the atom followed by the codec fourcc. Some
27  * decoders need information in this atom to operate correctly. Such
28  * is the case with SVQ3. In order to get the best use out of this decoder,
29  * the calling app must make the SVQ3 ImageDescription atom available
30  * via the AVCodecContext's extradata[_size] field:
31  *
32  * AVCodecContext.extradata = pointer to ImageDescription, first characters
33  * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
34  * AVCodecContext.extradata_size = size of ImageDescription atom memory
35  * buffer (which will be the same as the ImageDescription atom size field
36  * from the QT file, minus 4 bytes since the length is missing)
37  *
38  * You will know you have these parameters passed correctly when the decoder
39  * correctly decodes this file:
40  * http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41  */
42 
43 #include <inttypes.h>
44 
45 #include "libavutil/attributes.h"
46 #include "internal.h"
47 #include "avcodec.h"
48 #include "mpegutils.h"
49 #include "h264.h"
50 
51 #include "h264data.h" // FIXME FIXME FIXME
52 
53 #include "h264_mvpred.h"
54 #include "golomb.h"
55 #include "hpeldsp.h"
56 #include "rectangle.h"
57 #include "tpeldsp.h"
58 #include "vdpau_internal.h"
59 
60 #if CONFIG_ZLIB
61 #include <zlib.h>
62 #endif
63 
64 #include "svq1.h"
65 #include "svq3.h"
66 
67 /**
68  * @file
69  * svq3 decoder.
70  */
71 
72 typedef struct SVQ3Context {
83  uint32_t watermark_key;
85  int buf_size;
91 } SVQ3Context;
92 
93 #define FULLPEL_MODE 1
94 #define HALFPEL_MODE 2
95 #define THIRDPEL_MODE 3
96 #define PREDICT_MODE 4
97 
98 /* dual scan (from some older h264 draft)
99  * o-->o-->o o
100  * | /|
101  * o o o / o
102  * | / | |/ |
103  * o o o o
104  * /
105  * o-->o-->o-->o
106  */
107 static const uint8_t svq3_scan[16] = {
108  0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
109  2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
110  0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
111  0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
112 };
113 
114 static const uint8_t luma_dc_zigzag_scan[16] = {
115  0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
116  3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
117  1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
118  3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
119 };
120 
121 static const uint8_t svq3_pred_0[25][2] = {
122  { 0, 0 },
123  { 1, 0 }, { 0, 1 },
124  { 0, 2 }, { 1, 1 }, { 2, 0 },
125  { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
126  { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
127  { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
128  { 2, 4 }, { 3, 3 }, { 4, 2 },
129  { 4, 3 }, { 3, 4 },
130  { 4, 4 }
131 };
132 
133 static const int8_t svq3_pred_1[6][6][5] = {
134  { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
135  { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
136  { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
137  { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
138  { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
139  { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
140  { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
141  { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
142  { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
143  { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
144  { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
145  { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
146 };
147 
148 static const struct {
151 } svq3_dct_tables[2][16] = {
152  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
153  { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
154  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
155  { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
156 };
157 
158 static const uint32_t svq3_dequant_coeff[32] = {
159  3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
160  9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
161  24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
162  61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
163 };
164 
165 static int svq3_decode_end(AVCodecContext *avctx);
166 
167 void ff_svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
168 {
169  const int qmul = svq3_dequant_coeff[qp];
170 #define stride 16
171  int i;
172  int temp[16];
173  static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
174 
175  for (i = 0; i < 4; i++) {
176  const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
177  const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
178  const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
179  const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
180 
181  temp[4 * i + 0] = z0 + z3;
182  temp[4 * i + 1] = z1 + z2;
183  temp[4 * i + 2] = z1 - z2;
184  temp[4 * i + 3] = z0 - z3;
185  }
186 
187  for (i = 0; i < 4; i++) {
188  const int offset = x_offset[i];
189  const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
190  const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
191  const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
192  const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
193 
194  output[stride * 0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
195  output[stride * 2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
196  output[stride * 8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
197  output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
198  }
199 }
200 #undef stride
201 
202 void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block,
203  int stride, int qp, int dc)
204 {
205  const int qmul = svq3_dequant_coeff[qp];
206  int i;
207 
208  if (dc) {
209  dc = 13 * 13 * (dc == 1 ? 1538 * block[0]
210  : qmul * (block[0] >> 3) / 2);
211  block[0] = 0;
212  }
213 
214  for (i = 0; i < 4; i++) {
215  const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
216  const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
217  const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
218  const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
219 
220  block[0 + 4 * i] = z0 + z3;
221  block[1 + 4 * i] = z1 + z2;
222  block[2 + 4 * i] = z1 - z2;
223  block[3 + 4 * i] = z0 - z3;
224  }
225 
226  for (i = 0; i < 4; i++) {
227  const int z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
228  const int z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
229  const int z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
230  const int z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
231  const int rr = (dc + 0x80000);
232 
233  dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
234  dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
235  dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
236  dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
237  }
238 
239  memset(block, 0, 16 * sizeof(int16_t));
240 }
241 
242 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
243  int index, const int type)
244 {
245  static const uint8_t *const scan_patterns[4] =
247 
248  int run, level, sign, limit;
249  unsigned vlc;
250  const int intra = 3 * type >> 2;
251  const uint8_t *const scan = scan_patterns[type];
252 
253  for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
254  for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
255  if ((int32_t)vlc < 0)
256  return -1;
257 
258  sign = (vlc & 1) ? 0 : -1;
259  vlc = vlc + 1 >> 1;
260 
261  if (type == 3) {
262  if (vlc < 3) {
263  run = 0;
264  level = vlc;
265  } else if (vlc < 4) {
266  run = 1;
267  level = 1;
268  } else {
269  run = vlc & 0x3;
270  level = (vlc + 9 >> 2) - run;
271  }
272  } else {
273  if (vlc < 16U) {
274  run = svq3_dct_tables[intra][vlc].run;
275  level = svq3_dct_tables[intra][vlc].level;
276  } else if (intra) {
277  run = vlc & 0x7;
278  level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
279  } else {
280  run = vlc & 0xF;
281  level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
282  }
283  }
284 
285 
286  if ((index += run) >= limit)
287  return -1;
288 
289  block[scan[index]] = (level ^ sign) - sign;
290  }
291 
292  if (type != 2) {
293  break;
294  }
295  }
296 
297  return 0;
298 }
299 
300 static inline void svq3_mc_dir_part(SVQ3Context *s,
301  int x, int y, int width, int height,
302  int mx, int my, int dxy,
303  int thirdpel, int dir, int avg)
304 {
305  H264Context *h = &s->h;
306  H264SliceContext *sl = &h->slice_ctx[0];
307  const H264Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
308  uint8_t *src, *dest;
309  int i, emu = 0;
310  int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
311 
312  mx += x;
313  my += y;
314 
315  if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
316  my < 0 || my >= s->v_edge_pos - height - 1) {
317  emu = 1;
318  mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
319  my = av_clip(my, -16, s->v_edge_pos - height + 15);
320  }
321 
322  /* form component predictions */
323  dest = h->cur_pic.f->data[0] + x + y * sl->linesize;
324  src = pic->f->data[0] + mx + my * sl->linesize;
325 
326  if (emu) {
328  sl->linesize, sl->linesize,
329  width + 1, height + 1,
330  mx, my, s->h_edge_pos, s->v_edge_pos);
331  src = sl->edge_emu_buffer;
332  }
333  if (thirdpel)
334  (avg ? s->tdsp.avg_tpel_pixels_tab
335  : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, sl->linesize,
336  width, height);
337  else
338  (avg ? s->hdsp.avg_pixels_tab
339  : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, sl->linesize,
340  height);
341 
342  if (!(h->flags & AV_CODEC_FLAG_GRAY)) {
343  mx = mx + (mx < (int) x) >> 1;
344  my = my + (my < (int) y) >> 1;
345  width = width >> 1;
346  height = height >> 1;
347  blocksize++;
348 
349  for (i = 1; i < 3; i++) {
350  dest = h->cur_pic.f->data[i] + (x >> 1) + (y >> 1) * sl->uvlinesize;
351  src = pic->f->data[i] + mx + my * sl->uvlinesize;
352 
353  if (emu) {
355  sl->uvlinesize, sl->uvlinesize,
356  width + 1, height + 1,
357  mx, my, (s->h_edge_pos >> 1),
358  s->v_edge_pos >> 1);
359  src = sl->edge_emu_buffer;
360  }
361  if (thirdpel)
362  (avg ? s->tdsp.avg_tpel_pixels_tab
363  : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
364  sl->uvlinesize,
365  width, height);
366  else
367  (avg ? s->hdsp.avg_pixels_tab
368  : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
369  sl->uvlinesize,
370  height);
371  }
372  }
373 }
374 
375 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
376  int dir, int avg)
377 {
378  int i, j, k, mx, my, dx, dy, x, y;
379  H264Context *h = &s->h;
380  H264SliceContext *sl = &h->slice_ctx[0];
381  const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
382  const int part_height = 16 >> ((unsigned)(size + 1) / 3);
383  const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
384  const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
385  const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
386 
387  for (i = 0; i < 16; i += part_height)
388  for (j = 0; j < 16; j += part_width) {
389  const int b_xy = (4 * sl->mb_x + (j >> 2)) +
390  (4 * sl->mb_y + (i >> 2)) * h->b_stride;
391  int dxy;
392  x = 16 * sl->mb_x + j;
393  y = 16 * sl->mb_y + i;
394  k = (j >> 2 & 1) + (i >> 1 & 2) +
395  (j >> 1 & 4) + (i & 8);
396 
397  if (mode != PREDICT_MODE) {
398  pred_motion(h, sl, k, part_width >> 2, dir, 1, &mx, &my);
399  } else {
400  mx = s->next_pic->motion_val[0][b_xy][0] << 1;
401  my = s->next_pic->motion_val[0][b_xy][1] << 1;
402 
403  if (dir == 0) {
404  mx = mx * h->frame_num_offset /
405  h->prev_frame_num_offset + 1 >> 1;
406  my = my * h->frame_num_offset /
407  h->prev_frame_num_offset + 1 >> 1;
408  } else {
409  mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
410  h->prev_frame_num_offset + 1 >> 1;
411  my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
412  h->prev_frame_num_offset + 1 >> 1;
413  }
414  }
415 
416  /* clip motion vector prediction to frame border */
417  mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
418  my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
419 
420  /* get (optional) motion vector differential */
421  if (mode == PREDICT_MODE) {
422  dx = dy = 0;
423  } else {
424  dy = svq3_get_se_golomb(&h->gb);
425  dx = svq3_get_se_golomb(&h->gb);
426 
427  if (dx == INVALID_VLC || dy == INVALID_VLC) {
428  av_log(h->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
429  return -1;
430  }
431  }
432 
433  /* compute motion vector */
434  if (mode == THIRDPEL_MODE) {
435  int fx, fy;
436  mx = (mx + 1 >> 1) + dx;
437  my = (my + 1 >> 1) + dy;
438  fx = (unsigned)(mx + 0x3000) / 3 - 0x1000;
439  fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
440  dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
441 
442  svq3_mc_dir_part(s, x, y, part_width, part_height,
443  fx, fy, dxy, 1, dir, avg);
444  mx += mx;
445  my += my;
446  } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
447  mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
448  my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
449  dxy = (mx & 1) + 2 * (my & 1);
450 
451  svq3_mc_dir_part(s, x, y, part_width, part_height,
452  mx >> 1, my >> 1, dxy, 0, dir, avg);
453  mx *= 3;
454  my *= 3;
455  } else {
456  mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
457  my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
458 
459  svq3_mc_dir_part(s, x, y, part_width, part_height,
460  mx, my, 0, 0, dir, avg);
461  mx *= 6;
462  my *= 6;
463  }
464 
465  /* update mv_cache */
466  if (mode != PREDICT_MODE) {
467  int32_t mv = pack16to32(mx, my);
468 
469  if (part_height == 8 && i < 8) {
470  AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 * 8], mv);
471 
472  if (part_width == 8 && j < 8)
473  AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
474  }
475  if (part_width == 8 && j < 8)
476  AV_WN32A(sl->mv_cache[dir][scan8[k] + 1], mv);
477  if (part_width == 4 || part_height == 4)
478  AV_WN32A(sl->mv_cache[dir][scan8[k]], mv);
479  }
480 
481  /* write back motion vectors */
482  fill_rectangle(h->cur_pic.motion_val[dir][b_xy],
483  part_width >> 2, part_height >> 2, h->b_stride,
484  pack16to32(mx, my), 4);
485  }
486 
487  return 0;
488 }
489 
490 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
491 {
492  H264Context *h = &s->h;
493  H264SliceContext *sl = &h->slice_ctx[0];
494  int i, j, k, m, dir, mode;
495  int cbp = 0;
496  uint32_t vlc;
497  int8_t *top, *left;
498  const int mb_xy = sl->mb_xy;
499  const int b_xy = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride;
500 
501  sl->top_samples_available = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
502  sl->left_samples_available = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
503  sl->topright_samples_available = 0xFFFF;
504 
505  if (mb_type == 0) { /* SKIP */
506  if (h->pict_type == AV_PICTURE_TYPE_P ||
507  s->next_pic->mb_type[mb_xy] == -1) {
508  svq3_mc_dir_part(s, 16 * sl->mb_x, 16 * sl->mb_y, 16, 16,
509  0, 0, 0, 0, 0, 0);
510 
511  if (h->pict_type == AV_PICTURE_TYPE_B)
512  svq3_mc_dir_part(s, 16 * sl->mb_x, 16 * sl->mb_y, 16, 16,
513  0, 0, 0, 0, 1, 1);
514 
515  mb_type = MB_TYPE_SKIP;
516  } else {
517  mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
518  if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
519  return -1;
520  if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
521  return -1;
522 
523  mb_type = MB_TYPE_16x16;
524  }
525  } else if (mb_type < 8) { /* INTER */
526  if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&h->gb))
527  mode = THIRDPEL_MODE;
528  else if (s->halfpel_flag &&
529  s->thirdpel_flag == !get_bits1(&h->gb))
530  mode = HALFPEL_MODE;
531  else
532  mode = FULLPEL_MODE;
533 
534  /* fill caches */
535  /* note ref_cache should contain here:
536  * ????????
537  * ???11111
538  * N??11111
539  * N??11111
540  * N??11111
541  */
542 
543  for (m = 0; m < 2; m++) {
544  if (sl->mb_x > 0 && sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
545  for (i = 0; i < 4; i++)
546  AV_COPY32(sl->mv_cache[m][scan8[0] - 1 + i * 8],
547  h->cur_pic.motion_val[m][b_xy - 1 + i * h->b_stride]);
548  } else {
549  for (i = 0; i < 4; i++)
550  AV_ZERO32(sl->mv_cache[m][scan8[0] - 1 + i * 8]);
551  }
552  if (sl->mb_y > 0) {
553  memcpy(sl->mv_cache[m][scan8[0] - 1 * 8],
554  h->cur_pic.motion_val[m][b_xy - h->b_stride],
555  4 * 2 * sizeof(int16_t));
556  memset(&sl->ref_cache[m][scan8[0] - 1 * 8],
557  (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
558 
559  if (sl->mb_x < h->mb_width - 1) {
560  AV_COPY32(sl->mv_cache[m][scan8[0] + 4 - 1 * 8],
561  h->cur_pic.motion_val[m][b_xy - h->b_stride + 4]);
562  sl->ref_cache[m][scan8[0] + 4 - 1 * 8] =
563  (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride + 1] + 6] == -1 ||
564  sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
565  } else
566  sl->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
567  if (sl->mb_x > 0) {
568  AV_COPY32(sl->mv_cache[m][scan8[0] - 1 - 1 * 8],
569  h->cur_pic.motion_val[m][b_xy - h->b_stride - 1]);
570  sl->ref_cache[m][scan8[0] - 1 - 1 * 8] =
571  (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
572  } else
573  sl->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
574  } else
575  memset(&sl->ref_cache[m][scan8[0] - 1 * 8 - 1],
576  PART_NOT_AVAILABLE, 8);
577 
578  if (h->pict_type != AV_PICTURE_TYPE_B)
579  break;
580  }
581 
582  /* decode motion vector(s) and form prediction(s) */
583  if (h->pict_type == AV_PICTURE_TYPE_P) {
584  if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
585  return -1;
586  } else { /* AV_PICTURE_TYPE_B */
587  if (mb_type != 2) {
588  if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
589  return -1;
590  } else {
591  for (i = 0; i < 4; i++)
592  memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
593  0, 4 * 2 * sizeof(int16_t));
594  }
595  if (mb_type != 1) {
596  if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
597  return -1;
598  } else {
599  for (i = 0; i < 4; i++)
600  memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
601  0, 4 * 2 * sizeof(int16_t));
602  }
603  }
604 
605  mb_type = MB_TYPE_16x16;
606  } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
607  memset(sl->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
608 
609  if (mb_type == 8) {
610  if (sl->mb_x > 0) {
611  for (i = 0; i < 4; i++)
612  sl->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
613  if (sl->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
614  sl->left_samples_available = 0x5F5F;
615  }
616  if (sl->mb_y > 0) {
617  sl->intra4x4_pred_mode_cache[4 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 0];
618  sl->intra4x4_pred_mode_cache[5 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 1];
619  sl->intra4x4_pred_mode_cache[6 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 2];
620  sl->intra4x4_pred_mode_cache[7 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 3];
621 
622  if (sl->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
623  sl->top_samples_available = 0x33FF;
624  }
625 
626  /* decode prediction codes for luma blocks */
627  for (i = 0; i < 16; i += 2) {
628  vlc = svq3_get_ue_golomb(&h->gb);
629 
630  if (vlc >= 25U) {
632  "luma prediction:%"PRIu32"\n", vlc);
633  return -1;
634  }
635 
636  left = &sl->intra4x4_pred_mode_cache[scan8[i] - 1];
637  top = &sl->intra4x4_pred_mode_cache[scan8[i] - 8];
638 
639  left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
640  left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
641 
642  if (left[1] == -1 || left[2] == -1) {
643  av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
644  return -1;
645  }
646  }
647  } else { /* mb_type == 33, DC_128_PRED block type */
648  for (i = 0; i < 4; i++)
649  memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
650  }
651 
653 
654  if (mb_type == 8) {
656 
657  sl->top_samples_available = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
658  sl->left_samples_available = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
659  } else {
660  for (i = 0; i < 4; i++)
661  memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
662 
663  sl->top_samples_available = 0x33FF;
664  sl->left_samples_available = 0x5F5F;
665  }
666 
667  mb_type = MB_TYPE_INTRA4x4;
668  } else { /* INTRA16x16 */
669  dir = i_mb_type_info[mb_type - 8].pred_mode;
670  dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
671 
672  if ((sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, dir, 0)) < 0) {
673  av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
674  return sl->intra16x16_pred_mode;
675  }
676 
677  cbp = i_mb_type_info[mb_type - 8].cbp;
678  mb_type = MB_TYPE_INTRA16x16;
679  }
680 
681  if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
682  for (i = 0; i < 4; i++)
683  memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
684  0, 4 * 2 * sizeof(int16_t));
685  if (h->pict_type == AV_PICTURE_TYPE_B) {
686  for (i = 0; i < 4; i++)
687  memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
688  0, 4 * 2 * sizeof(int16_t));
689  }
690  }
691  if (!IS_INTRA4x4(mb_type)) {
692  memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
693  }
694  if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
695  memset(sl->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
696  }
697 
698  if (!IS_INTRA16x16(mb_type) &&
699  (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
700  if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48U){
701  av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
702  return -1;
703  }
704 
705  cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
706  : golomb_to_inter_cbp[vlc];
707  }
708  if (IS_INTRA16x16(mb_type) ||
709  (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
710  sl->qscale += svq3_get_se_golomb(&h->gb);
711 
712  if (sl->qscale > 31u) {
713  av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", sl->qscale);
714  return -1;
715  }
716  }
717  if (IS_INTRA16x16(mb_type)) {
718  AV_ZERO128(sl->mb_luma_dc[0] + 0);
719  AV_ZERO128(sl->mb_luma_dc[0] + 8);
720  if (svq3_decode_block(&h->gb, sl->mb_luma_dc[0], 0, 1)) {
722  "error while decoding intra luma dc\n");
723  return -1;
724  }
725  }
726 
727  if (cbp) {
728  const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
729  const int type = ((sl->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
730 
731  for (i = 0; i < 4; i++)
732  if ((cbp & (1 << i))) {
733  for (j = 0; j < 4; j++) {
734  k = index ? (1 * (j & 1) + 2 * (i & 1) +
735  2 * (j & 2) + 4 * (i & 2))
736  : (4 * i + j);
737  sl->non_zero_count_cache[scan8[k]] = 1;
738 
739  if (svq3_decode_block(&h->gb, &sl->mb[16 * k], index, type)) {
741  "error while decoding block\n");
742  return -1;
743  }
744  }
745  }
746 
747  if ((cbp & 0x30)) {
748  for (i = 1; i < 3; ++i)
749  if (svq3_decode_block(&h->gb, &sl->mb[16 * 16 * i], 0, 3)) {
751  "error while decoding chroma dc block\n");
752  return -1;
753  }
754 
755  if ((cbp & 0x20)) {
756  for (i = 1; i < 3; i++) {
757  for (j = 0; j < 4; j++) {
758  k = 16 * i + j;
759  sl->non_zero_count_cache[scan8[k]] = 1;
760 
761  if (svq3_decode_block(&h->gb, &sl->mb[16 * k], 1, 1)) {
763  "error while decoding chroma ac block\n");
764  return -1;
765  }
766  }
767  }
768  }
769  }
770  }
771 
772  sl->cbp = cbp;
773  h->cur_pic.mb_type[mb_xy] = mb_type;
774 
775  if (IS_INTRA(mb_type))
777 
778  return 0;
779 }
780 
782 {
783  SVQ3Context *s = avctx->priv_data;
784  H264Context *h = &s->h;
785  H264SliceContext *sl = &h->slice_ctx[0];
786  const int mb_xy = sl->mb_xy;
787  int i, header;
788  unsigned slice_id;
789 
790  header = get_bits(&h->gb, 8);
791 
792  if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
793  /* TODO: what? */
794  av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
795  return -1;
796  } else {
797  int length = header >> 5 & 3;
798 
800  8 * show_bits(&h->gb, 8 * length) +
801  8 * length;
802 
803  if (s->next_slice_index > h->gb.size_in_bits) {
804  av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
805  return -1;
806  }
807 
808  h->gb.size_in_bits = s->next_slice_index - 8 * (length - 1);
809  skip_bits(&h->gb, 8);
810 
811  if (s->watermark_key) {
812  uint32_t header = AV_RL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1]);
813  AV_WL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1],
814  header ^ s->watermark_key);
815  }
816  if (length > 0) {
817  memmove((uint8_t *) &h->gb.buffer[get_bits_count(&h->gb) >> 3],
818  &h->gb.buffer[h->gb.size_in_bits >> 3], length - 1);
819  }
820  skip_bits_long(&h->gb, 0);
821  }
822 
823  if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
824  av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
825  return -1;
826  }
827 
828  sl->slice_type = golomb_to_pict_type[slice_id];
829 
830  if ((header & 0x9F) == 2) {
831  i = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
832  sl->mb_skip_run = get_bits(&h->gb, i) -
833  (sl->mb_y * h->mb_width + sl->mb_x);
834  } else {
835  skip_bits1(&h->gb);
836  sl->mb_skip_run = 0;
837  }
838 
839  sl->slice_num = get_bits(&h->gb, 8);
840  sl->qscale = get_bits(&h->gb, 5);
841  s->adaptive_quant = get_bits1(&h->gb);
842 
843  /* unknown fields */
844  skip_bits1(&h->gb);
845 
846  if (s->has_watermark)
847  skip_bits1(&h->gb);
848 
849  skip_bits1(&h->gb);
850  skip_bits(&h->gb, 2);
851 
852  if (skip_1stop_8data_bits(&h->gb) < 0)
853  return AVERROR_INVALIDDATA;
854 
855  /* reset intra predictors and invalidate motion vector references */
856  if (sl->mb_x > 0) {
857  memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
858  -1, 4 * sizeof(int8_t));
859  memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - sl->mb_x],
860  -1, 8 * sizeof(int8_t) * sl->mb_x);
861  }
862  if (sl->mb_y > 0) {
863  memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
864  -1, 8 * sizeof(int8_t) * (h->mb_width - sl->mb_x));
865 
866  if (sl->mb_x > 0)
867  sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
868  }
869 
870  return 0;
871 }
872 
874 {
875  SVQ3Context *s = avctx->priv_data;
876  H264Context *h = &s->h;
877  H264SliceContext *sl;
878  int m;
879  unsigned char *extradata;
880  unsigned char *extradata_end;
881  unsigned int size;
882  int marker_found = 0;
883  int ret;
884 
885  s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
886  s->last_pic = av_mallocz(sizeof(*s->last_pic));
887  s->next_pic = av_mallocz(sizeof(*s->next_pic));
888  if (!s->next_pic || !s->last_pic || !s->cur_pic) {
889  ret = AVERROR(ENOMEM);
890  goto fail;
891  }
892 
893  s->cur_pic->f = av_frame_alloc();
894  s->last_pic->f = av_frame_alloc();
895  s->next_pic->f = av_frame_alloc();
896  if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
897  return AVERROR(ENOMEM);
898 
899  if ((ret = ff_h264_decode_init(avctx)) < 0)
900  goto fail;
901 
902  // we will overwrite it later during decoding
903  av_frame_free(&h->cur_pic.f);
904 
906 
907  ff_h264dsp_init(&h->h264dsp, 8, 1);
910  ff_videodsp_init(&h->vdsp, 8);
911 
912  memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));
913  memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));
914 
915  avctx->bits_per_raw_sample = 8;
916  h->sps.bit_depth_luma = 8;
917  h->chroma_format_idc = 1;
918 
919  ff_hpeldsp_init(&s->hdsp, avctx->flags);
920  ff_tpeldsp_init(&s->tdsp);
921 
922  sl = h->slice_ctx;
923 
924  h->flags = avctx->flags;
925  sl->is_complex = 1;
926  h->sps.chroma_format_idc = 1;
928  avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
929  avctx->color_range = AVCOL_RANGE_JPEG;
930 
931  h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
932  h->chroma_x_shift = h->chroma_y_shift = 1;
933 
934  s->halfpel_flag = 1;
935  s->thirdpel_flag = 1;
936  s->has_watermark = 0;
937 
938  /* prowl for the "SEQH" marker in the extradata */
939  extradata = (unsigned char *)avctx->extradata;
940  extradata_end = avctx->extradata + avctx->extradata_size;
941  if (extradata) {
942  for (m = 0; m + 8 < avctx->extradata_size; m++) {
943  if (!memcmp(extradata, "SEQH", 4)) {
944  marker_found = 1;
945  break;
946  }
947  extradata++;
948  }
949  }
950 
951  /* if a match was found, parse the extra data */
952  if (marker_found) {
953  GetBitContext gb;
954  int frame_size_code;
955  int unk0, unk1, unk2, unk3, unk4;
956 
957  size = AV_RB32(&extradata[4]);
958  if (size > extradata_end - extradata - 8) {
959  ret = AVERROR_INVALIDDATA;
960  goto fail;
961  }
962  init_get_bits(&gb, extradata + 8, size * 8);
963 
964  /* 'frame size code' and optional 'width, height' */
965  frame_size_code = get_bits(&gb, 3);
966  switch (frame_size_code) {
967  case 0:
968  avctx->width = 160;
969  avctx->height = 120;
970  break;
971  case 1:
972  avctx->width = 128;
973  avctx->height = 96;
974  break;
975  case 2:
976  avctx->width = 176;
977  avctx->height = 144;
978  break;
979  case 3:
980  avctx->width = 352;
981  avctx->height = 288;
982  break;
983  case 4:
984  avctx->width = 704;
985  avctx->height = 576;
986  break;
987  case 5:
988  avctx->width = 240;
989  avctx->height = 180;
990  break;
991  case 6:
992  avctx->width = 320;
993  avctx->height = 240;
994  break;
995  case 7:
996  avctx->width = get_bits(&gb, 12);
997  avctx->height = get_bits(&gb, 12);
998  break;
999  }
1000 
1001  s->halfpel_flag = get_bits1(&gb);
1002  s->thirdpel_flag = get_bits1(&gb);
1003 
1004  /* unknown fields */
1005  unk0 = get_bits1(&gb);
1006  unk1 = get_bits1(&gb);
1007  unk2 = get_bits1(&gb);
1008  unk3 = get_bits1(&gb);
1009 
1010  h->low_delay = get_bits1(&gb);
1011 
1012  /* unknown field */
1013  unk4 = get_bits1(&gb);
1014 
1015  av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1016  unk0, unk1, unk2, unk3, unk4);
1017 
1018  if (skip_1stop_8data_bits(&gb) < 0) {
1019  ret = AVERROR_INVALIDDATA;
1020  goto fail;
1021  }
1022 
1023  s->has_watermark = get_bits1(&gb);
1024  avctx->has_b_frames = !h->low_delay;
1025  if (s->has_watermark) {
1026 #if CONFIG_ZLIB
1027  unsigned watermark_width = svq3_get_ue_golomb(&gb);
1028  unsigned watermark_height = svq3_get_ue_golomb(&gb);
1029  int u1 = svq3_get_ue_golomb(&gb);
1030  int u2 = get_bits(&gb, 8);
1031  int u3 = get_bits(&gb, 2);
1032  int u4 = svq3_get_ue_golomb(&gb);
1033  unsigned long buf_len = watermark_width *
1034  watermark_height * 4;
1035  int offset = get_bits_count(&gb) + 7 >> 3;
1036  uint8_t *buf;
1037 
1038  if (watermark_height <= 0 ||
1039  (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
1040  ret = -1;
1041  goto fail;
1042  }
1043 
1044  buf = av_malloc(buf_len);
1045  if (!buf) {
1046  ret = AVERROR(ENOMEM);
1047  goto fail;
1048  }
1049  av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1050  watermark_width, watermark_height);
1051  av_log(avctx, AV_LOG_DEBUG,
1052  "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1053  u1, u2, u3, u4, offset);
1054  if (uncompress(buf, &buf_len, extradata + 8 + offset,
1055  size - offset) != Z_OK) {
1056  av_log(avctx, AV_LOG_ERROR,
1057  "could not uncompress watermark logo\n");
1058  av_free(buf);
1059  ret = -1;
1060  goto fail;
1061  }
1062  s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1063  s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1064  av_log(avctx, AV_LOG_DEBUG,
1065  "watermark key %#"PRIx32"\n", s->watermark_key);
1066  av_free(buf);
1067 #else
1068  av_log(avctx, AV_LOG_ERROR,
1069  "this svq3 file contains watermark which need zlib support compiled in\n");
1070  ret = -1;
1071  goto fail;
1072 #endif
1073  }
1074  }
1075 
1076  h->width = avctx->width;
1077  h->height = avctx->height;
1078  h->mb_width = (h->width + 15) / 16;
1079  h->mb_height = (h->height + 15) / 16;
1080  h->mb_stride = h->mb_width + 1;
1081  h->mb_num = h->mb_width * h->mb_height;
1082  h->b_stride = 4 * h->mb_width;
1083  s->h_edge_pos = h->mb_width * 16;
1084  s->v_edge_pos = h->mb_height * 16;
1085 
1086  if ((ret = ff_h264_alloc_tables(h)) < 0) {
1087  av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1088  goto fail;
1089  }
1090 
1091  return 0;
1092 fail:
1093  svq3_decode_end(avctx);
1094  return ret;
1095 }
1096 
1097 static void free_picture(AVCodecContext *avctx, H264Picture *pic)
1098 {
1099  int i;
1100  for (i = 0; i < 2; i++) {
1101  av_buffer_unref(&pic->motion_val_buf[i]);
1102  av_buffer_unref(&pic->ref_index_buf[i]);
1103  }
1105 
1106  av_frame_unref(pic->f);
1107 }
1108 
1109 static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
1110 {
1111  SVQ3Context *s = avctx->priv_data;
1112  H264Context *h = &s->h;
1113  H264SliceContext *sl = &h->slice_ctx[0];
1114  const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
1115  const int mb_array_size = h->mb_stride * h->mb_height;
1116  const int b4_stride = h->mb_width * 4 + 1;
1117  const int b4_array_size = b4_stride * h->mb_height * 4;
1118  int ret;
1119 
1120  if (!pic->motion_val_buf[0]) {
1121  int i;
1122 
1123  pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1124  if (!pic->mb_type_buf)
1125  return AVERROR(ENOMEM);
1126  pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
1127 
1128  for (i = 0; i < 2; i++) {
1129  pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1130  pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1131  if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1132  ret = AVERROR(ENOMEM);
1133  goto fail;
1134  }
1135 
1136  pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1137  pic->ref_index[i] = pic->ref_index_buf[i]->data;
1138  }
1139  }
1140  pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1141 
1142  ret = ff_get_buffer(avctx, pic->f,
1143  pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1144  if (ret < 0)
1145  goto fail;
1146 
1147  if (!sl->edge_emu_buffer) {
1148  sl->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1149  if (!sl->edge_emu_buffer)
1150  return AVERROR(ENOMEM);
1151  }
1152 
1153  sl->linesize = pic->f->linesize[0];
1154  sl->uvlinesize = pic->f->linesize[1];
1155 
1156  return 0;
1157 fail:
1158  free_picture(avctx, pic);
1159  return ret;
1160 }
1161 
1162 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1163  int *got_frame, AVPacket *avpkt)
1164 {
1165  SVQ3Context *s = avctx->priv_data;
1166  H264Context *h = &s->h;
1167  H264SliceContext *sl = &h->slice_ctx[0];
1168  int buf_size = avpkt->size;
1169  int left;
1170  uint8_t *buf;
1171  int ret, m, i;
1172 
1173  /* special case for last picture */
1174  if (buf_size == 0) {
1175  if (s->next_pic->f->data[0] && !h->low_delay && !s->last_frame_output) {
1176  ret = av_frame_ref(data, s->next_pic->f);
1177  if (ret < 0)
1178  return ret;
1179  s->last_frame_output = 1;
1180  *got_frame = 1;
1181  }
1182  return 0;
1183  }
1184 
1185  sl->mb_x = sl->mb_y = sl->mb_xy = 0;
1186 
1187  if (s->watermark_key) {
1188  av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1189  if (!s->buf)
1190  return AVERROR(ENOMEM);
1191  memcpy(s->buf, avpkt->data, buf_size);
1192  buf = s->buf;
1193  } else {
1194  buf = avpkt->data;
1195  }
1196 
1197  init_get_bits(&h->gb, buf, 8 * buf_size);
1198 
1199  if (svq3_decode_slice_header(avctx))
1200  return -1;
1201 
1202  h->pict_type = sl->slice_type;
1203 
1204  if (h->pict_type != AV_PICTURE_TYPE_B)
1205  FFSWAP(H264Picture*, s->next_pic, s->last_pic);
1206 
1207  av_frame_unref(s->cur_pic->f);
1208 
1209  /* for skipping the frame */
1210  s->cur_pic->f->pict_type = h->pict_type;
1212 
1213  ret = get_buffer(avctx, s->cur_pic);
1214  if (ret < 0)
1215  return ret;
1216 
1217  h->cur_pic_ptr = s->cur_pic;
1218  h->cur_pic = *s->cur_pic;
1219 
1220  for (i = 0; i < 16; i++) {
1221  h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1222  h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1223  }
1224  for (i = 0; i < 16; i++) {
1225  h->block_offset[16 + i] =
1226  h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1227  h->block_offset[48 + 16 + i] =
1228  h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1229  }
1230 
1231  if (h->pict_type != AV_PICTURE_TYPE_I) {
1232  if (!s->last_pic->f->data[0]) {
1233  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1234  av_frame_unref(s->last_pic->f);
1235  ret = get_buffer(avctx, s->last_pic);
1236  if (ret < 0)
1237  return ret;
1238  memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1239  memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1240  s->last_pic->f->linesize[1]);
1241  memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1242  s->last_pic->f->linesize[2]);
1243  }
1244 
1245  if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1246  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1247  av_frame_unref(s->next_pic->f);
1248  ret = get_buffer(avctx, s->next_pic);
1249  if (ret < 0)
1250  return ret;
1251  memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1252  memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1253  s->next_pic->f->linesize[1]);
1254  memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1255  s->next_pic->f->linesize[2]);
1256  }
1257  }
1258 
1259  if (avctx->debug & FF_DEBUG_PICT_INFO)
1261  "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1263  s->halfpel_flag, s->thirdpel_flag,
1264  s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
1265 
1266  if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1268  avctx->skip_frame >= AVDISCARD_ALL)
1269  return 0;
1270 
1271  if (s->next_p_frame_damaged) {
1272  if (h->pict_type == AV_PICTURE_TYPE_B)
1273  return 0;
1274  else
1275  s->next_p_frame_damaged = 0;
1276  }
1277 
1278  if (h->pict_type == AV_PICTURE_TYPE_B) {
1280 
1281  if (h->frame_num_offset < 0)
1282  h->frame_num_offset += 256;
1283  if (h->frame_num_offset == 0 ||
1285  av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1286  return -1;
1287  }
1288  } else {
1289  h->prev_frame_num = h->frame_num;
1290  h->frame_num = sl->slice_num;
1292 
1293  if (h->prev_frame_num_offset < 0)
1294  h->prev_frame_num_offset += 256;
1295  }
1296 
1297  for (m = 0; m < 2; m++) {
1298  int i;
1299  for (i = 0; i < 4; i++) {
1300  int j;
1301  for (j = -1; j < 4; j++)
1302  sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1303  if (i < 3)
1304  sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1305  }
1306  }
1307 
1308  for (sl->mb_y = 0; sl->mb_y < h->mb_height; sl->mb_y++) {
1309  for (sl->mb_x = 0; sl->mb_x < h->mb_width; sl->mb_x++) {
1310  unsigned mb_type;
1311  sl->mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
1312 
1313  if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1314  ((get_bits_count(&h->gb) & 7) == 0 ||
1315  show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1316  skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1317  h->gb.size_in_bits = 8 * buf_size;
1318 
1319  if (svq3_decode_slice_header(avctx))
1320  return -1;
1321 
1322  /* TODO: support s->mb_skip_run */
1323  }
1324 
1325  mb_type = svq3_get_ue_golomb(&h->gb);
1326 
1327  if (h->pict_type == AV_PICTURE_TYPE_I)
1328  mb_type += 8;
1329  else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1330  mb_type += 4;
1331  if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1333  "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
1334  return -1;
1335  }
1336 
1337  if (mb_type != 0 || sl->cbp)
1338  ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
1339 
1340  if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1341  h->cur_pic.mb_type[sl->mb_x + sl->mb_y * h->mb_stride] =
1342  (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1343  }
1344 
1345  ff_draw_horiz_band(avctx, s->cur_pic->f,
1346  s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1347  16 * sl->mb_y, 16, h->picture_structure, 0,
1348  h->low_delay);
1349  }
1350 
1351  left = buf_size*8 - get_bits_count(&h->gb);
1352 
1353  if (sl->mb_y != h->mb_height || sl->mb_x != h->mb_width) {
1354  av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, sl->mb_y, sl->mb_x, left);
1355  //av_hex_dump(stderr, buf+buf_size-8, 8);
1356  }
1357 
1358  if (left < 0) {
1359  av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1360  return -1;
1361  }
1362 
1363  if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1364  ret = av_frame_ref(data, s->cur_pic->f);
1365  else if (s->last_pic->f->data[0])
1366  ret = av_frame_ref(data, s->last_pic->f);
1367  if (ret < 0)
1368  return ret;
1369 
1370  /* Do not output the last pic after seeking. */
1371  if (s->last_pic->f->data[0] || h->low_delay)
1372  *got_frame = 1;
1373 
1374  if (h->pict_type != AV_PICTURE_TYPE_B) {
1375  FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
1376  } else {
1377  av_frame_unref(s->cur_pic->f);
1378  }
1379 
1380  return buf_size;
1381 }
1382 
1384 {
1385  SVQ3Context *s = avctx->priv_data;
1386  H264Context *h = &s->h;
1387 
1388  free_picture(avctx, s->cur_pic);
1389  free_picture(avctx, s->next_pic);
1390  free_picture(avctx, s->last_pic);
1391  av_frame_free(&s->cur_pic->f);
1392  av_frame_free(&s->next_pic->f);
1393  av_frame_free(&s->last_pic->f);
1394  av_freep(&s->cur_pic);
1395  av_freep(&s->next_pic);
1396  av_freep(&s->last_pic);
1397 
1398  memset(&h->cur_pic, 0, sizeof(h->cur_pic));
1399 
1401 
1402  av_freep(&s->buf);
1403  s->buf_size = 0;
1404 
1405  return 0;
1406 }
1407 
1409  .name = "svq3",
1410  .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1411  .type = AVMEDIA_TYPE_VIDEO,
1412  .id = AV_CODEC_ID_SVQ3,
1413  .priv_data_size = sizeof(SVQ3Context),
1415  .close = svq3_decode_end,
1417  .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1420  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1421  AV_PIX_FMT_NONE},
1422 };
int chroma_format_idc
Definition: h264.h:178
#define MB_TYPE_INTRA16x16
Definition: avcodec.h:1141
uint8_t pred_mode
Definition: h264data.h:75
#define NULL
Definition: coverity.c:32
#define MB_TYPE_SKIP
Definition: avcodec.h:1151
int ff_h264_check_intra_pred_mode(const H264Context *h, H264SliceContext *sl, 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.c:184
discard all frames except keyframes
Definition: avcodec.h:687
const char * s
Definition: avisynth_c.h:631
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
GetBitContext gb
Definition: h264.h:524
int16_t mb[16 *48 *2]
Definition: h264.h:494
int low_delay
Definition: h264.h:550
int mb_num
Definition: h264.h:621
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:124
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264.h:486
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
HpelDSPContext hdsp
Definition: svq3.c:74
op_pixels_func avg_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:68
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
uint16_t ff_svq1_packet_checksum(const uint8_t *data, const int length, int value)
Definition: svq13.c:60
static int svq3_decode_block(GetBitContext *gb, int16_t *block, int index, const int type)
Definition: svq3.c:242
else temp
Definition: vf_mcdeint.c:257
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:217
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
av_cold int ff_h264_decode_init(AVCodecContext *avctx)
Definition: h264.c:647
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2236
AVBufferRef * mb_type_buf
Definition: h264.h:319
int size
Definition: avcodec.h:1423
#define MB_TYPE_INTRA4x4
Definition: avcodec.h:1140
int chroma_x_shift
Definition: h264.h:538
const uint8_t * buffer
Definition: get_bits.h:55
static unsigned svq3_get_ue_golomb(GetBitContext *gb)
Definition: golomb.h:115
#define INVALID_VLC
Definition: golomb.h:38
int16_t(*[2] motion_val)[2]
Definition: h264.h:317
int flags
Definition: h264.h:553
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1721
int mb_height
Definition: h264.h:619
av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, int chroma_format_idc)
Set the intra prediction function pointers.
Definition: h264pred.c:411
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:126
int v_edge_pos
Definition: svq3.c:89
H264Context.
Definition: h264.h:517
discard all
Definition: avcodec.h:688
AVFrame * f
Definition: h264.h:310
uint8_t run
Definition: svq3.c:149
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:3004
#define FULLPEL_MODE
Definition: svq3.c:93
void ff_draw_horiz_band(AVCodecContext *avctx, AVFrame *cur, AVFrame *last, int y, int h, int picture_structure, int first_field, int low_delay)
Draw a horizontal band if supported.
Definition: mpegutils.c:30
AVCodec.
Definition: avcodec.h:3473
int picture_structure
Definition: h264.h:590
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
#define AV_COPY32(d, s)
Definition: intreadwrite.h:586
Macro definitions for various function/variable attributes.
static int svq3_mc_dir(SVQ3Context *s, int size, int mode, int dir, int avg)
Definition: svq3.c:375
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:3227
static const uint8_t golomb_to_pict_type[5]
Definition: h264data.h:37
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:881
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int is_complex
Definition: h264.h:432
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
uint8_t scaling_matrix4[6][16]
Definition: h264.h:253
int has_watermark
Definition: svq3.c:81
int thirdpel_flag
Definition: svq3.c:80
if()
Definition: avfilter.c:975
static const uint8_t luma_dc_zigzag_scan[16]
Definition: svq3.c:114
uint8_t
#define av_cold
Definition: attributes.h:74
int prev_frame_num_offset
for POC type 2
Definition: h264.h:654
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
#define DC_PRED8x8
Definition: h264pred.h:68
mode
Definition: f_perms.c:27
int bit_depth_chroma
bit_depth_chroma_minus8 + 8
Definition: h264.h:228
int slice_type
Definition: h264.h:368
H264Picture * last_pic
Definition: svq3.c:78
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:363
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1616
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
int height
Definition: h264.h:537
static const IMbInfo i_mb_type_info[26]
Definition: h264data.h:79
uint8_t * data
Definition: avcodec.h:1422
thirdpel DSP context
Definition: tpeldsp.h:42
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
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:89
static const struct @92 svq3_dct_tables[2][16]
int chroma_y_shift
Definition: h264.h:538
thirdpel DSP functions
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color, int update)
Definition: ffplay.c:784
ptrdiff_t size
Definition: opengl_enc.c:101
static const uint8_t header[24]
Definition: sdr2.c:67
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:762
int chroma_qp[2]
Definition: h264.h:373
#define av_log(a,...)
unsigned m
Definition: audioconvert.c:187
int width
Definition: h264.h:537
static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
Definition: svq3.c:490
H.264 / AVC / MPEG4 part10 codec.
int slice_num
Definition: h264.h:367
#define U(x)
Definition: vp56_arith.h:37
int frame_num
Definition: h264.h:650
unsigned int topright_samples_available
Definition: h264.h:418
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
Definition: h264_mb.c:818
static void free_picture(AVCodecContext *avctx, H264Picture *pic)
Definition: svq3.c:1097
H264PredContext hpc
Definition: h264.h:557
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int next_slice_index
Definition: svq3.c:82
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1811
#define HALFPEL_MODE
Definition: svq3.c:94
static av_always_inline void write_back_intra_pred_mode(const H264Context *h, H264SliceContext *sl)
Definition: h264.h:1068
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:148
av_cold void ff_tpeldsp_init(TpelDSPContext *c)
Definition: tpeldsp.c:312
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:175
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264.h:400
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
PPS pps
current pps
Definition: h264.h:577
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1596
GLsizei GLsizei * length
Definition: opengl_enc.c:115
const char * name
Name of the codec implementation.
Definition: avcodec.h:3480
#define IS_SKIP(a)
Definition: mpegutils.h:77
unsigned int top_samples_available
Definition: h264.h:417
#define PREDICT_MODE
Definition: svq3.c:96
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264.h:1023
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
Libavcodec external API header.
#define fail()
Definition: checkasm.h:55
Sorenson Vector Quantizer #1 (SVQ1) video codec.
int mb_skip_run
Definition: h264.h:431
static const uint8_t scan8[16 *3+3]
Definition: h264.h:1007
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
static int svq3_get_se_golomb(GetBitContext *gb)
Definition: golomb.h:222
int16_t mb_luma_dc[3][16 *2]
as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not too lar...
Definition: h264.h:495
uint8_t scaling_matrix8[6][64]
Definition: h264.h:254
void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block, int stride, int qp, int dc)
Definition: svq3.c:202
useful rectangle filling function
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
tpel_mc_func avg_tpel_pixels_tab[11]
Definition: tpeldsp.h:54
Half-pel DSP context.
Definition: hpeldsp.h:45
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: avcodec.h:850
AVBufferRef * motion_val_buf[2]
Definition: h264.h:316
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:242
int frame_num_offset
for POC type 2
Definition: h264.h:653
int chroma_pred_mode
Definition: h264.h:397
uint32_t * mb2br_xy
Definition: h264.h:571
#define FFMIN(a, b)
Definition: common.h:66
av_cold void ff_h264dsp_init(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)
Definition: h264dsp.c:67
float y
int reference
Definition: h264.h:341
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:75
H264Context h
Definition: svq3.c:73
ret
Definition: avfilter.c:974
int width
picture width / height.
Definition: avcodec.h:1680
void ff_svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
Definition: svq3.c:167
uint32_t * mb_type
Definition: h264.h:320
SPS sps
current sps
Definition: h264.h:576
int size_in_bits
Definition: get_bits.h:57
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:287
static av_cold int svq3_decode_init(AVCodecContext *avctx)
Definition: svq3.c:873
tpel_mc_func put_tpel_pixels_tab[11]
Thirdpel motion compensation with rounding (a + b + 1) >> 1.
Definition: tpeldsp.h:53
H264SliceContext * slice_ctx
Definition: h264.h:531
float u
H264Picture * cur_pic
Definition: svq3.c:76
static const uint8_t golomb_to_intra4x4_cbp[48]
Definition: h264data.h:42
int last_frame_output
Definition: svq3.c:90
#define PART_NOT_AVAILABLE
Definition: h264.h:562
int next_p_frame_damaged
Definition: svq3.c:87
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:526
#define IS_INTRA16x16(a)
Definition: mpegutils.h:72
uint8_t * edge_emu_buffer
Definition: h264.h:471
static const int8_t mv[256][2]
Definition: 4xm.c:77
int chroma_format_idc
chroma format from sps to detect changes
Definition: h264.h:636
VideoDSPContext vdsp
Definition: h264.h:520
int intra16x16_pred_mode
Definition: h264.h:398
Half-pel DSP functions.
AVCodec ff_svq3_decoder
Definition: svq3.c:1408
int mb_stride
Definition: h264.h:620
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AVCodecContext * avctx
Definition: h264.h:519
AVS_Value src
Definition: avisynth_c.h:482
H264 / AVC / MPEG4 part10 codec data table
static const uint8_t zigzag_scan[16+1]
Definition: h264data.h:54
int prev_frame_num
frame_num of the last pic for POC type 1/2
Definition: h264.h:655
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
int debug
debug
Definition: avcodec.h:2841
main external API structure.
Definition: avcodec.h:1501
uint8_t * data
The data buffer.
Definition: buffer.h:89
int ff_h264_alloc_tables(H264Context *h)
Allocate tables.
Definition: h264.c:398
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:1040
int ff_h264_check_intra4x4_pred_mode(const H264Context *h, H264SliceContext *sl)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
Definition: h264.c:137
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
void * buf
Definition: avisynth_c.h:553
GLint GLenum type
Definition: opengl_enc.c:105
int extradata_size
Definition: avcodec.h:1617
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:82
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
BYTE int const BYTE int int int height
Definition: avisynth_c.h:676
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:329
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:297
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264.h:481
int index
Definition: gxfenc.c:89
static const uint8_t chroma_dc_scan[4]
Definition: h264data.h:61
int8_t * ref_index[2]
Definition: h264.h:326
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:300
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:410
#define MB_TYPE_16x16
Definition: avcodec.h:1143
H264Picture * cur_pic_ptr
Definition: h264.h:527
static int svq3_decode_end(AVCodecContext *avctx)
Definition: svq3.c:1383
static const uint8_t svq3_pred_0[25][2]
Definition: svq3.c:121
#define IS_INTER(a)
Definition: mpegutils.h:75
uint8_t * buf
Definition: svq3.c:84
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:209
ptrdiff_t linesize
Definition: h264.h:421
int block_offset[2 *(16 *3)]
block_offset[ 0..23] for frame macroblocks block_offset[24..47] for field macroblocks ...
Definition: h264.h:568
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:462
ptrdiff_t uvlinesize
Definition: h264.h:421
av_cold void ff_h264_free_context(H264Context *h)
Free any data that may have been allocated in the H264 context like SPS, PPS etc. ...
Definition: h264.c:1901
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
uint8_t level
Definition: svq3.c:150
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2842
Definition: vp9.h:48
#define AV_ZERO128(d)
Definition: intreadwrite.h:622
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:522
discard all non reference
Definition: avcodec.h:684
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
uint8_t cbp
Definition: h264data.h:76
common internal api header.
H264Picture * next_pic
Definition: svq3.c:77
int h_edge_pos
Definition: svq3.c:88
static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
Definition: svq3.c:1109
H.264 / AVC / MPEG4 part10 motion vector predicion.
Bi-dir predicted.
Definition: avutil.h:276
#define stride
int8_t * intra4x4_pred_mode
Definition: h264.h:401
static const uint8_t golomb_to_inter_cbp[48]
Definition: h264data.h:48
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264.h:227
#define IS_INTRA(x, y)
static const uint32_t svq3_dequant_coeff[32]
Definition: svq3.c:158
void * priv_data
Definition: avcodec.h:1543
#define THIRDPEL_MODE
Definition: svq3.c:95
#define PICT_FRAME
Definition: mpegutils.h:35
#define IS_INTRA4x4(a)
Definition: mpegutils.h:71
#define av_free(p)
int8_t ref_cache[2][5 *8]
Definition: h264.h:487
#define av_log2
Definition: intmath.h:105
static int svq3_decode_slice_header(AVCodecContext *avctx)
Definition: svq3.c:781
H264Picture cur_pic
Definition: h264.h:528
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:237
#define AV_ZERO32(d)
Definition: intreadwrite.h:614
int mb_width
Definition: h264.h:619
enum AVPictureType pict_type
Definition: h264.h:710
TpelDSPContext tdsp
Definition: svq3.c:75
static const uint8_t svq3_scan[16]
Definition: svq3.c:107
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
AVBufferRef * ref_index_buf[2]
Definition: h264.h:325
H264Picture last_pic_for_ec
Definition: h264.h:529
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:228
static const int8_t svq3_pred_1[6][6][5]
Definition: svq3.c:133
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2292
H264DSPContext h264dsp
Definition: h264.h:521
unsigned int left_samples_available
Definition: h264.h:419
#define av_freep(p)
uint32_t watermark_key
Definition: svq3.c:83
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:593
#define FFSWAP(type, a, b)
Definition: common.h:69
int buf_size
Definition: svq3.c:85
exp golomb vlc stuff
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
This structure stores compressed data.
Definition: avcodec.h:1399
static int svq3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: svq3.c:1162
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1215
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:856
for(j=16;j >0;--j)
int b_stride
Definition: h264.h:572
Predicted.
Definition: avutil.h:275
int halfpel_flag
Definition: svq3.c:79
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
int adaptive_quant
Definition: svq3.c:86
static av_always_inline void pred_motion(const H264Context *const h, H264SliceContext *sl, int n, int part_width, int list, int ref, int *const mx, int *const my)
Get the predicted MV.
Definition: h264_mvpred.h:95
static int width
static int16_t block[64]
Definition: dct-test.c:110