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 {
73  H264Context h;
74  HpelDSPContext hdsp;
75  TpelDSPContext tdsp;
76  H264Picture *cur_pic;
77  H264Picture *next_pic;
78  H264Picture *last_pic;
79  int halfpel_flag;
80  int thirdpel_flag;
81  int unknown_flag;
82  int next_slice_index;
83  uint32_t watermark_key;
84  uint8_t *buf;
85  int buf_size;
86  int adaptive_quant;
87  int next_p_frame_damaged;
88  int h_edge_pos;
89  int v_edge_pos;
90  int last_frame_output;
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 {
149  uint8_t run;
150  uint8_t level;
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] =
246  { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
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  const H264Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
307  uint8_t *src, *dest;
308  int i, emu = 0;
309  int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
310 
311  mx += x;
312  my += y;
313 
314  if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
315  my < 0 || my >= s->v_edge_pos - height - 1) {
316  emu = 1;
317  mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
318  my = av_clip(my, -16, s->v_edge_pos - height + 15);
319  }
320 
321  /* form component predictions */
322  dest = h->cur_pic.f.data[0] + x + y * h->linesize;
323  src = pic->f.data[0] + mx + my * h->linesize;
324 
325  if (emu) {
326  h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src,
327  h->linesize, h->linesize,
328  width + 1, height + 1,
329  mx, my, s->h_edge_pos, s->v_edge_pos);
330  src = h->edge_emu_buffer;
331  }
332  if (thirdpel)
333  (avg ? s->tdsp.avg_tpel_pixels_tab
334  : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, h->linesize,
335  width, height);
336  else
337  (avg ? s->hdsp.avg_pixels_tab
338  : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, h->linesize,
339  height);
340 
341  if (!(h->flags & CODEC_FLAG_GRAY)) {
342  mx = mx + (mx < (int) x) >> 1;
343  my = my + (my < (int) y) >> 1;
344  width = width >> 1;
345  height = height >> 1;
346  blocksize++;
347 
348  for (i = 1; i < 3; i++) {
349  dest = h->cur_pic.f.data[i] + (x >> 1) + (y >> 1) * h->uvlinesize;
350  src = pic->f.data[i] + mx + my * h->uvlinesize;
351 
352  if (emu) {
353  h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src,
354  h->uvlinesize, h->uvlinesize,
355  width + 1, height + 1,
356  mx, my, (s->h_edge_pos >> 1),
357  s->v_edge_pos >> 1);
358  src = h->edge_emu_buffer;
359  }
360  if (thirdpel)
361  (avg ? s->tdsp.avg_tpel_pixels_tab
362  : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
363  h->uvlinesize,
364  width, height);
365  else
366  (avg ? s->hdsp.avg_pixels_tab
367  : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
368  h->uvlinesize,
369  height);
370  }
371  }
372 }
373 
374 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
375  int dir, int avg)
376 {
377  int i, j, k, mx, my, dx, dy, x, y;
378  H264Context *h = &s->h;
379  const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
380  const int part_height = 16 >> ((unsigned)(size + 1) / 3);
381  const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
382  const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
383  const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
384 
385  for (i = 0; i < 16; i += part_height)
386  for (j = 0; j < 16; j += part_width) {
387  const int b_xy = (4 * h->mb_x + (j >> 2)) +
388  (4 * h->mb_y + (i >> 2)) * h->b_stride;
389  int dxy;
390  x = 16 * h->mb_x + j;
391  y = 16 * h->mb_y + i;
392  k = (j >> 2 & 1) + (i >> 1 & 2) +
393  (j >> 1 & 4) + (i & 8);
394 
395  if (mode != PREDICT_MODE) {
396  pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
397  } else {
398  mx = s->next_pic->motion_val[0][b_xy][0] << 1;
399  my = s->next_pic->motion_val[0][b_xy][1] << 1;
400 
401  if (dir == 0) {
402  mx = mx * h->frame_num_offset /
403  h->prev_frame_num_offset + 1 >> 1;
404  my = my * h->frame_num_offset /
405  h->prev_frame_num_offset + 1 >> 1;
406  } else {
407  mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
408  h->prev_frame_num_offset + 1 >> 1;
409  my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
410  h->prev_frame_num_offset + 1 >> 1;
411  }
412  }
413 
414  /* clip motion vector prediction to frame border */
415  mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
416  my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
417 
418  /* get (optional) motion vector differential */
419  if (mode == PREDICT_MODE) {
420  dx = dy = 0;
421  } else {
422  dy = svq3_get_se_golomb(&h->gb);
423  dx = svq3_get_se_golomb(&h->gb);
424 
425  if (dx == INVALID_VLC || dy == INVALID_VLC) {
426  av_log(h->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
427  return -1;
428  }
429  }
430 
431  /* compute motion vector */
432  if (mode == THIRDPEL_MODE) {
433  int fx, fy;
434  mx = (mx + 1 >> 1) + dx;
435  my = (my + 1 >> 1) + dy;
436  fx = (unsigned)(mx + 0x3000) / 3 - 0x1000;
437  fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
438  dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
439 
440  svq3_mc_dir_part(s, x, y, part_width, part_height,
441  fx, fy, dxy, 1, dir, avg);
442  mx += mx;
443  my += my;
444  } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
445  mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
446  my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
447  dxy = (mx & 1) + 2 * (my & 1);
448 
449  svq3_mc_dir_part(s, x, y, part_width, part_height,
450  mx >> 1, my >> 1, dxy, 0, dir, avg);
451  mx *= 3;
452  my *= 3;
453  } else {
454  mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
455  my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
456 
457  svq3_mc_dir_part(s, x, y, part_width, part_height,
458  mx, my, 0, 0, dir, avg);
459  mx *= 6;
460  my *= 6;
461  }
462 
463  /* update mv_cache */
464  if (mode != PREDICT_MODE) {
465  int32_t mv = pack16to32(mx, my);
466 
467  if (part_height == 8 && i < 8) {
468  AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
469 
470  if (part_width == 8 && j < 8)
471  AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
472  }
473  if (part_width == 8 && j < 8)
474  AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
475  if (part_width == 4 || part_height == 4)
476  AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
477  }
478 
479  /* write back motion vectors */
480  fill_rectangle(h->cur_pic.motion_val[dir][b_xy],
481  part_width >> 2, part_height >> 2, h->b_stride,
482  pack16to32(mx, my), 4);
483  }
484 
485  return 0;
486 }
487 
488 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
489 {
490  H264Context *h = &s->h;
491  int i, j, k, m, dir, mode;
492  int cbp = 0;
493  uint32_t vlc;
494  int8_t *top, *left;
495  const int mb_xy = h->mb_xy;
496  const int b_xy = 4 * h->mb_x + 4 * h->mb_y * h->b_stride;
497 
498  h->top_samples_available = (h->mb_y == 0) ? 0x33FF : 0xFFFF;
499  h->left_samples_available = (h->mb_x == 0) ? 0x5F5F : 0xFFFF;
500  h->topright_samples_available = 0xFFFF;
501 
502  if (mb_type == 0) { /* SKIP */
503  if (h->pict_type == AV_PICTURE_TYPE_P ||
504  s->next_pic->mb_type[mb_xy] == -1) {
505  svq3_mc_dir_part(s, 16 * h->mb_x, 16 * h->mb_y, 16, 16,
506  0, 0, 0, 0, 0, 0);
507 
508  if (h->pict_type == AV_PICTURE_TYPE_B)
509  svq3_mc_dir_part(s, 16 * h->mb_x, 16 * h->mb_y, 16, 16,
510  0, 0, 0, 0, 1, 1);
511 
512  mb_type = MB_TYPE_SKIP;
513  } else {
514  mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
515  if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
516  return -1;
517  if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
518  return -1;
519 
520  mb_type = MB_TYPE_16x16;
521  }
522  } else if (mb_type < 8) { /* INTER */
523  if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&h->gb))
524  mode = THIRDPEL_MODE;
525  else if (s->halfpel_flag &&
526  s->thirdpel_flag == !get_bits1(&h->gb))
527  mode = HALFPEL_MODE;
528  else
529  mode = FULLPEL_MODE;
530 
531  /* fill caches */
532  /* note ref_cache should contain here:
533  * ????????
534  * ???11111
535  * N??11111
536  * N??11111
537  * N??11111
538  */
539 
540  for (m = 0; m < 2; m++) {
541  if (h->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
542  for (i = 0; i < 4; i++)
543  AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
544  h->cur_pic.motion_val[m][b_xy - 1 + i * h->b_stride]);
545  } else {
546  for (i = 0; i < 4; i++)
547  AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
548  }
549  if (h->mb_y > 0) {
550  memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
551  h->cur_pic.motion_val[m][b_xy - h->b_stride],
552  4 * 2 * sizeof(int16_t));
553  memset(&h->ref_cache[m][scan8[0] - 1 * 8],
554  (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
555 
556  if (h->mb_x < h->mb_width - 1) {
557  AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
558  h->cur_pic.motion_val[m][b_xy - h->b_stride + 4]);
559  h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
560  (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride + 1] + 6] == -1 ||
561  h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
562  } else
563  h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
564  if (h->mb_x > 0) {
565  AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
566  h->cur_pic.motion_val[m][b_xy - h->b_stride - 1]);
567  h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
568  (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
569  } else
570  h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
571  } else
572  memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
573  PART_NOT_AVAILABLE, 8);
574 
575  if (h->pict_type != AV_PICTURE_TYPE_B)
576  break;
577  }
578 
579  /* decode motion vector(s) and form prediction(s) */
580  if (h->pict_type == AV_PICTURE_TYPE_P) {
581  if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
582  return -1;
583  } else { /* AV_PICTURE_TYPE_B */
584  if (mb_type != 2) {
585  if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
586  return -1;
587  } else {
588  for (i = 0; i < 4; i++)
589  memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
590  0, 4 * 2 * sizeof(int16_t));
591  }
592  if (mb_type != 1) {
593  if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
594  return -1;
595  } else {
596  for (i = 0; i < 4; i++)
597  memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
598  0, 4 * 2 * sizeof(int16_t));
599  }
600  }
601 
602  mb_type = MB_TYPE_16x16;
603  } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
604  memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
605 
606  if (mb_type == 8) {
607  if (h->mb_x > 0) {
608  for (i = 0; i < 4; i++)
609  h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
610  if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
611  h->left_samples_available = 0x5F5F;
612  }
613  if (h->mb_y > 0) {
614  h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 0];
615  h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 1];
616  h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 2];
617  h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 3];
618 
619  if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
620  h->top_samples_available = 0x33FF;
621  }
622 
623  /* decode prediction codes for luma blocks */
624  for (i = 0; i < 16; i += 2) {
625  vlc = svq3_get_ue_golomb(&h->gb);
626 
627  if (vlc >= 25U) {
628  av_log(h->avctx, AV_LOG_ERROR,
629  "luma prediction:%"PRIu32"\n", vlc);
630  return -1;
631  }
632 
633  left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
634  top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
635 
636  left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
637  left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
638 
639  if (left[1] == -1 || left[2] == -1) {
640  av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
641  return -1;
642  }
643  }
644  } else { /* mb_type == 33, DC_128_PRED block type */
645  for (i = 0; i < 4; i++)
646  memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
647  }
648 
649  write_back_intra_pred_mode(h);
650 
651  if (mb_type == 8) {
652  ff_h264_check_intra4x4_pred_mode(h);
653 
654  h->top_samples_available = (h->mb_y == 0) ? 0x33FF : 0xFFFF;
655  h->left_samples_available = (h->mb_x == 0) ? 0x5F5F : 0xFFFF;
656  } else {
657  for (i = 0; i < 4; i++)
658  memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
659 
660  h->top_samples_available = 0x33FF;
661  h->left_samples_available = 0x5F5F;
662  }
663 
664  mb_type = MB_TYPE_INTRA4x4;
665  } else { /* INTRA16x16 */
666  dir = i_mb_type_info[mb_type - 8].pred_mode;
667  dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
668 
669  if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) < 0) {
670  av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
671  return h->intra16x16_pred_mode;
672  }
673 
674  cbp = i_mb_type_info[mb_type - 8].cbp;
675  mb_type = MB_TYPE_INTRA16x16;
676  }
677 
678  if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
679  for (i = 0; i < 4; i++)
680  memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
681  0, 4 * 2 * sizeof(int16_t));
682  if (h->pict_type == AV_PICTURE_TYPE_B) {
683  for (i = 0; i < 4; i++)
684  memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
685  0, 4 * 2 * sizeof(int16_t));
686  }
687  }
688  if (!IS_INTRA4x4(mb_type)) {
689  memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
690  }
691  if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
692  memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
693  }
694 
695  if (!IS_INTRA16x16(mb_type) &&
696  (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
697  if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48U){
698  av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
699  return -1;
700  }
701 
702  cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
703  : golomb_to_inter_cbp[vlc];
704  }
705  if (IS_INTRA16x16(mb_type) ||
706  (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
707  h->qscale += svq3_get_se_golomb(&h->gb);
708 
709  if (h->qscale > 31u) {
710  av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", h->qscale);
711  return -1;
712  }
713  }
714  if (IS_INTRA16x16(mb_type)) {
715  AV_ZERO128(h->mb_luma_dc[0] + 0);
716  AV_ZERO128(h->mb_luma_dc[0] + 8);
717  if (svq3_decode_block(&h->gb, h->mb_luma_dc[0], 0, 1)) {
718  av_log(h->avctx, AV_LOG_ERROR,
719  "error while decoding intra luma dc\n");
720  return -1;
721  }
722  }
723 
724  if (cbp) {
725  const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
726  const int type = ((h->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
727 
728  for (i = 0; i < 4; i++)
729  if ((cbp & (1 << i))) {
730  for (j = 0; j < 4; j++) {
731  k = index ? (1 * (j & 1) + 2 * (i & 1) +
732  2 * (j & 2) + 4 * (i & 2))
733  : (4 * i + j);
734  h->non_zero_count_cache[scan8[k]] = 1;
735 
736  if (svq3_decode_block(&h->gb, &h->mb[16 * k], index, type)) {
737  av_log(h->avctx, AV_LOG_ERROR,
738  "error while decoding block\n");
739  return -1;
740  }
741  }
742  }
743 
744  if ((cbp & 0x30)) {
745  for (i = 1; i < 3; ++i)
746  if (svq3_decode_block(&h->gb, &h->mb[16 * 16 * i], 0, 3)) {
747  av_log(h->avctx, AV_LOG_ERROR,
748  "error while decoding chroma dc block\n");
749  return -1;
750  }
751 
752  if ((cbp & 0x20)) {
753  for (i = 1; i < 3; i++) {
754  for (j = 0; j < 4; j++) {
755  k = 16 * i + j;
756  h->non_zero_count_cache[scan8[k]] = 1;
757 
758  if (svq3_decode_block(&h->gb, &h->mb[16 * k], 1, 1)) {
759  av_log(h->avctx, AV_LOG_ERROR,
760  "error while decoding chroma ac block\n");
761  return -1;
762  }
763  }
764  }
765  }
766  }
767  }
768 
769  h->cbp = cbp;
770  h->cur_pic.mb_type[mb_xy] = mb_type;
771 
772  if (IS_INTRA(mb_type))
773  h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
774 
775  return 0;
776 }
777 
778 static int svq3_decode_slice_header(AVCodecContext *avctx)
779 {
780  SVQ3Context *s = avctx->priv_data;
781  H264Context *h = &s->h;
782  const int mb_xy = h->mb_xy;
783  int i, header;
784  unsigned slice_id;
785 
786  header = get_bits(&h->gb, 8);
787 
788  if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
789  /* TODO: what? */
790  av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
791  return -1;
792  } else {
793  int length = header >> 5 & 3;
794 
795  s->next_slice_index = get_bits_count(&h->gb) +
796  8 * show_bits(&h->gb, 8 * length) +
797  8 * length;
798 
799  if (s->next_slice_index > h->gb.size_in_bits) {
800  av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
801  return -1;
802  }
803 
804  h->gb.size_in_bits = s->next_slice_index - 8 * (length - 1);
805  skip_bits(&h->gb, 8);
806 
807  if (s->watermark_key) {
808  uint32_t header = AV_RL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1]);
809  AV_WL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1],
810  header ^ s->watermark_key);
811  }
812  if (length > 0) {
813  memmove((uint8_t *) &h->gb.buffer[get_bits_count(&h->gb) >> 3],
814  &h->gb.buffer[h->gb.size_in_bits >> 3], length - 1);
815  }
816  skip_bits_long(&h->gb, 0);
817  }
818 
819  if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
820  av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
821  return -1;
822  }
823 
824  h->slice_type = golomb_to_pict_type[slice_id];
825 
826  if ((header & 0x9F) == 2) {
827  i = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
828  h->mb_skip_run = get_bits(&h->gb, i) -
829  (h->mb_y * h->mb_width + h->mb_x);
830  } else {
831  skip_bits1(&h->gb);
832  h->mb_skip_run = 0;
833  }
834 
835  h->slice_num = get_bits(&h->gb, 8);
836  h->qscale = get_bits(&h->gb, 5);
837  s->adaptive_quant = get_bits1(&h->gb);
838 
839  /* unknown fields */
840  skip_bits1(&h->gb);
841 
842  if (s->unknown_flag)
843  skip_bits1(&h->gb);
844 
845  skip_bits1(&h->gb);
846  skip_bits(&h->gb, 2);
847 
848  if (skip_1stop_8data_bits(&h->gb) < 0)
849  return AVERROR_INVALIDDATA;
850 
851  /* reset intra predictors and invalidate motion vector references */
852  if (h->mb_x > 0) {
853  memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
854  -1, 4 * sizeof(int8_t));
855  memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_x],
856  -1, 8 * sizeof(int8_t) * h->mb_x);
857  }
858  if (h->mb_y > 0) {
859  memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
860  -1, 8 * sizeof(int8_t) * (h->mb_width - h->mb_x));
861 
862  if (h->mb_x > 0)
863  h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
864  }
865 
866  return 0;
867 }
868 
869 static av_cold int svq3_decode_init(AVCodecContext *avctx)
870 {
871  SVQ3Context *s = avctx->priv_data;
872  H264Context *h = &s->h;
873  int m;
874  unsigned char *extradata;
875  unsigned char *extradata_end;
876  unsigned int size;
877  int marker_found = 0;
878  int ret;
879 
880  s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
881  s->last_pic = av_mallocz(sizeof(*s->last_pic));
882  s->next_pic = av_mallocz(sizeof(*s->next_pic));
883  if (!s->next_pic || !s->last_pic || !s->cur_pic) {
884  ret = AVERROR(ENOMEM);
885  goto fail;
886  }
887 
888  if ((ret = ff_h264_decode_init(avctx)) < 0)
889  goto fail;
890 
891  ff_hpeldsp_init(&s->hdsp, avctx->flags);
892  ff_tpeldsp_init(&s->tdsp);
893 
894  h->flags = avctx->flags;
895  h->is_complex = 1;
896  h->sps.chroma_format_idc = 1;
897  h->picture_structure = PICT_FRAME;
898  avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
899  avctx->color_range = AVCOL_RANGE_JPEG;
900 
901  h->chroma_qp[0] = h->chroma_qp[1] = 4;
902  h->chroma_x_shift = h->chroma_y_shift = 1;
903 
904  s->halfpel_flag = 1;
905  s->thirdpel_flag = 1;
906  s->unknown_flag = 0;
907 
908  /* prowl for the "SEQH" marker in the extradata */
909  extradata = (unsigned char *)avctx->extradata;
910  extradata_end = avctx->extradata + avctx->extradata_size;
911  if (extradata) {
912  for (m = 0; m + 8 < avctx->extradata_size; m++) {
913  if (!memcmp(extradata, "SEQH", 4)) {
914  marker_found = 1;
915  break;
916  }
917  extradata++;
918  }
919  }
920 
921  /* if a match was found, parse the extra data */
922  if (marker_found) {
923  GetBitContext gb;
924  int frame_size_code;
925 
926  size = AV_RB32(&extradata[4]);
927  if (size > extradata_end - extradata - 8) {
928  ret = AVERROR_INVALIDDATA;
929  goto fail;
930  }
931  init_get_bits(&gb, extradata + 8, size * 8);
932 
933  /* 'frame size code' and optional 'width, height' */
934  frame_size_code = get_bits(&gb, 3);
935  switch (frame_size_code) {
936  case 0:
937  avctx->width = 160;
938  avctx->height = 120;
939  break;
940  case 1:
941  avctx->width = 128;
942  avctx->height = 96;
943  break;
944  case 2:
945  avctx->width = 176;
946  avctx->height = 144;
947  break;
948  case 3:
949  avctx->width = 352;
950  avctx->height = 288;
951  break;
952  case 4:
953  avctx->width = 704;
954  avctx->height = 576;
955  break;
956  case 5:
957  avctx->width = 240;
958  avctx->height = 180;
959  break;
960  case 6:
961  avctx->width = 320;
962  avctx->height = 240;
963  break;
964  case 7:
965  avctx->width = get_bits(&gb, 12);
966  avctx->height = get_bits(&gb, 12);
967  break;
968  }
969 
970  s->halfpel_flag = get_bits1(&gb);
971  s->thirdpel_flag = get_bits1(&gb);
972 
973  /* unknown fields */
974  skip_bits1(&gb);
975  skip_bits1(&gb);
976  skip_bits1(&gb);
977  skip_bits1(&gb);
978 
979  h->low_delay = get_bits1(&gb);
980 
981  /* unknown field */
982  skip_bits1(&gb);
983 
984  if (skip_1stop_8data_bits(&gb) < 0) {
985  ret = AVERROR_INVALIDDATA;
986  goto fail;
987  }
988 
989  s->unknown_flag = get_bits1(&gb);
990  avctx->has_b_frames = !h->low_delay;
991  if (s->unknown_flag) {
992 #if CONFIG_ZLIB
993  unsigned watermark_width = svq3_get_ue_golomb(&gb);
994  unsigned watermark_height = svq3_get_ue_golomb(&gb);
995  int u1 = svq3_get_ue_golomb(&gb);
996  int u2 = get_bits(&gb, 8);
997  int u3 = get_bits(&gb, 2);
998  int u4 = svq3_get_ue_golomb(&gb);
999  unsigned long buf_len = watermark_width *
1000  watermark_height * 4;
1001  int offset = get_bits_count(&gb) + 7 >> 3;
1002  uint8_t *buf;
1003 
1004  if (watermark_height <= 0 ||
1005  (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
1006  ret = -1;
1007  goto fail;
1008  }
1009 
1010  buf = av_malloc(buf_len);
1011  if (!buf) {
1012  ret = AVERROR(ENOMEM);
1013  goto fail;
1014  }
1015  av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1016  watermark_width, watermark_height);
1017  av_log(avctx, AV_LOG_DEBUG,
1018  "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1019  u1, u2, u3, u4, offset);
1020  if (uncompress(buf, &buf_len, extradata + 8 + offset,
1021  size - offset) != Z_OK) {
1022  av_log(avctx, AV_LOG_ERROR,
1023  "could not uncompress watermark logo\n");
1024  av_free(buf);
1025  ret = -1;
1026  goto fail;
1027  }
1028  s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1029  s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1030  av_log(avctx, AV_LOG_DEBUG,
1031  "watermark key %#"PRIx32"\n", s->watermark_key);
1032  av_free(buf);
1033 #else
1034  av_log(avctx, AV_LOG_ERROR,
1035  "this svq3 file contains watermark which need zlib support compiled in\n");
1036  ret = -1;
1037  goto fail;
1038 #endif
1039  }
1040  }
1041 
1042  h->width = avctx->width;
1043  h->height = avctx->height;
1044  h->mb_width = (h->width + 15) / 16;
1045  h->mb_height = (h->height + 15) / 16;
1046  h->mb_stride = h->mb_width + 1;
1047  h->mb_num = h->mb_width * h->mb_height;
1048  h->b_stride = 4 * h->mb_width;
1049  s->h_edge_pos = h->mb_width * 16;
1050  s->v_edge_pos = h->mb_height * 16;
1051 
1052  if ((ret = ff_h264_alloc_tables(h)) < 0) {
1053  av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1054  goto fail;
1055  }
1056 
1057  return 0;
1058 fail:
1059  svq3_decode_end(avctx);
1060  return ret;
1061 }
1062 
1063 static void free_picture(AVCodecContext *avctx, H264Picture *pic)
1064 {
1065  int i;
1066  for (i = 0; i < 2; i++) {
1067  av_buffer_unref(&pic->motion_val_buf[i]);
1068  av_buffer_unref(&pic->ref_index_buf[i]);
1069  }
1070  av_buffer_unref(&pic->mb_type_buf);
1071 
1072  av_frame_unref(&pic->f);
1073 }
1074 
1075 static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
1076 {
1077  SVQ3Context *s = avctx->priv_data;
1078  H264Context *h = &s->h;
1079  const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
1080  const int mb_array_size = h->mb_stride * h->mb_height;
1081  const int b4_stride = h->mb_width * 4 + 1;
1082  const int b4_array_size = b4_stride * h->mb_height * 4;
1083  int ret;
1084 
1085  if (!pic->motion_val_buf[0]) {
1086  int i;
1087 
1088  pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1089  if (!pic->mb_type_buf)
1090  return AVERROR(ENOMEM);
1091  pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
1092 
1093  for (i = 0; i < 2; i++) {
1094  pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1095  pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1096  if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1097  ret = AVERROR(ENOMEM);
1098  goto fail;
1099  }
1100 
1101  pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1102  pic->ref_index[i] = pic->ref_index_buf[i]->data;
1103  }
1104  }
1105  pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1106 
1107  ret = ff_get_buffer(avctx, &pic->f,
1108  pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1109  if (ret < 0)
1110  goto fail;
1111 
1112  if (!h->edge_emu_buffer) {
1113  h->edge_emu_buffer = av_mallocz_array(pic->f.linesize[0], 17);
1114  if (!h->edge_emu_buffer)
1115  return AVERROR(ENOMEM);
1116  }
1117 
1118  h->linesize = pic->f.linesize[0];
1119  h->uvlinesize = pic->f.linesize[1];
1120 
1121  return 0;
1122 fail:
1123  free_picture(avctx, pic);
1124  return ret;
1125 }
1126 
1127 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1128  int *got_frame, AVPacket *avpkt)
1129 {
1130  SVQ3Context *s = avctx->priv_data;
1131  H264Context *h = &s->h;
1132  int buf_size = avpkt->size;
1133  int left;
1134  uint8_t *buf;
1135  int ret, m, i;
1136 
1137  /* special case for last picture */
1138  if (buf_size == 0) {
1139  if (s->next_pic->f.data[0] && !h->low_delay && !s->last_frame_output) {
1140  ret = av_frame_ref(data, &s->next_pic->f);
1141  if (ret < 0)
1142  return ret;
1143  s->last_frame_output = 1;
1144  *got_frame = 1;
1145  }
1146  return 0;
1147  }
1148 
1149  h->mb_x = h->mb_y = h->mb_xy = 0;
1150 
1151  if (s->watermark_key) {
1152  av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1153  if (!s->buf)
1154  return AVERROR(ENOMEM);
1155  memcpy(s->buf, avpkt->data, buf_size);
1156  buf = s->buf;
1157  } else {
1158  buf = avpkt->data;
1159  }
1160 
1161  init_get_bits(&h->gb, buf, 8 * buf_size);
1162 
1163  if (svq3_decode_slice_header(avctx))
1164  return -1;
1165 
1166  h->pict_type = h->slice_type;
1167 
1168  if (h->pict_type != AV_PICTURE_TYPE_B)
1169  FFSWAP(H264Picture*, s->next_pic, s->last_pic);
1170 
1171  av_frame_unref(&s->cur_pic->f);
1172 
1173  /* for skipping the frame */
1174  s->cur_pic->f.pict_type = h->pict_type;
1175  s->cur_pic->f.key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
1176 
1177  ret = get_buffer(avctx, s->cur_pic);
1178  if (ret < 0)
1179  return ret;
1180 
1181  h->cur_pic_ptr = s->cur_pic;
1182  av_frame_unref(&h->cur_pic.f);
1183  memcpy(&h->cur_pic.tf, &s->cur_pic->tf, sizeof(h->cur_pic) - offsetof(H264Picture, tf));
1184  ret = av_frame_ref(&h->cur_pic.f, &s->cur_pic->f);
1185  if (ret < 0)
1186  return ret;
1187 
1188  for (i = 0; i < 16; i++) {
1189  h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1190  h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1191  }
1192  for (i = 0; i < 16; i++) {
1193  h->block_offset[16 + i] =
1194  h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1195  h->block_offset[48 + 16 + i] =
1196  h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1197  }
1198 
1199  if (h->pict_type != AV_PICTURE_TYPE_I) {
1200  if (!s->last_pic->f.data[0]) {
1201  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1202  av_frame_unref(&s->last_pic->f);
1203  ret = get_buffer(avctx, s->last_pic);
1204  if (ret < 0)
1205  return ret;
1206  memset(s->last_pic->f.data[0], 0, avctx->height * s->last_pic->f.linesize[0]);
1207  memset(s->last_pic->f.data[1], 0x80, (avctx->height / 2) *
1208  s->last_pic->f.linesize[1]);
1209  memset(s->last_pic->f.data[2], 0x80, (avctx->height / 2) *
1210  s->last_pic->f.linesize[2]);
1211  }
1212 
1213  if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f.data[0]) {
1214  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1215  av_frame_unref(&s->next_pic->f);
1216  ret = get_buffer(avctx, s->next_pic);
1217  if (ret < 0)
1218  return ret;
1219  memset(s->next_pic->f.data[0], 0, avctx->height * s->next_pic->f.linesize[0]);
1220  memset(s->next_pic->f.data[1], 0x80, (avctx->height / 2) *
1221  s->next_pic->f.linesize[1]);
1222  memset(s->next_pic->f.data[2], 0x80, (avctx->height / 2) *
1223  s->next_pic->f.linesize[2]);
1224  }
1225  }
1226 
1227  if (avctx->debug & FF_DEBUG_PICT_INFO)
1228  av_log(h->avctx, AV_LOG_DEBUG,
1229  "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1230  av_get_picture_type_char(h->pict_type),
1231  s->halfpel_flag, s->thirdpel_flag,
1232  s->adaptive_quant, h->qscale, h->slice_num);
1233 
1234  if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1235  avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
1236  avctx->skip_frame >= AVDISCARD_ALL)
1237  return 0;
1238 
1239  if (s->next_p_frame_damaged) {
1240  if (h->pict_type == AV_PICTURE_TYPE_B)
1241  return 0;
1242  else
1243  s->next_p_frame_damaged = 0;
1244  }
1245 
1246  if (h->pict_type == AV_PICTURE_TYPE_B) {
1247  h->frame_num_offset = h->slice_num - h->prev_frame_num;
1248 
1249  if (h->frame_num_offset < 0)
1250  h->frame_num_offset += 256;
1251  if (h->frame_num_offset == 0 ||
1252  h->frame_num_offset >= h->prev_frame_num_offset) {
1253  av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1254  return -1;
1255  }
1256  } else {
1257  h->prev_frame_num = h->frame_num;
1258  h->frame_num = h->slice_num;
1259  h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1260 
1261  if (h->prev_frame_num_offset < 0)
1262  h->prev_frame_num_offset += 256;
1263  }
1264 
1265  for (m = 0; m < 2; m++) {
1266  int i;
1267  for (i = 0; i < 4; i++) {
1268  int j;
1269  for (j = -1; j < 4; j++)
1270  h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1271  if (i < 3)
1272  h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1273  }
1274  }
1275 
1276  for (h->mb_y = 0; h->mb_y < h->mb_height; h->mb_y++) {
1277  for (h->mb_x = 0; h->mb_x < h->mb_width; h->mb_x++) {
1278  unsigned mb_type;
1279  h->mb_xy = h->mb_x + h->mb_y * h->mb_stride;
1280 
1281  if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1282  ((get_bits_count(&h->gb) & 7) == 0 ||
1283  show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1284  skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1285  h->gb.size_in_bits = 8 * buf_size;
1286 
1287  if (svq3_decode_slice_header(avctx))
1288  return -1;
1289 
1290  /* TODO: support s->mb_skip_run */
1291  }
1292 
1293  mb_type = svq3_get_ue_golomb(&h->gb);
1294 
1295  if (h->pict_type == AV_PICTURE_TYPE_I)
1296  mb_type += 8;
1297  else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1298  mb_type += 4;
1299  if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1300  av_log(h->avctx, AV_LOG_ERROR,
1301  "error while decoding MB %d %d\n", h->mb_x, h->mb_y);
1302  return -1;
1303  }
1304 
1305  if (mb_type != 0 || h->cbp)
1306  ff_h264_hl_decode_mb(h);
1307 
1308  if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1309  h->cur_pic.mb_type[h->mb_x + h->mb_y * h->mb_stride] =
1310  (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1311  }
1312 
1313  ff_draw_horiz_band(avctx, &s->cur_pic->f,
1314  s->last_pic->f.data[0] ? &s->last_pic->f : NULL,
1315  16 * h->mb_y, 16, h->picture_structure, 0,
1316  h->low_delay);
1317  }
1318 
1319  left = buf_size*8 - get_bits_count(&h->gb);
1320 
1321  if (h->mb_y != h->mb_height || h->mb_x != h->mb_width) {
1322  av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, h->mb_y, h->mb_x, left);
1323  //av_hex_dump(stderr, buf+buf_size-8, 8);
1324  }
1325 
1326  if (left < 0) {
1327  av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1328  return -1;
1329  }
1330 
1331  if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1332  ret = av_frame_ref(data, &s->cur_pic->f);
1333  else if (s->last_pic->f.data[0])
1334  ret = av_frame_ref(data, &s->last_pic->f);
1335  if (ret < 0)
1336  return ret;
1337 
1338  /* Do not output the last pic after seeking. */
1339  if (s->last_pic->f.data[0] || h->low_delay)
1340  *got_frame = 1;
1341 
1342  if (h->pict_type != AV_PICTURE_TYPE_B) {
1343  FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
1344  } else {
1345  av_frame_unref(&s->cur_pic->f);
1346  }
1347 
1348  return buf_size;
1349 }
1350 
1351 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1352 {
1353  SVQ3Context *s = avctx->priv_data;
1354  H264Context *h = &s->h;
1355 
1356  free_picture(avctx, s->cur_pic);
1357  free_picture(avctx, s->next_pic);
1358  free_picture(avctx, s->last_pic);
1359  av_freep(&s->cur_pic);
1360  av_freep(&s->next_pic);
1361  av_freep(&s->last_pic);
1362 
1363  av_frame_unref(&h->cur_pic.f);
1364 
1365  ff_h264_free_context(h);
1366 
1367  av_freep(&s->buf);
1368  s->buf_size = 0;
1369  av_freep(&h->edge_emu_buffer);
1370 
1371  return 0;
1372 }
1373 
1374 AVCodec ff_svq3_decoder = {
1375  .name = "svq3",
1376  .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1377  .type = AVMEDIA_TYPE_VIDEO,
1378  .id = AV_CODEC_ID_SVQ3,
1379  .priv_data_size = sizeof(SVQ3Context),
1380  .init = svq3_decode_init,
1381  .close = svq3_decode_end,
1382  .decode = svq3_decode_frame,
1383  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND |
1384  CODEC_CAP_DR1 |
1385  CODEC_CAP_DELAY,
1386  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1387  AV_PIX_FMT_NONE},
1388 };
Generated on Sun Mar 8 2015 02:35:00 for FFmpeg by   doxygen 1.8.2