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