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