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