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