2 * Copyright (c) 2003 The FFmpeg Project.
4 * This file is part of FFmpeg.
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.
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.
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
21 * How to use this decoder:
22 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
23 * have stsd atoms to describe media trak properties. A stsd atom for a
24 * video trak contains 1 or more ImageDescription atoms. These atoms begin
25 * with the 4-byte length of the atom followed by the codec fourcc. Some
26 * decoders need information in this atom to operate correctly. Such
27 * is the case with SVQ3. In order to get the best use out of this decoder,
28 * the calling app must make the SVQ3 ImageDescription atom available
29 * via the AVCodecContext's extradata[_size] field:
31 * AVCodecContext.extradata = pointer to ImageDescription, first characters
32 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
33 * AVCodecContext.extradata_size = size of ImageDescription atom memory
34 * buffer (which will be the same as the ImageDescription atom size field
35 * from the QT file, minus 4 bytes since the length is missing)
37 * You will know you have these parameters passed correctly when the decoder
38 * correctly decodes this file:
39 * ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
48 #define FULLPEL_MODE 1
49 #define HALFPEL_MODE 2
50 #define THIRDPEL_MODE 3
51 #define PREDICT_MODE 4
53 /* dual scan (from some older h264 draft)
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,
69 static const uint8_t svq3_pred_0[25][2] = {
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 },
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 } },
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 } }
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
111 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp){
112 const int qmul= svq3_dequant_coeff[qp];
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};
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];
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];
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;
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];
150 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
153 dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
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];
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;
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);
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) ];
183 static void pred4x4_down_left_svq3_c(uint8_t *src, uint8_t *topright, int stride){
186 const __attribute__((unused)) int unu0= t0;
187 const __attribute__((unused)) int unu1= l0;
189 src[0+0*stride]=(l1 + t1)>>1;
191 src[0+1*stride]=(l2 + t2)>>1;
204 src[3+3*stride]=(l3 + t3)>>1;
207 static void pred16x16_plane_svq3_c(uint8_t *src, int stride){
208 pred16x16_plane_compat_c(src, stride, 1);
211 static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
212 int index, const int type) {
214 static const uint8_t *const scan_patterns[4] =
215 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
217 int run, level, sign, vlc, limit;
218 const int intra = (3 * type) >> 2;
219 const uint8_t *const scan = scan_patterns[type];
221 for (limit=(16 >> intra); index < 16; index=limit, limit+=8) {
222 for (; (vlc = svq3_get_ue_golomb (gb)) != 0; index++) {
224 if (vlc == INVALID_VLC)
227 sign = (vlc & 0x1) - 1;
228 vlc = (vlc + 1) >> 1;
234 } else if (vlc < 4) {
239 level = ((vlc + 9) >> 2) - run;
243 run = svq3_dct_tables[intra][vlc].run;
244 level = svq3_dct_tables[intra][vlc].level;
247 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
250 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
254 if ((index += run) >= limit)
257 block[scan[index]] = (level ^ sign) - sign;
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) {
273 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
276 int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
281 if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
282 my < 0 || my >= (s->v_edge_pos - height - 1)) {
284 if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
288 mx = av_clip (mx, -16, (s->h_edge_pos - width + 15));
289 my = av_clip (my, -16, (s->v_edge_pos - height + 15));
292 /* form component predictions */
293 dest = s->current_picture.data[0] + x + y*s->linesize;
294 src = pic->data[0] + mx + my*s->linesize;
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;
302 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
304 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
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);
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;
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;
323 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
325 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
330 static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {
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;
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;
346 k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8);
348 if (mode != PREDICT_MODE) {
349 pred_motion (h, k, (part_width >> 2), dir, 1, &mx, &my);
351 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
352 my = s->next_picture.motion_val[0][b_xy][1]<<1;
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;
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;
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);
367 /* get (optional) motion vector differential */
368 if (mode == PREDICT_MODE) {
371 dy = svq3_get_se_golomb (&s->gb);
372 dx = svq3_get_se_golomb (&s->gb);
374 if (dx == INVALID_VLC || dy == INVALID_VLC) {
375 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
380 /* compute motion vector */
381 if (mode == THIRDPEL_MODE) {
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);
389 svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
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);
397 svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
401 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
402 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
404 svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
409 /* update mv_cache */
410 if (mode != PREDICT_MODE) {
411 int32_t mv = pack16to32(mx,my);
413 if (part_height == 8 && i < 8) {
414 *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
416 if (part_width == 8 && j < 8) {
417 *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
420 if (part_width == 8 && j < 8) {
421 *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
423 if (part_width == 4 || part_height == 4) {
424 *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
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);
436 static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
437 int i, j, k, m, dir, mode;
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;
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;
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);
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);
457 mb_type = MB_TYPE_SKIP;
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)
462 if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 1, 1) < 0)
465 mb_type = MB_TYPE_16x16;
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)) {
477 /* note ref_cache should contain here:
486 for (m=0; m < 2; m++) {
487 if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
488 for (i=0; i < 4; i++) {
489 *(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];
492 for (i=0; i < 4; i++) {
493 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
497 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));
498 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);
500 if (s->mb_x < (s->mb_width - 1)) {
501 *(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];
502 h->ref_cache[m][scan8[0] + 4 - 1*8] =
503 (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
504 h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1;
506 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
508 *(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];
509 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;
511 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
513 memset (&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
515 if (s->pict_type != B_TYPE)
519 /* decode motion vector(s) and form prediction(s) */
520 if (s->pict_type == P_TYPE) {
521 if(svq3_mc_dir (h, (mb_type - 1), mode, 0, 0) < 0)
523 } else { /* B_TYPE */
525 if(svq3_mc_dir (h, 0, mode, 0, 0) < 0)
528 for (i=0; i < 4; i++) {
529 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
533 if(svq3_mc_dir (h, 0, mode, 1, (mb_type == 3)) < 0)
536 for (i=0; i < 4; i++) {
537 memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
542 mb_type = MB_TYPE_16x16;
543 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
544 memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
548 for (i=0; i < 4; i++) {
549 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
551 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
552 h->left_samples_available = 0x5F5F;
556 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
557 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
558 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
559 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
561 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
562 h->top_samples_available = 0x33FF;
566 /* decode prediction codes for luma blocks */
567 for (i=0; i < 16; i+=2) {
568 vlc = svq3_get_ue_golomb (&s->gb);
571 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
575 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
576 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
578 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
579 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
581 if (left[1] == -1 || left[2] == -1){
582 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
586 } else { /* mb_type == 33, DC_128_PRED block type */
587 for (i=0; i < 4; i++) {
588 memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
592 write_back_intra_pred_mode (h);
595 check_intra4x4_pred_mode (h);
597 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
598 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
600 for (i=0; i < 4; i++) {
601 memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
604 h->top_samples_available = 0x33FF;
605 h->left_samples_available = 0x5F5F;
608 mb_type = MB_TYPE_INTRA4x4;
609 } else { /* INTRA16x16 */
610 dir = i_mb_type_info[mb_type - 8].pred_mode;
611 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
613 if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1){
614 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
618 cbp = i_mb_type_info[mb_type - 8].cbp;
619 mb_type = MB_TYPE_INTRA16x16;
622 if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
623 for (i=0; i < 4; i++) {
624 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
626 if (s->pict_type == B_TYPE) {
627 for (i=0; i < 4; i++) {
628 memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
632 if (!IS_INTRA4x4(mb_type)) {
633 memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
635 if (!IS_SKIP(mb_type) || s->pict_type == B_TYPE) {
636 memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
637 s->dsp.clear_blocks(h->mb);
640 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == B_TYPE)) {
641 if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48){
642 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
646 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
648 if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
649 s->qscale += svq3_get_se_golomb (&s->gb);
652 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
656 if (IS_INTRA16x16(mb_type)) {
657 if (svq3_decode_block (&s->gb, h->mb, 0, 0)){
658 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
664 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
665 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
667 for (i=0; i < 4; i++) {
668 if ((cbp & (1 << i))) {
669 for (j=0; j < 4; j++) {
670 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
671 h->non_zero_count_cache[ scan8[k] ] = 1;
673 if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type)){
674 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
682 for (i=0; i < 2; ++i) {
683 if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
684 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
690 for (i=0; i < 8; i++) {
691 h->non_zero_count_cache[ scan8[16+i] ] = 1;
693 if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1)){
694 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
702 s->current_picture.mb_type[mb_xy] = mb_type;
704 if (IS_INTRA(mb_type)) {
705 h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
711 static int svq3_decode_slice_header (H264Context *h) {
712 MpegEncContext *const s = (MpegEncContext *) h;
713 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
716 header = get_bits (&s->gb, 8);
718 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
720 av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
723 int length = (header >> 5) & 3;
725 h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits (&s->gb, 8*length) + 8*length;
727 if (h->next_slice_index > s->gb.size_in_bits){
728 av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
732 s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
733 skip_bits(&s->gb, 8);
736 memcpy ((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
737 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
741 if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3){
742 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
746 h->slice_type = golomb_to_pict_type[i];
748 if ((header & 0x9F) == 2) {
749 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
750 s->mb_skip_run = get_bits (&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
756 h->slice_num = get_bits (&s->gb, 8);
757 s->qscale = get_bits (&s->gb, 5);
758 s->adaptive_quant = get_bits1 (&s->gb);
763 if (h->unknown_svq3_flag) {
768 get_bits (&s->gb, 2);
770 while (get_bits1 (&s->gb)) {
771 get_bits (&s->gb, 8);
774 /* reset intra predictors and invalidate motion vector references */
776 memset (h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
777 memset (h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
780 memset (h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
783 h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
790 static int svq3_decode_frame (AVCodecContext *avctx,
791 void *data, int *data_size,
792 uint8_t *buf, int buf_size) {
793 MpegEncContext *const s = avctx->priv_data;
794 H264Context *const h = avctx->priv_data;
796 unsigned char *extradata;
799 s->flags = avctx->flags;
800 s->flags2 = avctx->flags2;
801 s->unrestricted_mv = 1;
803 if (!s->context_initialized) {
804 s->width = avctx->width;
805 s->height = avctx->height;
806 h->pred4x4[DIAG_DOWN_LEFT_PRED] = pred4x4_down_left_svq3_c;
807 h->pred16x16[PLANE_PRED8x8] = pred16x16_plane_svq3_c;
809 h->thirdpel_flag = 1;
810 h->unknown_svq3_flag = 0;
813 if (MPV_common_init (s) < 0)
816 h->b_stride = 4*s->mb_width;
820 /* prowl for the "SEQH" marker in the extradata */
821 extradata = (unsigned char *)avctx->extradata;
822 for (m = 0; m < avctx->extradata_size; m++) {
823 if (!memcmp (extradata, "SEQH", 4))
828 /* if a match was found, parse the extra data */
829 if (extradata && !memcmp (extradata, "SEQH", 4)) {
833 size = AV_RB32(&extradata[4]);
834 init_get_bits (&gb, extradata + 8, size*8);
836 /* 'frame size code' and optional 'width, height' */
837 if (get_bits (&gb, 3) == 7) {
842 h->halfpel_flag = get_bits1 (&gb);
843 h->thirdpel_flag = get_bits1 (&gb);
851 s->low_delay = get_bits1 (&gb);
856 while (get_bits1 (&gb)) {
860 h->unknown_svq3_flag = get_bits1 (&gb);
861 avctx->has_b_frames = !s->low_delay;
865 /* special case for last picture */
867 if (s->next_picture_ptr && !s->low_delay) {
868 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
869 *data_size = sizeof(AVFrame);
874 init_get_bits (&s->gb, buf, 8*buf_size);
876 s->mb_x = s->mb_y = 0;
878 if (svq3_decode_slice_header (h))
881 s->pict_type = h->slice_type;
882 s->picture_number = h->slice_num;
884 if(avctx->debug&FF_DEBUG_PICT_INFO){
885 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d\n",
886 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
887 s->adaptive_quant, s->qscale
891 /* for hurry_up==5 */
892 s->current_picture.pict_type = s->pict_type;
893 s->current_picture.key_frame = (s->pict_type == I_TYPE);
895 /* skip b frames if we dont have reference frames */
896 if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
897 /* skip b frames if we are in a hurry */
898 if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
899 /* skip everything if we are in a hurry >= 5 */
900 if (avctx->hurry_up >= 5) return 0;
901 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
902 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
903 || avctx->skip_frame >= AVDISCARD_ALL)
906 if (s->next_p_frame_damaged) {
907 if (s->pict_type == B_TYPE)
910 s->next_p_frame_damaged = 0;
913 if (frame_start (h) < 0)
916 if (s->pict_type == B_TYPE) {
917 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
919 if (h->frame_num_offset < 0) {
920 h->frame_num_offset += 256;
922 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
923 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
927 h->prev_frame_num = h->frame_num;
928 h->frame_num = h->slice_num;
929 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
931 if (h->prev_frame_num_offset < 0) {
932 h->prev_frame_num_offset += 256;
941 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
942 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
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++) {
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)) {
952 skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
953 s->gb.size_in_bits = 8*buf_size;
955 if (svq3_decode_slice_header (h))
958 /* TODO: support s->mb_skip_run */
961 mb_type = svq3_get_ue_golomb (&s->gb);
963 if (s->pict_type == I_TYPE) {
965 } else if (s->pict_type == B_TYPE && mb_type >= 4) {
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);
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;
983 ff_draw_horiz_band(s, 16*s->mb_y, 16);
988 if (s->pict_type == B_TYPE || s->low_delay) {
989 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
991 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
994 avctx->frame_number = s->picture_number - 1;
996 /* dont output the last pic after seeking */
997 if (s->last_picture_ptr || s->low_delay) {
998 *data_size = sizeof(AVFrame);
1005 AVCodec svq3_decoder = {
1009 sizeof(H264Context),
1014 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,