00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00048 #define FULLPEL_MODE 1
00049 #define HALFPEL_MODE 2
00050 #define THIRDPEL_MODE 3
00051 #define PREDICT_MODE 4
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062 static const uint8_t svq3_scan[16]={
00063 0+0*4, 1+0*4, 2+0*4, 2+1*4,
00064 2+2*4, 3+0*4, 3+1*4, 3+2*4,
00065 0+1*4, 0+2*4, 1+1*4, 1+2*4,
00066 0+3*4, 1+3*4, 2+3*4, 3+3*4,
00067 };
00068
00069 static const uint8_t svq3_pred_0[25][2] = {
00070 { 0, 0 },
00071 { 1, 0 }, { 0, 1 },
00072 { 0, 2 }, { 1, 1 }, { 2, 0 },
00073 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
00074 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
00075 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
00076 { 2, 4 }, { 3, 3 }, { 4, 2 },
00077 { 4, 3 }, { 3, 4 },
00078 { 4, 4 }
00079 };
00080
00081 static const int8_t svq3_pred_1[6][6][5] = {
00082 { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
00083 { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
00084 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
00085 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
00086 { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
00087 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
00088 { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
00089 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
00090 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
00091 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
00092 { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
00093 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
00094 };
00095
00096 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
00097 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
00098 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
00099 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
00100 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
00101 };
00102
00103 static const uint32_t svq3_dequant_coeff[32] = {
00104 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
00105 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
00106 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
00107 61694, 68745, 77615, 89113,100253,109366,126635,141533
00108 };
00109
00110
00111 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp){
00112 const int qmul= svq3_dequant_coeff[qp];
00113 #define stride 16
00114 int i;
00115 int temp[16];
00116 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
00117 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
00118
00119 for(i=0; i<4; i++){
00120 const int offset= y_offset[i];
00121 const int z0= 13*(block[offset+stride*0] + block[offset+stride*4]);
00122 const int z1= 13*(block[offset+stride*0] - block[offset+stride*4]);
00123 const int z2= 7* block[offset+stride*1] - 17*block[offset+stride*5];
00124 const int z3= 17* block[offset+stride*1] + 7*block[offset+stride*5];
00125
00126 temp[4*i+0]= z0+z3;
00127 temp[4*i+1]= z1+z2;
00128 temp[4*i+2]= z1-z2;
00129 temp[4*i+3]= z0-z3;
00130 }
00131
00132 for(i=0; i<4; i++){
00133 const int offset= x_offset[i];
00134 const int z0= 13*(temp[4*0+i] + temp[4*2+i]);
00135 const int z1= 13*(temp[4*0+i] - temp[4*2+i]);
00136 const int z2= 7* temp[4*1+i] - 17*temp[4*3+i];
00137 const int z3= 17* temp[4*1+i] + 7*temp[4*3+i];
00138
00139 block[stride*0 +offset]= ((z0 + z3)*qmul + 0x80000)>>20;
00140 block[stride*2 +offset]= ((z1 + z2)*qmul + 0x80000)>>20;
00141 block[stride*8 +offset]= ((z1 - z2)*qmul + 0x80000)>>20;
00142 block[stride*10+offset]= ((z0 - z3)*qmul + 0x80000)>>20;
00143 }
00144 }
00145 #undef stride
00146
00147 static void svq3_add_idct_c (uint8_t *dst, DCTELEM *block, int stride, int qp, int dc){
00148 const int qmul= svq3_dequant_coeff[qp];
00149 int i;
00150 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
00151
00152 if (dc) {
00153 dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
00154 block[0] = 0;
00155 }
00156
00157 for (i=0; i < 4; i++) {
00158 const int z0= 13*(block[0 + 4*i] + block[2 + 4*i]);
00159 const int z1= 13*(block[0 + 4*i] - block[2 + 4*i]);
00160 const int z2= 7* block[1 + 4*i] - 17*block[3 + 4*i];
00161 const int z3= 17* block[1 + 4*i] + 7*block[3 + 4*i];
00162
00163 block[0 + 4*i]= z0 + z3;
00164 block[1 + 4*i]= z1 + z2;
00165 block[2 + 4*i]= z1 - z2;
00166 block[3 + 4*i]= z0 - z3;
00167 }
00168
00169 for (i=0; i < 4; i++) {
00170 const int z0= 13*(block[i + 4*0] + block[i + 4*2]);
00171 const int z1= 13*(block[i + 4*0] - block[i + 4*2]);
00172 const int z2= 7* block[i + 4*1] - 17*block[i + 4*3];
00173 const int z3= 17* block[i + 4*1] + 7*block[i + 4*3];
00174 const int rr= (dc + 0x80000);
00175
00176 dst[i + stride*0]= cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
00177 dst[i + stride*1]= cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
00178 dst[i + stride*2]= cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
00179 dst[i + stride*3]= cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
00180 }
00181 }
00182
00183 static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
00184 int index, const int type) {
00185
00186 static const uint8_t *const scan_patterns[4] =
00187 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
00188
00189 int run, level, sign, vlc, limit;
00190 const int intra = (3 * type) >> 2;
00191 const uint8_t *const scan = scan_patterns[type];
00192
00193 for (limit=(16 >> intra); index < 16; index=limit, limit+=8) {
00194 for (; (vlc = svq3_get_ue_golomb (gb)) != 0; index++) {
00195
00196 if (vlc == INVALID_VLC)
00197 return -1;
00198
00199 sign = (vlc & 0x1) - 1;
00200 vlc = (vlc + 1) >> 1;
00201
00202 if (type == 3) {
00203 if (vlc < 3) {
00204 run = 0;
00205 level = vlc;
00206 } else if (vlc < 4) {
00207 run = 1;
00208 level = 1;
00209 } else {
00210 run = (vlc & 0x3);
00211 level = ((vlc + 9) >> 2) - run;
00212 }
00213 } else {
00214 if (vlc < 16) {
00215 run = svq3_dct_tables[intra][vlc].run;
00216 level = svq3_dct_tables[intra][vlc].level;
00217 } else if (intra) {
00218 run = (vlc & 0x7);
00219 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
00220 } else {
00221 run = (vlc & 0xF);
00222 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
00223 }
00224 }
00225
00226 if ((index += run) >= limit)
00227 return -1;
00228
00229 block[scan[index]] = (level ^ sign) - sign;
00230 }
00231
00232 if (type != 2) {
00233 break;
00234 }
00235 }
00236
00237 return 0;
00238 }
00239
00240 static inline void svq3_mc_dir_part (MpegEncContext *s,
00241 int x, int y, int width, int height,
00242 int mx, int my, int dxy,
00243 int thirdpel, int dir, int avg) {
00244
00245 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
00246 uint8_t *src, *dest;
00247 int i, emu = 0;
00248 int blocksize= 2 - (width>>3);
00249
00250 mx += x;
00251 my += y;
00252
00253 if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
00254 my < 0 || my >= (s->v_edge_pos - height - 1)) {
00255
00256 if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
00257 emu = 1;
00258 }
00259
00260 mx = av_clip (mx, -16, (s->h_edge_pos - width + 15));
00261 my = av_clip (my, -16, (s->v_edge_pos - height + 15));
00262 }
00263
00264
00265 dest = s->current_picture.data[0] + x + y*s->linesize;
00266 src = pic->data[0] + mx + my*s->linesize;
00267
00268 if (emu) {
00269 ff_emulated_edge_mc (s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
00270 mx, my, s->h_edge_pos, s->v_edge_pos);
00271 src = s->edge_emu_buffer;
00272 }
00273 if(thirdpel)
00274 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
00275 else
00276 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
00277
00278 if (!(s->flags & CODEC_FLAG_GRAY)) {
00279 mx = (mx + (mx < (int) x)) >> 1;
00280 my = (my + (my < (int) y)) >> 1;
00281 width = (width >> 1);
00282 height = (height >> 1);
00283 blocksize++;
00284
00285 for (i=1; i < 3; i++) {
00286 dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
00287 src = pic->data[i] + mx + my*s->uvlinesize;
00288
00289 if (emu) {
00290 ff_emulated_edge_mc (s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
00291 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
00292 src = s->edge_emu_buffer;
00293 }
00294 if(thirdpel)
00295 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
00296 else
00297 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
00298 }
00299 }
00300 }
00301
00302 static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {
00303
00304 int i, j, k, mx, my, dx, dy, x, y;
00305 MpegEncContext *const s = (MpegEncContext *) h;
00306 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
00307 const int part_height = 16 >> ((unsigned) (size + 1) / 3);
00308 const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
00309 const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width;
00310 const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width;
00311
00312 for (i=0; i < 16; i+=part_height) {
00313 for (j=0; j < 16; j+=part_width) {
00314 const int b_xy = (4*s->mb_x+(j>>2)) + (4*s->mb_y+(i>>2))*h->b_stride;
00315 int dxy;
00316 x = 16*s->mb_x + j;
00317 y = 16*s->mb_y + i;
00318 k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8);
00319
00320 if (mode != PREDICT_MODE) {
00321 pred_motion (h, k, (part_width >> 2), dir, 1, &mx, &my);
00322 } else {
00323 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
00324 my = s->next_picture.motion_val[0][b_xy][1]<<1;
00325
00326 if (dir == 0) {
00327 mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
00328 my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
00329 } else {
00330 mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
00331 my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
00332 }
00333 }
00334
00335
00336 mx = av_clip (mx, extra_width - 6*x, h_edge_pos - 6*x);
00337 my = av_clip (my, extra_width - 6*y, v_edge_pos - 6*y);
00338
00339
00340 if (mode == PREDICT_MODE) {
00341 dx = dy = 0;
00342 } else {
00343 dy = svq3_get_se_golomb (&s->gb);
00344 dx = svq3_get_se_golomb (&s->gb);
00345
00346 if (dx == INVALID_VLC || dy == INVALID_VLC) {
00347 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
00348 return -1;
00349 }
00350 }
00351
00352
00353 if (mode == THIRDPEL_MODE) {
00354 int fx, fy;
00355 mx = ((mx + 1)>>1) + dx;
00356 my = ((my + 1)>>1) + dy;
00357 fx= ((unsigned)(mx + 0x3000))/3 - 0x1000;
00358 fy= ((unsigned)(my + 0x3000))/3 - 0x1000;
00359 dxy= (mx - 3*fx) + 4*(my - 3*fy);
00360
00361 svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
00362 mx += mx;
00363 my += my;
00364 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
00365 mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
00366 my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
00367 dxy= (mx&1) + 2*(my&1);
00368
00369 svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
00370 mx *= 3;
00371 my *= 3;
00372 } else {
00373 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
00374 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
00375
00376 svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
00377 mx *= 6;
00378 my *= 6;
00379 }
00380
00381
00382 if (mode != PREDICT_MODE) {
00383 int32_t mv = pack16to32(mx,my);
00384
00385 if (part_height == 8 && i < 8) {
00386 *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
00387
00388 if (part_width == 8 && j < 8) {
00389 *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
00390 }
00391 }
00392 if (part_width == 8 && j < 8) {
00393 *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
00394 }
00395 if (part_width == 4 || part_height == 4) {
00396 *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
00397 }
00398 }
00399
00400
00401 fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
00402 }
00403 }
00404
00405 return 0;
00406 }
00407
00408 static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
00409 int i, j, k, m, dir, mode;
00410 int cbp = 0;
00411 uint32_t vlc;
00412 int8_t *top, *left;
00413 MpegEncContext *const s = (MpegEncContext *) h;
00414 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
00415 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
00416
00417 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
00418 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
00419 h->topright_samples_available = 0xFFFF;
00420
00421 if (mb_type == 0) {
00422 if (s->pict_type == P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
00423 svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
00424
00425 if (s->pict_type == B_TYPE) {
00426 svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
00427 }
00428
00429 mb_type = MB_TYPE_SKIP;
00430 } else {
00431 mb_type= FFMIN(s->next_picture.mb_type[mb_xy], 6);
00432 if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 0, 0) < 0)
00433 return -1;
00434 if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 1, 1) < 0)
00435 return -1;
00436
00437 mb_type = MB_TYPE_16x16;
00438 }
00439 } else if (mb_type < 8) {
00440 if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
00441 mode = THIRDPEL_MODE;
00442 } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
00443 mode = HALFPEL_MODE;
00444 } else {
00445 mode = FULLPEL_MODE;
00446 }
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457 for (m=0; m < 2; m++) {
00458 if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
00459 for (i=0; i < 4; i++) {
00460 *(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];
00461 }
00462 } else {
00463 for (i=0; i < 4; i++) {
00464 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
00465 }
00466 }
00467 if (s->mb_y > 0) {
00468 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));
00469 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);
00470
00471 if (s->mb_x < (s->mb_width - 1)) {
00472 *(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];
00473 h->ref_cache[m][scan8[0] + 4 - 1*8] =
00474 (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
00475 h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1;
00476 }else
00477 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
00478 if (s->mb_x > 0) {
00479 *(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];
00480 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;
00481 }else
00482 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
00483 }else
00484 memset (&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
00485
00486 if (s->pict_type != B_TYPE)
00487 break;
00488 }
00489
00490
00491 if (s->pict_type == P_TYPE) {
00492 if(svq3_mc_dir (h, (mb_type - 1), mode, 0, 0) < 0)
00493 return -1;
00494 } else {
00495 if (mb_type != 2) {
00496 if(svq3_mc_dir (h, 0, mode, 0, 0) < 0)
00497 return -1;
00498 } else {
00499 for (i=0; i < 4; i++) {
00500 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
00501 }
00502 }
00503 if (mb_type != 1) {
00504 if(svq3_mc_dir (h, 0, mode, 1, (mb_type == 3)) < 0)
00505 return -1;
00506 } else {
00507 for (i=0; i < 4; i++) {
00508 memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
00509 }
00510 }
00511 }
00512
00513 mb_type = MB_TYPE_16x16;
00514 } else if (mb_type == 8 || mb_type == 33) {
00515 memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
00516
00517 if (mb_type == 8) {
00518 if (s->mb_x > 0) {
00519 for (i=0; i < 4; i++) {
00520 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
00521 }
00522 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
00523 h->left_samples_available = 0x5F5F;
00524 }
00525 }
00526 if (s->mb_y > 0) {
00527 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
00528 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
00529 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
00530 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
00531
00532 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
00533 h->top_samples_available = 0x33FF;
00534 }
00535 }
00536
00537
00538 for (i=0; i < 16; i+=2) {
00539 vlc = svq3_get_ue_golomb (&s->gb);
00540
00541 if (vlc >= 25){
00542 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
00543 return -1;
00544 }
00545
00546 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
00547 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
00548
00549 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
00550 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
00551
00552 if (left[1] == -1 || left[2] == -1){
00553 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
00554 return -1;
00555 }
00556 }
00557 } else {
00558 for (i=0; i < 4; i++) {
00559 memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
00560 }
00561 }
00562
00563 write_back_intra_pred_mode (h);
00564
00565 if (mb_type == 8) {
00566 check_intra4x4_pred_mode (h);
00567
00568 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
00569 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
00570 } else {
00571 for (i=0; i < 4; i++) {
00572 memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
00573 }
00574
00575 h->top_samples_available = 0x33FF;
00576 h->left_samples_available = 0x5F5F;
00577 }
00578
00579 mb_type = MB_TYPE_INTRA4x4;
00580 } else {
00581 dir = i_mb_type_info[mb_type - 8].pred_mode;
00582 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
00583
00584 if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1){
00585 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
00586 return -1;
00587 }
00588
00589 cbp = i_mb_type_info[mb_type - 8].cbp;
00590 mb_type = MB_TYPE_INTRA16x16;
00591 }
00592
00593 if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
00594 for (i=0; i < 4; i++) {
00595 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
00596 }
00597 if (s->pict_type == B_TYPE) {
00598 for (i=0; i < 4; i++) {
00599 memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
00600 }
00601 }
00602 }
00603 if (!IS_INTRA4x4(mb_type)) {
00604 memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
00605 }
00606 if (!IS_SKIP(mb_type) || s->pict_type == B_TYPE) {
00607 memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
00608 s->dsp.clear_blocks(h->mb);
00609 }
00610
00611 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == B_TYPE)) {
00612 if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48){
00613 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
00614 return -1;
00615 }
00616
00617 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
00618 }
00619 if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
00620 s->qscale += svq3_get_se_golomb (&s->gb);
00621
00622 if (s->qscale > 31){
00623 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
00624 return -1;
00625 }
00626 }
00627 if (IS_INTRA16x16(mb_type)) {
00628 if (svq3_decode_block (&s->gb, h->mb, 0, 0)){
00629 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
00630 return -1;
00631 }
00632 }
00633
00634 if (cbp) {
00635 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
00636 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
00637
00638 for (i=0; i < 4; i++) {
00639 if ((cbp & (1 << i))) {
00640 for (j=0; j < 4; j++) {
00641 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
00642 h->non_zero_count_cache[ scan8[k] ] = 1;
00643
00644 if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type)){
00645 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
00646 return -1;
00647 }
00648 }
00649 }
00650 }
00651
00652 if ((cbp & 0x30)) {
00653 for (i=0; i < 2; ++i) {
00654 if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
00655 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
00656 return -1;
00657 }
00658 }
00659
00660 if ((cbp & 0x20)) {
00661 for (i=0; i < 8; i++) {
00662 h->non_zero_count_cache[ scan8[16+i] ] = 1;
00663
00664 if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1)){
00665 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
00666 return -1;
00667 }
00668 }
00669 }
00670 }
00671 }
00672
00673 s->current_picture.mb_type[mb_xy] = mb_type;
00674
00675 if (IS_INTRA(mb_type)) {
00676 h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
00677 }
00678
00679 return 0;
00680 }
00681
00682 static int svq3_decode_slice_header (H264Context *h) {
00683 MpegEncContext *const s = (MpegEncContext *) h;
00684 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
00685 int i, header;
00686
00687 header = get_bits (&s->gb, 8);
00688
00689 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
00690
00691 av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
00692 return -1;
00693 } else {
00694 int length = (header >> 5) & 3;
00695
00696 h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits (&s->gb, 8*length) + 8*length;
00697
00698 if (h->next_slice_index > s->gb.size_in_bits){
00699 av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
00700 return -1;
00701 }
00702
00703 s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
00704 skip_bits(&s->gb, 8);
00705
00706 if (length > 0) {
00707 memcpy ((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
00708 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
00709 }
00710 }
00711
00712 if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3){
00713 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
00714 return -1;
00715 }
00716
00717 h->slice_type = golomb_to_pict_type[i];
00718
00719 if ((header & 0x9F) == 2) {
00720 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
00721 s->mb_skip_run = get_bits (&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
00722 } else {
00723 skip_bits1 (&s->gb);
00724 s->mb_skip_run = 0;
00725 }
00726
00727 h->slice_num = get_bits (&s->gb, 8);
00728 s->qscale = get_bits (&s->gb, 5);
00729 s->adaptive_quant = get_bits1 (&s->gb);
00730
00731
00732 skip_bits1 (&s->gb);
00733
00734 if (h->unknown_svq3_flag) {
00735 skip_bits1 (&s->gb);
00736 }
00737
00738 skip_bits1 (&s->gb);
00739 skip_bits (&s->gb, 2);
00740
00741 while (get_bits1 (&s->gb)) {
00742 skip_bits (&s->gb, 8);
00743 }
00744
00745
00746 if (s->mb_x > 0) {
00747 memset (h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
00748 memset (h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
00749 }
00750 if (s->mb_y > 0) {
00751 memset (h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
00752
00753 if (s->mb_x > 0) {
00754 h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
00755 }
00756 }
00757
00758 return 0;
00759 }
00760
00761 static int svq3_decode_frame (AVCodecContext *avctx,
00762 void *data, int *data_size,
00763 const uint8_t *buf, int buf_size) {
00764 MpegEncContext *const s = avctx->priv_data;
00765 H264Context *const h = avctx->priv_data;
00766 int m, mb_type;
00767 unsigned char *extradata;
00768 unsigned int size;
00769
00770 s->flags = avctx->flags;
00771 s->flags2 = avctx->flags2;
00772 s->unrestricted_mv = 1;
00773
00774 if (!s->context_initialized) {
00775 s->width = avctx->width;
00776 s->height = avctx->height;
00777 h->halfpel_flag = 1;
00778 h->thirdpel_flag = 1;
00779 h->unknown_svq3_flag = 0;
00780 h->chroma_qp[0] = h->chroma_qp[1] = 4;
00781
00782 if (MPV_common_init (s) < 0)
00783 return -1;
00784
00785 h->b_stride = 4*s->mb_width;
00786
00787 alloc_tables (h);
00788
00789
00790 extradata = (unsigned char *)avctx->extradata;
00791 for (m = 0; m < avctx->extradata_size; m++) {
00792 if (!memcmp (extradata, "SEQH", 4))
00793 break;
00794 extradata++;
00795 }
00796
00797
00798 if (extradata && !memcmp (extradata, "SEQH", 4)) {
00799
00800 GetBitContext gb;
00801
00802 size = AV_RB32(&extradata[4]);
00803 init_get_bits (&gb, extradata + 8, size*8);
00804
00805
00806 if (get_bits (&gb, 3) == 7) {
00807 skip_bits (&gb, 12);
00808 skip_bits (&gb, 12);
00809 }
00810
00811 h->halfpel_flag = get_bits1 (&gb);
00812 h->thirdpel_flag = get_bits1 (&gb);
00813
00814
00815 skip_bits1 (&gb);
00816 skip_bits1 (&gb);
00817 skip_bits1 (&gb);
00818 skip_bits1 (&gb);
00819
00820 s->low_delay = get_bits1 (&gb);
00821
00822
00823 skip_bits1 (&gb);
00824
00825 while (get_bits1 (&gb)) {
00826 skip_bits (&gb, 8);
00827 }
00828
00829 h->unknown_svq3_flag = get_bits1 (&gb);
00830 avctx->has_b_frames = !s->low_delay;
00831 }
00832 }
00833
00834
00835 if (buf_size == 0) {
00836 if (s->next_picture_ptr && !s->low_delay) {
00837 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
00838 *data_size = sizeof(AVFrame);
00839 }
00840 return 0;
00841 }
00842
00843 init_get_bits (&s->gb, buf, 8*buf_size);
00844
00845 s->mb_x = s->mb_y = 0;
00846
00847 if (svq3_decode_slice_header (h))
00848 return -1;
00849
00850 s->pict_type = h->slice_type;
00851 s->picture_number = h->slice_num;
00852
00853 if(avctx->debug&FF_DEBUG_PICT_INFO){
00854 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d\n",
00855 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
00856 s->adaptive_quant, s->qscale
00857 );
00858 }
00859
00860
00861 s->current_picture.pict_type = s->pict_type;
00862 s->current_picture.key_frame = (s->pict_type == I_TYPE);
00863
00864
00865 if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
00866
00867 if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
00868
00869 if (avctx->hurry_up >= 5) return 0;
00870 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
00871 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
00872 || avctx->skip_frame >= AVDISCARD_ALL)
00873 return 0;
00874
00875 if (s->next_p_frame_damaged) {
00876 if (s->pict_type == B_TYPE)
00877 return 0;
00878 else
00879 s->next_p_frame_damaged = 0;
00880 }
00881
00882 if (frame_start (h) < 0)
00883 return -1;
00884
00885 if (s->pict_type == B_TYPE) {
00886 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
00887
00888 if (h->frame_num_offset < 0) {
00889 h->frame_num_offset += 256;
00890 }
00891 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
00892 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
00893 return -1;
00894 }
00895 } else {
00896 h->prev_frame_num = h->frame_num;
00897 h->frame_num = h->slice_num;
00898 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
00899
00900 if (h->prev_frame_num_offset < 0) {
00901 h->prev_frame_num_offset += 256;
00902 }
00903 }
00904
00905 for(m=0; m<2; m++){
00906 int i;
00907 for(i=0; i<4; i++){
00908 int j;
00909 for(j=-1; j<4; j++)
00910 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
00911 if(i<3)
00912 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
00913 }
00914 }
00915
00916 for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
00917 for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
00918
00919 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
00920 ((get_bits_count(&s->gb) & 7) == 0 || show_bits (&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
00921
00922 skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
00923 s->gb.size_in_bits = 8*buf_size;
00924
00925 if (svq3_decode_slice_header (h))
00926 return -1;
00927
00928
00929 }
00930
00931 mb_type = svq3_get_ue_golomb (&s->gb);
00932
00933 if (s->pict_type == I_TYPE) {
00934 mb_type += 8;
00935 } else if (s->pict_type == B_TYPE && mb_type >= 4) {
00936 mb_type += 4;
00937 }
00938 if (mb_type > 33 || svq3_decode_mb (h, mb_type)) {
00939 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
00940 return -1;
00941 }
00942
00943 if (mb_type != 0) {
00944 hl_decode_mb (h);
00945 }
00946
00947 if (s->pict_type != B_TYPE && !s->low_delay) {
00948 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
00949 (s->pict_type == P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
00950 }
00951 }
00952
00953 ff_draw_horiz_band(s, 16*s->mb_y, 16);
00954 }
00955
00956 MPV_frame_end(s);
00957
00958 if (s->pict_type == B_TYPE || s->low_delay) {
00959 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
00960 } else {
00961 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
00962 }
00963
00964 avctx->frame_number = s->picture_number - 1;
00965
00966
00967 if (s->last_picture_ptr || s->low_delay) {
00968 *data_size = sizeof(AVFrame);
00969 }
00970
00971 return buf_size;
00972 }
00973
00974
00975 AVCodec svq3_decoder = {
00976 "svq3",
00977 CODEC_TYPE_VIDEO,
00978 CODEC_ID_SVQ3,
00979 sizeof(H264Context),
00980 decode_init,
00981 NULL,
00982 decode_end,
00983 svq3_decode_frame,
00984 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
00985 };