svq3.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2003 The Libav Project
3  *
4  * This file is part of Libav.
5  *
6  * Libav 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  * Libav 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 Libav; 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.libav.org/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41  */
42 #include "internal.h"
43 #include "dsputil.h"
44 #include "avcodec.h"
45 #include "mpegvideo.h"
46 #include "h264.h"
47 
48 #include "h264data.h" //FIXME FIXME FIXME
49 
50 #include "h264_mvpred.h"
51 #include "golomb.h"
52 #include "rectangle.h"
53 #include "vdpau_internal.h"
54 
55 #if CONFIG_ZLIB
56 #include <zlib.h>
57 #endif
58 
59 #include "svq1.h"
60 
66 typedef struct {
72  uint32_t watermark_key;
73 } SVQ3Context;
74 
75 #define FULLPEL_MODE 1
76 #define HALFPEL_MODE 2
77 #define THIRDPEL_MODE 3
78 #define PREDICT_MODE 4
79 
80 /* dual scan (from some older h264 draft)
81  o-->o-->o o
82  | /|
83  o o o / o
84  | / | |/ |
85  o o o o
86  /
87  o-->o-->o-->o
88 */
89 static const uint8_t svq3_scan[16] = {
90  0+0*4, 1+0*4, 2+0*4, 2+1*4,
91  2+2*4, 3+0*4, 3+1*4, 3+2*4,
92  0+1*4, 0+2*4, 1+1*4, 1+2*4,
93  0+3*4, 1+3*4, 2+3*4, 3+3*4,
94 };
95 
96 static const uint8_t svq3_pred_0[25][2] = {
97  { 0, 0 },
98  { 1, 0 }, { 0, 1 },
99  { 0, 2 }, { 1, 1 }, { 2, 0 },
100  { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
101  { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
102  { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
103  { 2, 4 }, { 3, 3 }, { 4, 2 },
104  { 4, 3 }, { 3, 4 },
105  { 4, 4 }
106 };
107 
108 static const int8_t svq3_pred_1[6][6][5] = {
109  { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
110  { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
111  { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
112  { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
113  { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
114  { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
115  { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
116  { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
117  { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
118  { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
119  { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
120  { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
121 };
122 
123 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
124  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
125  { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
126  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
127  { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
128 };
129 
130 static const uint32_t svq3_dequant_coeff[32] = {
131  3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
132  9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
133  24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
134  61694, 68745, 77615, 89113,100253,109366,126635,141533
135 };
136 
137 void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp){
138  const int qmul = svq3_dequant_coeff[qp];
139 #define stride 16
140  int i;
141  int temp[16];
142  static const uint8_t x_offset[4]={0, 1*stride, 4*stride, 5*stride};
143 
144  for(i=0; i<4; i++){
145  const int z0 = 13*(input[4*i+0] + input[4*i+2]);
146  const int z1 = 13*(input[4*i+0] - input[4*i+2]);
147  const int z2 = 7* input[4*i+1] - 17*input[4*i+3];
148  const int z3 = 17* input[4*i+1] + 7*input[4*i+3];
149 
150  temp[4*i+0] = z0+z3;
151  temp[4*i+1] = z1+z2;
152  temp[4*i+2] = z1-z2;
153  temp[4*i+3] = z0-z3;
154  }
155 
156  for(i=0; i<4; i++){
157  const int offset= x_offset[i];
158  const int z0= 13*(temp[4*0+i] + temp[4*2+i]);
159  const int z1= 13*(temp[4*0+i] - temp[4*2+i]);
160  const int z2= 7* temp[4*1+i] - 17*temp[4*3+i];
161  const int z3= 17* temp[4*1+i] + 7*temp[4*3+i];
162 
163  output[stride* 0+offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
164  output[stride* 2+offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
165  output[stride* 8+offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
166  output[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
167  }
168 }
169 #undef stride
170 
171 void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
172  int dc)
173 {
174  const int qmul = svq3_dequant_coeff[qp];
175  int i;
176 
177  if (dc) {
178  dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
179  block[0] = 0;
180  }
181 
182  for (i = 0; i < 4; i++) {
183  const int z0 = 13*(block[0 + 4*i] + block[2 + 4*i]);
184  const int z1 = 13*(block[0 + 4*i] - block[2 + 4*i]);
185  const int z2 = 7* block[1 + 4*i] - 17*block[3 + 4*i];
186  const int z3 = 17* block[1 + 4*i] + 7*block[3 + 4*i];
187 
188  block[0 + 4*i] = z0 + z3;
189  block[1 + 4*i] = z1 + z2;
190  block[2 + 4*i] = z1 - z2;
191  block[3 + 4*i] = z0 - z3;
192  }
193 
194  for (i = 0; i < 4; i++) {
195  const int z0 = 13*(block[i + 4*0] + block[i + 4*2]);
196  const int z1 = 13*(block[i + 4*0] - block[i + 4*2]);
197  const int z2 = 7* block[i + 4*1] - 17*block[i + 4*3];
198  const int z3 = 17* block[i + 4*1] + 7*block[i + 4*3];
199  const int rr = (dc + 0x80000);
200 
201  dst[i + stride*0] = av_clip_uint8( dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) );
202  dst[i + stride*1] = av_clip_uint8( dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) );
203  dst[i + stride*2] = av_clip_uint8( dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) );
204  dst[i + stride*3] = av_clip_uint8( dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) );
205  }
206 }
207 
209  int index, const int type)
210 {
211  static const uint8_t *const scan_patterns[4] =
213 
214  int run, level, sign, vlc, limit;
215  const int intra = (3 * type) >> 2;
216  const uint8_t *const scan = scan_patterns[type];
217 
218  for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
219  for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
220 
221  if (vlc == INVALID_VLC)
222  return -1;
223 
224  sign = (vlc & 0x1) - 1;
225  vlc = (vlc + 1) >> 1;
226 
227  if (type == 3) {
228  if (vlc < 3) {
229  run = 0;
230  level = vlc;
231  } else if (vlc < 4) {
232  run = 1;
233  level = 1;
234  } else {
235  run = (vlc & 0x3);
236  level = ((vlc + 9) >> 2) - run;
237  }
238  } else {
239  if (vlc < 16) {
240  run = svq3_dct_tables[intra][vlc].run;
241  level = svq3_dct_tables[intra][vlc].level;
242  } else if (intra) {
243  run = (vlc & 0x7);
244  level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
245  } else {
246  run = (vlc & 0xF);
247  level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
248  }
249  }
250 
251  if ((index += run) >= limit)
252  return -1;
253 
254  block[scan[index]] = (level ^ sign) - sign;
255  }
256 
257  if (type != 2) {
258  break;
259  }
260  }
261 
262  return 0;
263 }
264 
265 static inline void svq3_mc_dir_part(MpegEncContext *s,
266  int x, int y, int width, int height,
267  int mx, int my, int dxy,
268  int thirdpel, int dir, int avg)
269 {
270  const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
271  uint8_t *src, *dest;
272  int i, emu = 0;
273  int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
274 
275  mx += x;
276  my += y;
277 
278  if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
279  my < 0 || my >= (s->v_edge_pos - height - 1)) {
280 
281  if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
282  emu = 1;
283  }
284 
285  mx = av_clip (mx, -16, (s->h_edge_pos - width + 15));
286  my = av_clip (my, -16, (s->v_edge_pos - height + 15));
287  }
288 
289  /* form component predictions */
290  dest = s->current_picture.f.data[0] + x + y*s->linesize;
291  src = pic->f.data[0] + mx + my*s->linesize;
292 
293  if (emu) {
294  s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
295  mx, my, s->h_edge_pos, s->v_edge_pos);
296  src = s->edge_emu_buffer;
297  }
298  if (thirdpel)
299  (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
300  else
301  (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
302 
303  if (!(s->flags & CODEC_FLAG_GRAY)) {
304  mx = (mx + (mx < (int) x)) >> 1;
305  my = (my + (my < (int) y)) >> 1;
306  width = (width >> 1);
307  height = (height >> 1);
308  blocksize++;
309 
310  for (i = 1; i < 3; i++) {
311  dest = s->current_picture.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
312  src = pic->f.data[i] + mx + my * s->uvlinesize;
313 
314  if (emu) {
315  s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
316  mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
317  src = s->edge_emu_buffer;
318  }
319  if (thirdpel)
320  (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
321  else
322  (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
323  }
324  }
325 }
326 
327 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
328  int avg)
329 {
330  int i, j, k, mx, my, dx, dy, x, y;
331  MpegEncContext *const s = (MpegEncContext *) h;
332  const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
333  const int part_height = 16 >> ((unsigned) (size + 1) / 3);
334  const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
335  const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width;
336  const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width;
337 
338  for (i = 0; i < 16; i += part_height) {
339  for (j = 0; j < 16; j += part_width) {
340  const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
341  int dxy;
342  x = 16*s->mb_x + j;
343  y = 16*s->mb_y + i;
344  k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
345 
346  if (mode != PREDICT_MODE) {
347  pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
348  } else {
349  mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
350  my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
351 
352  if (dir == 0) {
353  mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
354  my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
355  } else {
356  mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
357  my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
358  }
359  }
360 
361  /* clip motion vector prediction to frame border */
362  mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
363  my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
364 
365  /* get (optional) motion vector differential */
366  if (mode == PREDICT_MODE) {
367  dx = dy = 0;
368  } else {
369  dy = svq3_get_se_golomb(&s->gb);
370  dx = svq3_get_se_golomb(&s->gb);
371 
372  if (dx == INVALID_VLC || dy == INVALID_VLC) {
373  av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
374  return -1;
375  }
376  }
377 
378  /* compute motion vector */
379  if (mode == THIRDPEL_MODE) {
380  int fx, fy;
381  mx = ((mx + 1)>>1) + dx;
382  my = ((my + 1)>>1) + dy;
383  fx = ((unsigned)(mx + 0x3000))/3 - 0x1000;
384  fy = ((unsigned)(my + 0x3000))/3 - 0x1000;
385  dxy = (mx - 3*fx) + 4*(my - 3*fy);
386 
387  svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
388  mx += mx;
389  my += my;
390  } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
391  mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
392  my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
393  dxy = (mx&1) + 2*(my&1);
394 
395  svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
396  mx *= 3;
397  my *= 3;
398  } else {
399  mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
400  my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
401 
402  svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
403  mx *= 6;
404  my *= 6;
405  }
406 
407  /* update mv_cache */
408  if (mode != PREDICT_MODE) {
409  int32_t mv = pack16to32(mx,my);
410 
411  if (part_height == 8 && i < 8) {
412  AV_WN32A(h->mv_cache[dir][scan8[k] + 1*8], mv);
413 
414  if (part_width == 8 && j < 8) {
415  AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1*8], mv);
416  }
417  }
418  if (part_width == 8 && j < 8) {
419  AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
420  }
421  if (part_width == 4 || part_height == 4) {
422  AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
423  }
424  }
425 
426  /* write back motion vectors */
428  part_width >> 2, part_height >> 2, h->b_stride,
429  pack16to32(mx, my), 4);
430  }
431  }
432 
433  return 0;
434 }
435 
436 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
437 {
438  H264Context *h = &svq3->h;
439  int i, j, k, m, dir, mode;
440  int cbp = 0;
441  uint32_t vlc;
442  int8_t *top, *left;
443  MpegEncContext *const s = (MpegEncContext *) h;
444  const int mb_xy = h->mb_xy;
445  const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
446 
447  h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
448  h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
449  h->topright_samples_available = 0xFFFF;
450 
451  if (mb_type == 0) { /* SKIP */
452  if (s->pict_type == AV_PICTURE_TYPE_P || s->next_picture.f.mb_type[mb_xy] == -1) {
453  svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
454 
455  if (s->pict_type == AV_PICTURE_TYPE_B) {
456  svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
457  }
458 
459  mb_type = MB_TYPE_SKIP;
460  } else {
461  mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
462  if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
463  return -1;
464  if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
465  return -1;
466 
467  mb_type = MB_TYPE_16x16;
468  }
469  } else if (mb_type < 8) { /* INTER */
470  if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1 (&s->gb)) {
471  mode = THIRDPEL_MODE;
472  } else if (svq3->halfpel_flag && svq3->thirdpel_flag == !get_bits1 (&s->gb)) {
473  mode = HALFPEL_MODE;
474  } else {
475  mode = FULLPEL_MODE;
476  }
477 
478  /* fill caches */
479  /* note ref_cache should contain here:
480  ????????
481  ???11111
482  N??11111
483  N??11111
484  N??11111
485  */
486 
487  for (m = 0; m < 2; m++) {
488  if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
489  for (i = 0; i < 4; i++) {
490  AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i*8], s->current_picture.f.motion_val[m][b_xy - 1 + i*h->b_stride]);
491  }
492  } else {
493  for (i = 0; i < 4; i++) {
494  AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i*8]);
495  }
496  }
497  if (s->mb_y > 0) {
498  memcpy(h->mv_cache[m][scan8[0] - 1*8], s->current_picture.f.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
499  memset(&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
500 
501  if (s->mb_x < (s->mb_width - 1)) {
502  AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1*8], s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4]);
503  h->ref_cache[m][scan8[0] + 4 - 1*8] =
504  (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
505  h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride ] ] == -1) ? PART_NOT_AVAILABLE : 1;
506  }else
507  h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
508  if (s->mb_x > 0) {
509  AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1*8], s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1]);
510  h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] == -1) ? PART_NOT_AVAILABLE : 1;
511  }else
512  h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
513  }else
514  memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
515 
516  if (s->pict_type != AV_PICTURE_TYPE_B)
517  break;
518  }
519 
520  /* decode motion vector(s) and form prediction(s) */
521  if (s->pict_type == AV_PICTURE_TYPE_P) {
522  if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
523  return -1;
524  } else { /* AV_PICTURE_TYPE_B */
525  if (mb_type != 2) {
526  if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
527  return -1;
528  } else {
529  for (i = 0; i < 4; i++) {
530  memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
531  }
532  }
533  if (mb_type != 1) {
534  if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
535  return -1;
536  } else {
537  for (i = 0; i < 4; i++) {
538  memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
539  }
540  }
541  }
542 
543  mb_type = MB_TYPE_16x16;
544  } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
545  memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
546 
547  if (mb_type == 8) {
548  if (s->mb_x > 0) {
549  for (i = 0; i < 4; i++) {
550  h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
551  }
552  if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
553  h->left_samples_available = 0x5F5F;
554  }
555  }
556  if (s->mb_y > 0) {
557  h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
558  h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
559  h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
560  h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
561 
562  if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
563  h->top_samples_available = 0x33FF;
564  }
565  }
566 
567  /* decode prediction codes for luma blocks */
568  for (i = 0; i < 16; i+=2) {
569  vlc = svq3_get_ue_golomb(&s->gb);
570 
571  if (vlc >= 25){
572  av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
573  return -1;
574  }
575 
576  left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
577  top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
578 
579  left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
580  left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
581 
582  if (left[1] == -1 || left[2] == -1){
583  av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
584  return -1;
585  }
586  }
587  } else { /* mb_type == 33, DC_128_PRED block type */
588  for (i = 0; i < 4; i++) {
589  memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
590  }
591  }
592 
594 
595  if (mb_type == 8) {
597 
598  h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
599  h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
600  } else {
601  for (i = 0; i < 4; i++) {
602  memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
603  }
604 
605  h->top_samples_available = 0x33FF;
606  h->left_samples_available = 0x5F5F;
607  }
608 
609  mb_type = MB_TYPE_INTRA4x4;
610  } else { /* INTRA16x16 */
611  dir = i_mb_type_info[mb_type - 8].pred_mode;
612  dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
613 
614  if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) < 0) {
615  av_log(h->s.avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
616  return h->intra16x16_pred_mode;
617  }
618 
619  cbp = i_mb_type_info[mb_type - 8].cbp;
620  mb_type = MB_TYPE_INTRA16x16;
621  }
622 
623  if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
624  for (i = 0; i < 4; i++) {
625  memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
626  }
627  if (s->pict_type == AV_PICTURE_TYPE_B) {
628  for (i = 0; i < 4; i++) {
629  memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
630  }
631  }
632  }
633  if (!IS_INTRA4x4(mb_type)) {
634  memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
635  }
636  if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
637  memset(h->non_zero_count_cache + 8, 0, 14*8*sizeof(uint8_t));
638  s->dsp.clear_blocks(h->mb+ 0);
639  s->dsp.clear_blocks(h->mb+384);
640  }
641 
642  if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
643  if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
644  av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
645  return -1;
646  }
647 
648  cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
649  }
650  if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
651  s->qscale += svq3_get_se_golomb(&s->gb);
652 
653  if (s->qscale > 31u){
654  av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
655  return -1;
656  }
657  }
658  if (IS_INTRA16x16(mb_type)) {
659  AV_ZERO128(h->mb_luma_dc[0]+0);
660  AV_ZERO128(h->mb_luma_dc[0]+8);
661  if (svq3_decode_block(&s->gb, h->mb_luma_dc, 0, 1)){
662  av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
663  return -1;
664  }
665  }
666 
667  if (cbp) {
668  const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
669  const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
670 
671  for (i = 0; i < 4; i++) {
672  if ((cbp & (1 << i))) {
673  for (j = 0; j < 4; j++) {
674  k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
675  h->non_zero_count_cache[ scan8[k] ] = 1;
676 
677  if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
678  av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
679  return -1;
680  }
681  }
682  }
683  }
684 
685  if ((cbp & 0x30)) {
686  for (i = 1; i < 3; ++i) {
687  if (svq3_decode_block(&s->gb, &h->mb[16*16*i], 0, 3)){
688  av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
689  return -1;
690  }
691  }
692 
693  if ((cbp & 0x20)) {
694  for (i = 1; i < 3; i++) {
695  for (j = 0; j < 4; j++) {
696  k = 16*i + j;
697  h->non_zero_count_cache[ scan8[k] ] = 1;
698 
699  if (svq3_decode_block(&s->gb, &h->mb[16*k], 1, 1)){
700  av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
701  return -1;
702  }
703  }
704  }
705  }
706  }
707  }
708 
709  h->cbp= cbp;
710  s->current_picture.f.mb_type[mb_xy] = mb_type;
711 
712  if (IS_INTRA(mb_type)) {
714  }
715 
716  return 0;
717 }
718 
720 {
721  SVQ3Context *svq3 = avctx->priv_data;
722  H264Context *h = &svq3->h;
723  MpegEncContext *s = &h->s;
724  const int mb_xy = h->mb_xy;
725  int i, header;
726 
727  header = get_bits(&s->gb, 8);
728 
729  if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
730  /* TODO: what? */
731  av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
732  return -1;
733  } else {
734  int length = (header >> 5) & 3;
735 
736  svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
737 
738  if (svq3->next_slice_index > s->gb.size_in_bits) {
739  av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
740  return -1;
741  }
742 
743  s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1);
744  skip_bits(&s->gb, 8);
745 
746  if (svq3->watermark_key) {
747  uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
748  AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key);
749  }
750  if (length > 0) {
751  memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
752  &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
753  }
754  skip_bits_long(&s->gb, 0);
755  }
756 
757  if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
758  av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
759  return -1;
760  }
761 
763 
764  if ((header & 0x9F) == 2) {
765  i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
766  s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
767  } else {
768  skip_bits1(&s->gb);
769  s->mb_skip_run = 0;
770  }
771 
772  h->slice_num = get_bits(&s->gb, 8);
773  s->qscale = get_bits(&s->gb, 5);
774  s->adaptive_quant = get_bits1(&s->gb);
775 
776  /* unknown fields */
777  skip_bits1(&s->gb);
778 
779  if (svq3->unknown_flag) {
780  skip_bits1(&s->gb);
781  }
782 
783  skip_bits1(&s->gb);
784  skip_bits(&s->gb, 2);
785 
786  while (get_bits1(&s->gb)) {
787  skip_bits(&s->gb, 8);
788  }
789 
790  /* reset intra predictors and invalidate motion vector references */
791  if (s->mb_x > 0) {
792  memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1 ]+3, -1, 4*sizeof(int8_t));
793  memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x] , -1, 8*sizeof(int8_t)*s->mb_x);
794  }
795  if (s->mb_y > 0) {
796  memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
797 
798  if (s->mb_x > 0) {
799  h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
800  }
801  }
802 
803  return 0;
804 }
805 
807 {
808  SVQ3Context *svq3 = avctx->priv_data;
809  H264Context *h = &svq3->h;
810  MpegEncContext *s = &h->s;
811  int m;
812  unsigned char *extradata;
813  unsigned char *extradata_end;
814  unsigned int size;
815  int marker_found = 0;
816 
817  if (ff_h264_decode_init(avctx) < 0)
818  return -1;
819 
820  s->flags = avctx->flags;
821  s->flags2 = avctx->flags2;
822  s->unrestricted_mv = 1;
823  h->is_complex=1;
824  avctx->pix_fmt = avctx->codec->pix_fmts[0];
825 
826  if (!s->context_initialized) {
827  h->chroma_qp[0] = h->chroma_qp[1] = 4;
828 
829  svq3->halfpel_flag = 1;
830  svq3->thirdpel_flag = 1;
831  svq3->unknown_flag = 0;
832 
833  /* prowl for the "SEQH" marker in the extradata */
834  extradata = (unsigned char *)avctx->extradata;
835  extradata_end = avctx->extradata + avctx->extradata_size;
836  if (extradata) {
837  for (m = 0; m + 8 < avctx->extradata_size; m++) {
838  if (!memcmp(extradata, "SEQH", 4)) {
839  marker_found = 1;
840  break;
841  }
842  extradata++;
843  }
844  }
845 
846  /* if a match was found, parse the extra data */
847  if (marker_found) {
848 
849  GetBitContext gb;
850  int frame_size_code;
851 
852  size = AV_RB32(&extradata[4]);
853  if (size > extradata_end - extradata - 8)
854  return AVERROR_INVALIDDATA;
855  init_get_bits(&gb, extradata + 8, size*8);
856 
857  /* 'frame size code' and optional 'width, height' */
858  frame_size_code = get_bits(&gb, 3);
859  switch (frame_size_code) {
860  case 0: avctx->width = 160; avctx->height = 120; break;
861  case 1: avctx->width = 128; avctx->height = 96; break;
862  case 2: avctx->width = 176; avctx->height = 144; break;
863  case 3: avctx->width = 352; avctx->height = 288; break;
864  case 4: avctx->width = 704; avctx->height = 576; break;
865  case 5: avctx->width = 240; avctx->height = 180; break;
866  case 6: avctx->width = 320; avctx->height = 240; break;
867  case 7:
868  avctx->width = get_bits(&gb, 12);
869  avctx->height = get_bits(&gb, 12);
870  break;
871  }
872 
873  svq3->halfpel_flag = get_bits1(&gb);
874  svq3->thirdpel_flag = get_bits1(&gb);
875 
876  /* unknown fields */
877  skip_bits1(&gb);
878  skip_bits1(&gb);
879  skip_bits1(&gb);
880  skip_bits1(&gb);
881 
882  s->low_delay = get_bits1(&gb);
883 
884  /* unknown field */
885  skip_bits1(&gb);
886 
887  while (get_bits1(&gb)) {
888  skip_bits(&gb, 8);
889  }
890 
891  svq3->unknown_flag = get_bits1(&gb);
892  avctx->has_b_frames = !s->low_delay;
893  if (svq3->unknown_flag) {
894 #if CONFIG_ZLIB
895  unsigned watermark_width = svq3_get_ue_golomb(&gb);
896  unsigned watermark_height = svq3_get_ue_golomb(&gb);
897  int u1 = svq3_get_ue_golomb(&gb);
898  int u2 = get_bits(&gb, 8);
899  int u3 = get_bits(&gb, 2);
900  int u4 = svq3_get_ue_golomb(&gb);
901  unsigned long buf_len = watermark_width*watermark_height*4;
902  int offset = (get_bits_count(&gb)+7)>>3;
903  uint8_t *buf;
904 
905  if (watermark_height > 0 &&
906  (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
907  return -1;
908 
909  buf = av_malloc(buf_len);
910  av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
911  av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
912  if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
913  av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
914  av_free(buf);
915  return -1;
916  }
917  svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
918  svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
919  av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
920  av_free(buf);
921 #else
922  av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
923  return -1;
924 #endif
925  }
926  }
927 
928  s->width = avctx->width;
929  s->height = avctx->height;
930 
931  if (MPV_common_init(s) < 0)
932  return -1;
933 
934  h->b_stride = 4*s->mb_width;
935 
936  if (ff_h264_alloc_tables(h) < 0) {
937  av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
938  return AVERROR(ENOMEM);
939  }
940  }
941 
942  return 0;
943 }
944 
946  void *data, int *data_size,
947  AVPacket *avpkt)
948 {
949  const uint8_t *buf = avpkt->data;
950  SVQ3Context *svq3 = avctx->priv_data;
951  H264Context *h = &svq3->h;
952  MpegEncContext *s = &h->s;
953  int buf_size = avpkt->size;
954  int m, mb_type;
955 
956  /* special case for last picture */
957  if (buf_size == 0) {
958  if (s->next_picture_ptr && !s->low_delay) {
959  *(AVFrame *) data = *(AVFrame *) &s->next_picture;
960  s->next_picture_ptr = NULL;
961  *data_size = sizeof(AVFrame);
962  }
963  return 0;
964  }
965 
966  init_get_bits (&s->gb, buf, 8*buf_size);
967 
968  s->mb_x = s->mb_y = h->mb_xy = 0;
969 
970  if (svq3_decode_slice_header(avctx))
971  return -1;
972 
973  s->pict_type = h->slice_type;
974  s->picture_number = h->slice_num;
975 
976  if (avctx->debug&FF_DEBUG_PICT_INFO){
977  av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
979  s->adaptive_quant, s->qscale, h->slice_num);
980  }
981 
982  /* for skipping the frame */
985 
986  /* Skip B-frames if we do not have reference frames. */
988  return 0;
989  if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
991  || avctx->skip_frame >= AVDISCARD_ALL)
992  return 0;
993 
994  if (s->next_p_frame_damaged) {
995  if (s->pict_type == AV_PICTURE_TYPE_B)
996  return 0;
997  else
998  s->next_p_frame_damaged = 0;
999  }
1000 
1001  if (ff_h264_frame_start(h) < 0)
1002  return -1;
1003 
1004  if (s->pict_type == AV_PICTURE_TYPE_B) {
1005  h->frame_num_offset = (h->slice_num - h->prev_frame_num);
1006 
1007  if (h->frame_num_offset < 0) {
1008  h->frame_num_offset += 256;
1009  }
1010  if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
1011  av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1012  return -1;
1013  }
1014  } else {
1015  h->prev_frame_num = h->frame_num;
1016  h->frame_num = h->slice_num;
1018 
1019  if (h->prev_frame_num_offset < 0) {
1020  h->prev_frame_num_offset += 256;
1021  }
1022  }
1023 
1024  for (m = 0; m < 2; m++){
1025  int i;
1026  for (i = 0; i < 4; i++){
1027  int j;
1028  for (j = -1; j < 4; j++)
1029  h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1030  if (i < 3)
1031  h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1032  }
1033  }
1034 
1035  for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1036  for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1037  h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1038 
1039  if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1040  ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1041 
1042  skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1043  s->gb.size_in_bits = 8*buf_size;
1044 
1045  if (svq3_decode_slice_header(avctx))
1046  return -1;
1047 
1048  /* TODO: support s->mb_skip_run */
1049  }
1050 
1051  mb_type = svq3_get_ue_golomb(&s->gb);
1052 
1053  if (s->pict_type == AV_PICTURE_TYPE_I) {
1054  mb_type += 8;
1055  } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
1056  mb_type += 4;
1057  }
1058  if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1059  av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1060  return -1;
1061  }
1062 
1063  if (mb_type != 0) {
1065  }
1066 
1067  if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
1068  s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1069  (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1070  }
1071  }
1072 
1073  ff_draw_horiz_band(s, 16*s->mb_y, 16);
1074  }
1075 
1076  MPV_frame_end(s);
1077 
1078  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1079  *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1080  } else {
1081  *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1082  }
1083 
1084  /* Do not output the last pic after seeking. */
1085  if (s->last_picture_ptr || s->low_delay) {
1086  *data_size = sizeof(AVFrame);
1087  }
1088 
1089  return buf_size;
1090 }
1091 
1093 {
1094  SVQ3Context *svq3 = avctx->priv_data;
1095  H264Context *h = &svq3->h;
1096  MpegEncContext *s = &h->s;
1097 
1099 
1100  MPV_common_end(s);
1101 
1102  return 0;
1103 }
1104 
1106  .name = "svq3",
1107  .type = AVMEDIA_TYPE_VIDEO,
1108  .id = CODEC_ID_SVQ3,
1109  .priv_data_size = sizeof(SVQ3Context),
1114  .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1115  .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1116 };