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