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