be smarter about the variable size of the extra SVQ3 data
[libav.git] / libavcodec / svq3.c
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
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
27 * via the AVCodecContext's extradata[_size] field:
28 *
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
38 *
39 */
40
41 /**
42 * @file svq3.c
43 * svq3 decoder.
44 */
45
46 #define FULLPEL_MODE 1
47 #define HALFPEL_MODE 2
48 #define THIRDPEL_MODE 3
49 #define PREDICT_MODE 4
50
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 */
60 static 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
67 static 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
79 static 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
94 static 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
101 static 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
109 static 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
145 static 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
181 static 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;
203 }
204
205 static void pred16x16_plane_svq3_c(uint8_t *src, int stride){
206 pred16x16_plane_compat_c(src, stride, 1);
207 }
208
209 static 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
266 static 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;
272 uint8_t *src, *dest;
273 int i, emu = 0;
274 int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
275
276 mx += x;
277 my += y;
278
279 if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
280 my < 0 || my >= (s->v_edge_pos - height - 1)) {
281
282 if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
283 emu = 1;
284 }
285
286 mx = clip (mx, -16, (s->h_edge_pos - width + 15));
287 my = clip (my, -16, (s->v_edge_pos - height + 15));
288 }
289
290 /* form component predictions */
291 dest = s->current_picture.data[0] + x + y*s->linesize;
292 src = pic->data[0] + mx + my*s->linesize;
293
294 if (emu) {
295 ff_emulated_edge_mc (s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
296 mx, my, s->h_edge_pos, s->v_edge_pos);
297 src = s->edge_emu_buffer;
298 }
299 if(thirdpel)
300 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
301 else
302 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
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);
309 blocksize++;
310
311 for (i=1; i < 3; i++) {
312 dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
313 src = pic->data[i] + mx + my*s->uvlinesize;
314
315 if (emu) {
316 ff_emulated_edge_mc (s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
317 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
318 src = s->edge_emu_buffer;
319 }
320 if(thirdpel)
321 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
322 else
323 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
324 }
325 }
326 }
327
328 static 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
433 static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
434 int i, j, k, m, dir, mode;
435 int cbp = 0;
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 */
447 if (s->pict_type == P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
448 svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
449
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);
452 }
453
454 mb_type = MB_TYPE_SKIP;
455 } else {
456 svq3_mc_dir (h, s->next_picture.mb_type[mb_xy], PREDICT_MODE, 0, 0);
457 svq3_mc_dir (h, s->next_picture.mb_type[mb_xy], PREDICT_MODE, 1, 1);
458
459 mb_type = MB_TYPE_16x16;
460 }
461 } else if (mb_type < 8) { /* INTER */
462 if (h->thirdpel_flag && h->halfpel_flag == !get_bits (&s->gb, 1)) {
463 mode = THIRDPEL_MODE;
464 } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits (&s->gb, 1)) {
465 mode = HALFPEL_MODE;
466 } else {
467 mode = FULLPEL_MODE;
468 }
469
470 /* fill caches */
471 /* note ref_cache should contain here:
472 ????????
473 ???11111
474 N??11111
475 N??11111
476 N??11111
477 N
478 */
479
480 for (m=0; m < 2; m++) {
481 if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
482 for (i=0; i < 4; i++) {
483 *(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];
484 }
485 } else {
486 for (i=0; i < 4; i++) {
487 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
488 }
489 }
490 if (s->mb_y > 0) {
491 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));
492 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);
493
494 if (s->mb_x < (s->mb_width - 1)) {
495 *(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];
496 h->ref_cache[m][scan8[0] + 4 - 1*8] =
497 (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
498 h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1;
499 }else
500 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
501 if (s->mb_x > 0) {
502 *(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];
503 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;
504 }else
505 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
506 }else
507 memset (&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
508
509 if (s->pict_type != B_TYPE)
510 break;
511 }
512
513 /* decode motion vector(s) and form prediction(s) */
514 if (s->pict_type == P_TYPE) {
515 svq3_mc_dir (h, (mb_type - 1), mode, 0, 0);
516 } else { /* B_TYPE */
517 if (mb_type != 2) {
518 svq3_mc_dir (h, 0, mode, 0, 0);
519 } else {
520 for (i=0; i < 4; i++) {
521 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
522 }
523 }
524 if (mb_type != 1) {
525 svq3_mc_dir (h, 0, mode, 1, (mb_type == 3));
526 } else {
527 for (i=0; i < 4; i++) {
528 memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
529 }
530 }
531 }
532
533 mb_type = MB_TYPE_16x16;
534 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
535 memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
536
537 if (mb_type == 8) {
538 if (s->mb_x > 0) {
539 for (i=0; i < 4; i++) {
540 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
541 }
542 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
543 h->left_samples_available = 0x5F5F;
544 }
545 }
546 if (s->mb_y > 0) {
547 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
548 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
549 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
550 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
551
552 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
553 h->top_samples_available = 0x33FF;
554 }
555 }
556
557 /* decode prediction codes for luma blocks */
558 for (i=0; i < 16; i+=2) {
559 vlc = svq3_get_ue_golomb (&s->gb);
560
561 if (vlc >= 25)
562 return -1;
563
564 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
565 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
566
567 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
568 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
569
570 if (left[1] == -1 || left[2] == -1)
571 return -1;
572 }
573 } else { /* mb_type == 33, DC_128_PRED block type */
574 for (i=0; i < 4; i++) {
575 memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
576 }
577 }
578
579 write_back_intra_pred_mode (h);
580
581 if (mb_type == 8) {
582 check_intra4x4_pred_mode (h);
583
584 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
585 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
586 } else {
587 for (i=0; i < 4; i++) {
588 memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
589 }
590
591 h->top_samples_available = 0x33FF;
592 h->left_samples_available = 0x5F5F;
593 }
594
595 mb_type = MB_TYPE_INTRA4x4;
596 } else { /* INTRA16x16 */
597 dir = i_mb_type_info[mb_type - 8].pred_mode;
598 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
599
600 if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1)
601 return -1;
602
603 cbp = i_mb_type_info[mb_type - 8].cbp;
604 mb_type = MB_TYPE_INTRA16x16;
605 }
606
607 if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
608 for (i=0; i < 4; i++) {
609 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
610 }
611 if (s->pict_type == B_TYPE) {
612 for (i=0; i < 4; i++) {
613 memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
614 }
615 }
616 }
617 if (!IS_INTRA4x4(mb_type)) {
618 memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
619 }
620 if (!IS_SKIP(mb_type) || s->pict_type == B_TYPE) {
621 memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
622 s->dsp.clear_blocks(h->mb);
623 }
624
625 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == B_TYPE)) {
626 if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48)
627 return -1;
628
629 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
630 }
631 if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
632 s->qscale += svq3_get_se_golomb (&s->gb);
633
634 if (s->qscale > 31)
635 return -1;
636 }
637 if (IS_INTRA16x16(mb_type)) {
638 if (svq3_decode_block (&s->gb, h->mb, 0, 0))
639 return -1;
640 }
641
642 if (cbp) {
643 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
644 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
645
646 for (i=0; i < 4; i++) {
647 if ((cbp & (1 << i))) {
648 for (j=0; j < 4; j++) {
649 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
650 h->non_zero_count_cache[ scan8[k] ] = 1;
651
652 if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type))
653 return -1;
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 return -1;
662 }
663
664 if ((cbp & 0x20)) {
665 for (i=0; i < 8; i++) {
666 h->non_zero_count_cache[ scan8[16+i] ] = 1;
667
668 if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1))
669 return -1;
670 }
671 }
672 }
673 }
674
675 s->current_picture.mb_type[mb_xy] = mb_type;
676
677 if (IS_INTRA(mb_type)) {
678 h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
679 }
680
681 return 0;
682 }
683
684 static int svq3_decode_slice_header (H264Context *h) {
685 MpegEncContext *const s = (MpegEncContext *) h;
686 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
687 int i, header;
688
689 header = get_bits (&s->gb, 8);
690
691 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
692 /* TODO: what? */
693 av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
694 return -1;
695 } else {
696 int length = (header >> 5) & 3;
697
698 h->next_slice_index = s->gb.index + 8*show_bits (&s->gb, 8*length) + 8*length;
699
700 if (h->next_slice_index > s->gb.size_in_bits){
701 av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
702 return -1;
703 }
704
705 s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
706 s->gb.index += 8;
707
708 if (length > 0) {
709 memcpy ((uint8_t *) &s->gb.buffer[s->gb.index >> 3],
710 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
711 }
712 }
713
714 if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3){
715 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
716 return -1;
717 }
718
719 h->slice_type = golomb_to_pict_type[i];
720
721 if ((header & 0x9F) == 2) {
722 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
723 s->mb_skip_run = get_bits (&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
724 } else {
725 get_bits1 (&s->gb);
726 s->mb_skip_run = 0;
727 }
728
729 h->slice_num = get_bits (&s->gb, 8);
730 s->qscale = get_bits (&s->gb, 5);
731 s->adaptive_quant = get_bits1 (&s->gb);
732
733 /* unknown fields */
734 get_bits1 (&s->gb);
735
736 if (h->unknown_svq3_flag) {
737 get_bits1 (&s->gb);
738 }
739
740 get_bits1 (&s->gb);
741 get_bits (&s->gb, 2);
742
743 while (get_bits1 (&s->gb)) {
744 get_bits (&s->gb, 8);
745 }
746
747 /* reset intra predictors and invalidate motion vector references */
748 if (s->mb_x > 0) {
749 memset (h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
750 memset (h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
751 }
752 if (s->mb_y > 0) {
753 memset (h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
754
755 if (s->mb_x > 0) {
756 h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
757 }
758 }
759
760 return 0;
761 }
762
763 static int svq3_decode_frame (AVCodecContext *avctx,
764 void *data, int *data_size,
765 uint8_t *buf, int buf_size) {
766 MpegEncContext *const s = avctx->priv_data;
767 H264Context *const h = avctx->priv_data;
768 int m, mb_type;
769 unsigned char *extradata;
770 unsigned int size;
771
772 *data_size = 0;
773
774 s->flags = avctx->flags;
775 s->flags2 = avctx->flags2;
776 s->unrestricted_mv = 1;
777
778 if (!s->context_initialized) {
779 s->width = avctx->width;
780 s->height = avctx->height;
781 h->pred4x4[DIAG_DOWN_LEFT_PRED] = pred4x4_down_left_svq3_c;
782 h->pred16x16[PLANE_PRED8x8] = pred16x16_plane_svq3_c;
783 h->halfpel_flag = 1;
784 h->thirdpel_flag = 1;
785 h->unknown_svq3_flag = 0;
786 h->chroma_qp = 4;
787
788 if (MPV_common_init (s) < 0)
789 return -1;
790
791 h->b_stride = 4*s->mb_width;
792
793 alloc_tables (h);
794
795 /* prowl for the "SEQH" marker in the extradata */
796 extradata = (unsigned char *)avctx->extradata;
797 for (m = 0; m < avctx->extradata_size; m++) {
798 if (!memcmp (extradata, "SEQH", 4))
799 break;
800 extradata++;
801 }
802
803 size = (extradata[4] << 24) | (extradata[5] << 16) |
804 (extradata[6] << 8) | extradata[7];
805
806 /* if a match was found, parse the extra data */
807 if (!memcmp (extradata, "SEQH", 4)) {
808
809 GetBitContext gb;
810
811 init_get_bits (&gb, extradata + 8, size);
812
813 /* 'frame size code' and optional 'width, height' */
814 if (get_bits (&gb, 3) == 7) {
815 get_bits (&gb, 12);
816 get_bits (&gb, 12);
817 }
818
819 h->halfpel_flag = get_bits1 (&gb);
820 h->thirdpel_flag = get_bits1 (&gb);
821
822 /* unknown fields */
823 get_bits1 (&gb);
824 get_bits1 (&gb);
825 get_bits1 (&gb);
826 get_bits1 (&gb);
827
828 s->low_delay = get_bits1 (&gb);
829
830 /* unknown field */
831 get_bits1 (&gb);
832
833 while (get_bits1 (&gb)) {
834 get_bits (&gb, 8);
835 }
836
837 h->unknown_svq3_flag = get_bits1 (&gb);
838 avctx->has_b_frames = !s->low_delay;
839 }
840 }
841
842 /* special case for last picture */
843 if (buf_size == 0) {
844 if (s->next_picture_ptr && !s->low_delay) {
845 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
846 *data_size = sizeof(AVFrame);
847 }
848 return 0;
849 }
850
851 init_get_bits (&s->gb, buf, 8*buf_size);
852
853 s->mb_x = s->mb_y = 0;
854
855 if (svq3_decode_slice_header (h))
856 return -1;
857
858 s->pict_type = h->slice_type;
859 s->picture_number = h->slice_num;
860
861 if(avctx->debug&FF_DEBUG_PICT_INFO){
862 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d\n",
863 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
864 s->adaptive_quant, s->qscale
865 );
866 }
867
868 /* for hurry_up==5 */
869 s->current_picture.pict_type = s->pict_type;
870 s->current_picture.key_frame = (s->pict_type == I_TYPE);
871
872 /* skip b frames if we dont have reference frames */
873 if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
874 /* skip b frames if we are in a hurry */
875 if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
876 /* skip everything if we are in a hurry >= 5 */
877 if (avctx->hurry_up >= 5) return 0;
878
879 if (s->next_p_frame_damaged) {
880 if (s->pict_type == B_TYPE)
881 return 0;
882 else
883 s->next_p_frame_damaged = 0;
884 }
885
886 frame_start (h);
887
888 if (s->pict_type == B_TYPE) {
889 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
890
891 if (h->frame_num_offset < 0) {
892 h->frame_num_offset += 256;
893 }
894 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
895 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
896 return -1;
897 }
898 } else {
899 h->prev_frame_num = h->frame_num;
900 h->frame_num = h->slice_num;
901 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
902
903 if (h->prev_frame_num_offset < 0) {
904 h->prev_frame_num_offset += 256;
905 }
906 }
907
908 for(m=0; m<2; m++){
909 int i;
910 for(i=0; i<4; i++){
911 int j;
912 for(j=-1; j<4; j++)
913 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
914 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
915 }
916 }
917
918 for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
919 for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
920
921 if ( (s->gb.index + 7) >= s->gb.size_in_bits &&
922 ((s->gb.index & 7) == 0 || show_bits (&s->gb, (-s->gb.index & 7)) == 0)) {
923
924 s->gb.index = h->next_slice_index;
925 s->gb.size_in_bits = 8*buf_size;
926
927 if (svq3_decode_slice_header (h))
928 return -1;
929
930 /* TODO: support s->mb_skip_run */
931 }
932
933 mb_type = svq3_get_ue_golomb (&s->gb);
934
935 if (s->pict_type == I_TYPE) {
936 mb_type += 8;
937 } else if (s->pict_type == B_TYPE && mb_type >= 4) {
938 mb_type += 4;
939 }
940 if (mb_type > 33 || svq3_decode_mb (h, mb_type)) {
941 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
942 return -1;
943 }
944
945 if (mb_type != 0) {
946 hl_decode_mb (h);
947 }
948
949 if (s->pict_type != B_TYPE && !s->low_delay) {
950 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
951 (s->pict_type == P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
952 }
953 }
954
955 ff_draw_horiz_band(s, 16*s->mb_y, 16);
956 }
957
958 MPV_frame_end(s);
959
960 if (s->pict_type == B_TYPE || s->low_delay) {
961 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
962 } else {
963 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
964 }
965
966 avctx->frame_number = s->picture_number - 1;
967
968 /* dont output the last pic after seeking */
969 if (s->last_picture_ptr || s->low_delay) {
970 *data_size = sizeof(AVFrame);
971 }
972
973 return buf_size;
974 }
975
976
977 AVCodec svq3_decoder = {
978 "svq3",
979 CODEC_TYPE_VIDEO,
980 CODEC_ID_SVQ3,
981 sizeof(H264Context),
982 decode_init,
983 NULL,
984 decode_end,
985 svq3_decode_frame,
986 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
987 };