/* ------------------------------------------------------------------ * Copyright (C) 1998-2009 PacketVideo * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. * See the License for the specific language governing permissions * and limitations under the License. * ------------------------------------------------------------------- */ #include "mp4def.h" #include "mp4enc_lib.h" #include "mp4lib_int.h" #include "m4venc_oscl.h" //#define PRINT_MV #define MIN_GOP 1 /* minimum size of GOP, 1/23/01, need to be tested */ #define CANDIDATE_DISTANCE 0 /* distance candidate from one another to consider as a distinct one */ /* shouldn't be more than 3 */ #define ZERO_MV_PREF 0 /* 0: bias (0,0)MV before full-pel search, lowest complexity*/ /* 1: bias (0,0)MV after full-pel search, before half-pel, highest comp */ /* 2: bias (0,0)MV after half-pel, high comp, better PSNR */ #define RASTER_REFRESH /* instead of random INTRA refresh, do raster scan, 2/26/01 */ #ifdef RASTER_REFRESH #define TARGET_REFRESH_PER_REGION 4 /* , no. MB per frame to be INTRA refreshed */ #else #define TARGET_REFRESH_PER_REGION 1 /* , no. MB per region to be INTRA refreshed */ #endif #define ALL_CAND_EQUAL 10 /* any number greater than 5 will work */ #define NumPixelMB 256 /* number of pixels used in SAD calculation */ #define DEF_8X8_WIN 3 /* search region for 8x8 MVs around the 16x16 MV */ #define MB_Nb 256 #define PREF_NULL_VEC 129 /* for zero vector bias */ #define PREF_16_VEC 129 /* 1MV bias versus 4MVs*/ #define PREF_INTRA 512 /* bias for INTRA coding */ const static Int tab_exclude[9][9] = // [last_loc][curr_loc] { {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 1, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 1, 1, 1, 1}, {0, 0, 0, 0, 0, 0, 1, 1, 1}, {0, 1, 1, 0, 0, 0, 1, 1, 1}, {0, 1, 1, 0, 0, 0, 0, 0, 1}, {0, 1, 1, 1, 1, 0, 0, 0, 1}, {0, 0, 1, 1, 1, 0, 0, 0, 0}, {0, 0, 1, 1, 1, 1, 1, 0, 0} }; //to decide whether to continue or compute const static Int refine_next[8][2] = /* [curr_k][increment] */ { {0, 0}, {2, 0}, {1, 1}, {0, 2}, { -1, 1}, { -2, 0}, { -1, -1}, {0, -2} }; #ifdef __cplusplus extern "C" { #endif void MBMotionSearch(VideoEncData *video, UChar *cur, UChar *best_cand[], Int i0, Int j0, Int type_pred, Int fullsearch, Int *hp_guess); Int fullsearch(VideoEncData *video, Vol *currVol, UChar *ref, UChar *cur, Int *imin, Int *jmin, Int ilow, Int ihigh, Int jlow, Int jhigh); Int fullsearchBlk(VideoEncData *video, Vol *currVol, UChar *cent, UChar *cur, Int *imin, Int *jmin, Int ilow, Int ihigh, Int jlow, Int jhigh, Int range); void CandidateSelection(Int *mvx, Int *mvy, Int *num_can, Int imb, Int jmb, VideoEncData *video, Int type_pred); void RasterIntraUpdate(UChar *intraArray, UChar *Mode, Int totalMB, Int numRefresh); void ResetIntraUpdate(UChar *intraArray, Int totalMB); void ResetIntraUpdateRegion(UChar *intraArray, Int start_i, Int rwidth, Int start_j, Int rheight, Int mbwidth, Int mbheight); void MoveNeighborSAD(Int dn[], Int new_loc); Int FindMin(Int dn[]); void PrepareCurMB(VideoEncData *video, UChar *cur); #ifdef __cplusplus } #endif /***************************************/ /* 2/28/01, for HYPOTHESIS TESTING */ #ifdef HTFM /* defined in mp4def.h */ #ifdef __cplusplus extern "C" { #endif void CalcThreshold(double pf, double exp_lamda[], Int nrmlz_th[]); void HTFMPrepareCurMB(VideoEncData *video, HTFM_Stat *htfm_stat, UChar *cur); #ifdef __cplusplus } #endif #define HTFM_Pf 0.25 /* 3/2/1, probability of false alarm, can be varied from 0 to 0.5 */ /***************************************/ #endif #ifdef _SAD_STAT ULong num_MB = 0; ULong num_HP_MB = 0; ULong num_Blk = 0; ULong num_HP_Blk = 0; ULong num_cand = 0; ULong num_better_hp = 0; ULong i_dist_from_guess = 0; ULong j_dist_from_guess = 0; ULong num_hp_not_zero = 0; #endif /*================================================================== Function: MotionEstimation Date: 10/3/2000 Purpose: Go through all macroblock for motion search and determine scene change detection. ====================================================================*/ void MotionEstimation(VideoEncData *video) { UChar use_4mv = video->encParams->MV8x8_Enabled; Vol *currVol = video->vol[video->currLayer]; Vop *currVop = video->currVop; VideoEncFrameIO *currFrame = video->input; Int i, j, comp; Int mbwidth = currVol->nMBPerRow; Int mbheight = currVol->nMBPerCol; Int totalMB = currVol->nTotalMB; Int width = currFrame->pitch; UChar *mode_mb, *Mode = video->headerInfo.Mode; MOT *mot_mb, **mot = video->mot; UChar *intraArray = video->intraArray; Int FS_en = video->encParams->FullSearch_Enabled; void (*ComputeMBSum)(UChar *, Int, MOT *) = video->functionPointer->ComputeMBSum; void (*ChooseMode)(UChar*, UChar*, Int, Int) = video->functionPointer->ChooseMode; Int numIntra, start_i, numLoop, incr_i; Int mbnum, offset; UChar *cur, *best_cand[5]; Int sad8 = 0, sad16 = 0; Int totalSAD = 0; /* average SAD for rate control */ Int skip_halfpel_4mv; Int f_code_p, f_code_n, max_mag = 0, min_mag = 0; Int type_pred; Int xh[5] = {0, 0, 0, 0, 0}; Int yh[5] = {0, 0, 0, 0, 0}; /* half-pel */ UChar hp_mem4MV[17*17*4]; #ifdef HTFM /***** HYPOTHESIS TESTING ********/ /* 2/28/01 */ Int collect = 0; HTFM_Stat htfm_stat; double newvar[16]; double exp_lamda[15]; /*********************************/ #endif Int hp_guess = 0; #ifdef PRINT_MV FILE *fp_debug; #endif // FILE *fstat; // static int frame_num = 0; offset = 0; if (video->currVop->predictionType == I_VOP) { /* compute the SAV */ mbnum = 0; cur = currFrame->yChan; for (j = 0; j < mbheight; j++) { for (i = 0; i < mbwidth; i++) { video->mbnum = mbnum; mot_mb = mot[mbnum]; (*ComputeMBSum)(cur + (i << 4), width, mot_mb); totalSAD += mot_mb[0].sad; mbnum++; } cur += (width << 4); } video->sumMAD = (float)totalSAD / (float)NumPixelMB; ResetIntraUpdate(intraArray, totalMB); return ; } /* 09/20/05 */ if (video->prevBaseVop->padded == 0 && !video->encParams->H263_Enabled) { PaddingEdge(video->prevBaseVop); video->prevBaseVop->padded = 1; } /* Random INTRA update */ /* suggest to do it in CodeMB */ /* 2/21/2001 */ //if(video->encParams->RC_Type == CBR_1 || video->encParams->RC_Type == CBR_2) if (video->currLayer == 0 && video->encParams->Refresh) { RasterIntraUpdate(intraArray, Mode, totalMB, video->encParams->Refresh); } video->sad_extra_info = NULL; #ifdef HTFM /***** HYPOTHESIS TESTING ********/ /* 2/28/01 */ InitHTFM(video, &htfm_stat, newvar, &collect); /*********************************/ #endif if ((video->encParams->SceneChange_Det == 1) /*&& video->currLayer==0 */ && ((video->encParams->LayerFrameRate[0] < 5.0) || (video->numVopsInGOP > MIN_GOP))) /* do not try to detect a new scene if low frame rate and too close to previous I-frame */ { incr_i = 2; numLoop = 2; start_i = 1; type_pred = 0; /* for initial candidate selection */ } else { incr_i = 1; numLoop = 1; start_i = 0; type_pred = 2; } /* First pass, loop thru half the macroblock */ /* determine scene change */ /* Second pass, for the rest of macroblocks */ numIntra = 0; while (numLoop--) { for (j = 0; j < mbheight; j++) { if (incr_i > 1) start_i = (start_i == 0 ? 1 : 0) ; /* toggle 0 and 1 */ offset = width * (j << 4) + (start_i << 4); mbnum = j * mbwidth + start_i; for (i = start_i; i < mbwidth; i += incr_i) { video->mbnum = mbnum; mot_mb = mot[mbnum]; mode_mb = Mode + mbnum; cur = currFrame->yChan + offset; if (*mode_mb != MODE_INTRA) { #if defined(HTFM) HTFMPrepareCurMB(video, &htfm_stat, cur); #else PrepareCurMB(video, cur); #endif /************************************************************/ /******** full-pel 1MV and 4MVs search **********************/ #ifdef _SAD_STAT num_MB++; #endif MBMotionSearch(video, cur, best_cand, i << 4, j << 4, type_pred, FS_en, &hp_guess); #ifdef PRINT_MV fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a"); fprintf(fp_debug, "#%d (%d,%d,%d) : ", mbnum, mot_mb[0].x, mot_mb[0].y, mot_mb[0].sad); fprintf(fp_debug, "(%d,%d,%d) : (%d,%d,%d) : (%d,%d,%d) : (%d,%d,%d) : ==>\n", mot_mb[1].x, mot_mb[1].y, mot_mb[1].sad, mot_mb[2].x, mot_mb[2].y, mot_mb[2].sad, mot_mb[3].x, mot_mb[3].y, mot_mb[3].sad, mot_mb[4].x, mot_mb[4].y, mot_mb[4].sad); fclose(fp_debug); #endif sad16 = mot_mb[0].sad; #ifdef NO_INTER4V sad8 = sad16; #else sad8 = mot_mb[1].sad + mot_mb[2].sad + mot_mb[3].sad + mot_mb[4].sad; #endif /* choose between INTRA or INTER */ (*ChooseMode)(mode_mb, cur, width, ((sad8 < sad16) ? sad8 : sad16)); } else /* INTRA update, use for prediction 3/23/01 */ { mot_mb[0].x = mot_mb[0].y = 0; } if (*mode_mb == MODE_INTRA) { numIntra++ ; /* compute SAV for rate control and fast DCT, 11/28/00 */ (*ComputeMBSum)(cur, width, mot_mb); /* leave mot_mb[0] as it is for fast motion search */ /* set the 4 MVs to zeros */ for (comp = 1; comp <= 4; comp++) { mot_mb[comp].x = 0; mot_mb[comp].y = 0; } #ifdef PRINT_MV fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a"); fprintf(fp_debug, "\n"); fclose(fp_debug); #endif } else /* *mode_mb = MODE_INTER;*/ { if (video->encParams->HalfPel_Enabled) { #ifdef _SAD_STAT num_HP_MB++; #endif /* find half-pel resolution motion vector */ FindHalfPelMB(video, cur, mot_mb, best_cand[0], i << 4, j << 4, xh, yh, hp_guess); #ifdef PRINT_MV fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a"); fprintf(fp_debug, "(%d,%d), %d\n", mot_mb[0].x, mot_mb[0].y, mot_mb[0].sad); fclose(fp_debug); #endif skip_halfpel_4mv = ((sad16 - mot_mb[0].sad) <= (MB_Nb >> 1) + 1); sad16 = mot_mb[0].sad; #ifndef NO_INTER4V if (use_4mv && !skip_halfpel_4mv) { /* Also decide 1MV or 4MV !!!!!!!!*/ sad8 = FindHalfPelBlk(video, cur, mot_mb, sad16, best_cand, mode_mb, i << 4, j << 4, xh, yh, hp_mem4MV); #ifdef PRINT_MV fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a"); fprintf(fp_debug, " (%d,%d,%d) : (%d,%d,%d) : (%d,%d,%d) : (%d,%d,%d) \n", mot_mb[1].x, mot_mb[1].y, mot_mb[1].sad, mot_mb[2].x, mot_mb[2].y, mot_mb[2].sad, mot_mb[3].x, mot_mb[3].y, mot_mb[3].sad, mot_mb[4].x, mot_mb[4].y, mot_mb[4].sad); fclose(fp_debug); #endif } #endif /* NO_INTER4V */ } else /* HalfPel_Enabled ==0 */ { #ifndef NO_INTER4V //if(sad16 < sad8-PREF_16_VEC) if (sad16 - PREF_16_VEC > sad8) { *mode_mb = MODE_INTER4V; } #endif } #if (ZERO_MV_PREF==2) /* use mot_mb[7].sad as d0 computed in MBMotionSearch*/ /******************************************************/ if (mot_mb[7].sad - PREF_NULL_VEC < sad16 && mot_mb[7].sad - PREF_NULL_VEC < sad8) { mot_mb[0].sad = mot_mb[7].sad - PREF_NULL_VEC; mot_mb[0].x = mot_mb[0].y = 0; *mode_mb = MODE_INTER; } /******************************************************/ #endif if (*mode_mb == MODE_INTER) { if (mot_mb[0].x == 0 && mot_mb[0].y == 0) /* use zero vector */ mot_mb[0].sad += PREF_NULL_VEC; /* add back the bias */ mot_mb[1].sad = mot_mb[2].sad = mot_mb[3].sad = mot_mb[4].sad = (mot_mb[0].sad + 2) >> 2; mot_mb[1].x = mot_mb[2].x = mot_mb[3].x = mot_mb[4].x = mot_mb[0].x; mot_mb[1].y = mot_mb[2].y = mot_mb[3].y = mot_mb[4].y = mot_mb[0].y; } } /* find maximum magnitude */ /* compute average SAD for rate control, 11/28/00 */ if (*mode_mb == MODE_INTER) { #ifdef PRINT_MV fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a"); fprintf(fp_debug, "%d MODE_INTER\n", mbnum); fclose(fp_debug); #endif totalSAD += mot_mb[0].sad; if (mot_mb[0].x > max_mag) max_mag = mot_mb[0].x; if (mot_mb[0].y > max_mag) max_mag = mot_mb[0].y; if (mot_mb[0].x < min_mag) min_mag = mot_mb[0].x; if (mot_mb[0].y < min_mag) min_mag = mot_mb[0].y; } else if (*mode_mb == MODE_INTER4V) { #ifdef PRINT_MV fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a"); fprintf(fp_debug, "%d MODE_INTER4V\n", mbnum); fclose(fp_debug); #endif totalSAD += sad8; for (comp = 1; comp <= 4; comp++) { if (mot_mb[comp].x > max_mag) max_mag = mot_mb[comp].x; if (mot_mb[comp].y > max_mag) max_mag = mot_mb[comp].y; if (mot_mb[comp].x < min_mag) min_mag = mot_mb[comp].x; if (mot_mb[comp].y < min_mag) min_mag = mot_mb[comp].y; } } else /* MODE_INTRA */ { #ifdef PRINT_MV fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a"); fprintf(fp_debug, "%d MODE_INTRA\n", mbnum); fclose(fp_debug); #endif totalSAD += mot_mb[0].sad; } mbnum += incr_i; offset += (incr_i << 4); } } if (incr_i > 1 && numLoop) /* scene change on and first loop */ { //if(numIntra > ((totalMB>>3)<<1) + (totalMB>>3)) /* 75% of 50%MBs */ if (numIntra > (0.30*(totalMB / 2.0))) /* 15% of 50%MBs */ { /******** scene change detected *******************/ currVop->predictionType = I_VOP; M4VENC_MEMSET(Mode, MODE_INTRA, sizeof(UChar)*totalMB); /* set this for MB level coding*/ currVop->quantizer = video->encParams->InitQuantIvop[video->currLayer]; /* compute the SAV for rate control & fast DCT */ totalSAD = 0; offset = 0; mbnum = 0; cur = currFrame->yChan; for (j = 0; j < mbheight; j++) { for (i = 0; i < mbwidth; i++) { video->mbnum = mbnum; mot_mb = mot[mbnum]; (*ComputeMBSum)(cur + (i << 4), width, mot_mb); totalSAD += mot_mb[0].sad; mbnum++; } cur += (width << 4); } video->sumMAD = (float)totalSAD / (float)NumPixelMB; ResetIntraUpdate(intraArray, totalMB); /* video->numVopsInGOP=0; 3/13/01 move it to vop.c*/ return ; } } /******** no scene change, continue motion search **********************/ start_i = 0; type_pred++; /* second pass */ } video->sumMAD = (float)totalSAD / (float)NumPixelMB; /* avg SAD */ /* find f_code , 10/27/2000 */ f_code_p = 1; while ((max_mag >> (4 + f_code_p)) > 0) f_code_p++; f_code_n = 1; min_mag *= -1; while ((min_mag - 1) >> (4 + f_code_n) > 0) f_code_n++; currVop->fcodeForward = (f_code_p > f_code_n ? f_code_p : f_code_n); #ifdef HTFM /***** HYPOTHESIS TESTING ********/ /* 2/28/01 */ if (collect) { collect = 0; UpdateHTFM(video, newvar, exp_lamda, &htfm_stat); } /*********************************/ #endif return ; } #ifdef HTFM void InitHTFM(VideoEncData *video, HTFM_Stat *htfm_stat, double *newvar, Int *collect) { Int i; Int lx = video->currVop->width; // padding Int lx2 = lx << 1; Int lx3 = lx2 + lx; Int rx = video->currVop->pitch; Int rx2 = rx << 1; Int rx3 = rx2 + rx; Int *offset, *offset2; /* 4/11/01, collect data every 30 frames, doesn't have to be base layer */ if (((Int)video->numVopsInGOP) % 30 == 1) { *collect = 1; htfm_stat->countbreak = 0; htfm_stat->abs_dif_mad_avg = 0; for (i = 0; i < 16; i++) { newvar[i] = 0.0; } // video->functionPointer->SAD_MB_PADDING = &SAD_MB_PADDING_HTFM_Collect; video->functionPointer->SAD_Macroblock = &SAD_MB_HTFM_Collect; video->functionPointer->SAD_MB_HalfPel[0] = NULL; video->functionPointer->SAD_MB_HalfPel[1] = &SAD_MB_HP_HTFM_Collectxh; video->functionPointer->SAD_MB_HalfPel[2] = &SAD_MB_HP_HTFM_Collectyh; video->functionPointer->SAD_MB_HalfPel[3] = &SAD_MB_HP_HTFM_Collectxhyh; video->sad_extra_info = (void*)(htfm_stat); offset = htfm_stat->offsetArray; offset2 = htfm_stat->offsetRef; } else { // video->functionPointer->SAD_MB_PADDING = &SAD_MB_PADDING_HTFM; video->functionPointer->SAD_Macroblock = &SAD_MB_HTFM; video->functionPointer->SAD_MB_HalfPel[0] = NULL; video->functionPointer->SAD_MB_HalfPel[1] = &SAD_MB_HP_HTFMxh; video->functionPointer->SAD_MB_HalfPel[2] = &SAD_MB_HP_HTFMyh; video->functionPointer->SAD_MB_HalfPel[3] = &SAD_MB_HP_HTFMxhyh; video->sad_extra_info = (void*)(video->nrmlz_th); offset = video->nrmlz_th + 16; offset2 = video->nrmlz_th + 32; } offset[0] = 0; offset[1] = lx2 + 2; offset[2] = 2; offset[3] = lx2; offset[4] = lx + 1; offset[5] = lx3 + 3; offset[6] = lx + 3; offset[7] = lx3 + 1; offset[8] = lx; offset[9] = lx3 + 2; offset[10] = lx3 ; offset[11] = lx + 2 ; offset[12] = 1; offset[13] = lx2 + 3; offset[14] = lx2 + 1; offset[15] = 3; offset2[0] = 0; offset2[1] = rx2 + 2; offset2[2] = 2; offset2[3] = rx2; offset2[4] = rx + 1; offset2[5] = rx3 + 3; offset2[6] = rx + 3; offset2[7] = rx3 + 1; offset2[8] = rx; offset2[9] = rx3 + 2; offset2[10] = rx3 ; offset2[11] = rx + 2 ; offset2[12] = 1; offset2[13] = rx2 + 3; offset2[14] = rx2 + 1; offset2[15] = 3; return ; } void UpdateHTFM(VideoEncData *video, double *newvar, double *exp_lamda, HTFM_Stat *htfm_stat) { if (htfm_stat->countbreak == 0) htfm_stat->countbreak = 1; newvar[0] = (double)(htfm_stat->abs_dif_mad_avg) / (htfm_stat->countbreak * 16.); if (newvar[0] < 0.001) { newvar[0] = 0.001; /* to prevent floating overflow */ } exp_lamda[0] = 1 / (newvar[0] * 1.4142136); exp_lamda[1] = exp_lamda[0] * 1.5825; exp_lamda[2] = exp_lamda[0] * 2.1750; exp_lamda[3] = exp_lamda[0] * 3.5065; exp_lamda[4] = exp_lamda[0] * 3.1436; exp_lamda[5] = exp_lamda[0] * 3.5315; exp_lamda[6] = exp_lamda[0] * 3.7449; exp_lamda[7] = exp_lamda[0] * 4.5854; exp_lamda[8] = exp_lamda[0] * 4.6191; exp_lamda[9] = exp_lamda[0] * 5.4041; exp_lamda[10] = exp_lamda[0] * 6.5974; exp_lamda[11] = exp_lamda[0] * 10.5341; exp_lamda[12] = exp_lamda[0] * 10.0719; exp_lamda[13] = exp_lamda[0] * 12.0516; exp_lamda[14] = exp_lamda[0] * 15.4552; CalcThreshold(HTFM_Pf, exp_lamda, video->nrmlz_th); return ; } void CalcThreshold(double pf, double exp_lamda[], Int nrmlz_th[]) { Int i; double temp[15]; // printf("\nLamda: "); /* parametric PREMODELling */ for (i = 0; i < 15; i++) { // printf("%g ",exp_lamda[i]); if (pf < 0.5) temp[i] = 1 / exp_lamda[i] * M4VENC_LOG(2 * pf); else temp[i] = -1 / exp_lamda[i] * M4VENC_LOG(2 * (1 - pf)); } nrmlz_th[15] = 0; for (i = 0; i < 15; i++) /* scale upto no.pixels */ nrmlz_th[i] = (Int)(temp[i] * ((i + 1) << 4) + 0.5); return ; } void HTFMPrepareCurMB(VideoEncData *video, HTFM_Stat *htfm_stat, UChar *cur) { void* tmp = (void*)(video->currYMB); ULong *htfmMB = (ULong*)tmp; UChar *ptr, byte; Int *offset; Int i; ULong word; Int width = video->currVop->width; if (((Int)video->numVopsInGOP) % 30 == 1) { offset = htfm_stat->offsetArray; } else { offset = video->nrmlz_th + 16; } for (i = 0; i < 16; i++) { ptr = cur + offset[i]; word = ptr[0]; byte = ptr[4]; word |= (byte << 8); byte = ptr[8]; word |= (byte << 16); byte = ptr[12]; word |= (byte << 24); *htfmMB++ = word; word = *(ptr += (width << 2)); byte = ptr[4]; word |= (byte << 8); byte = ptr[8]; word |= (byte << 16); byte = ptr[12]; word |= (byte << 24); *htfmMB++ = word; word = *(ptr += (width << 2)); byte = ptr[4]; word |= (byte << 8); byte = ptr[8]; word |= (byte << 16); byte = ptr[12]; word |= (byte << 24); *htfmMB++ = word; word = *(ptr += (width << 2)); byte = ptr[4]; word |= (byte << 8); byte = ptr[8]; word |= (byte << 16); byte = ptr[12]; word |= (byte << 24); *htfmMB++ = word; } return ; } #endif void PrepareCurMB(VideoEncData *video, UChar *cur) { void* tmp = (void*)(video->currYMB); ULong *currYMB = (ULong*)tmp; Int i; Int width = video->currVop->width; cur -= width; for (i = 0; i < 16; i++) { *currYMB++ = *((ULong*)(cur += width)); *currYMB++ = *((ULong*)(cur + 4)); *currYMB++ = *((ULong*)(cur + 8)); *currYMB++ = *((ULong*)(cur + 12)); } return ; } /*================================================================== Function: MBMotionSearch Date: 09/06/2000 Purpose: Perform motion estimation for a macroblock. Find 1MV and 4MVs in half-pels resolutions. Using ST1 algorithm provided by Chalidabhongse and Kuo CSVT March'98. ==================================================================*/ void MBMotionSearch(VideoEncData *video, UChar *cur, UChar *best_cand[], Int i0, Int j0, Int type_pred, Int FS_en, Int *hp_guess) { Vol *currVol = video->vol[video->currLayer]; UChar *ref, *cand, *ncand = NULL, *cur8; void *extra_info = video->sad_extra_info; Int mbnum = video->mbnum; Int width = video->currVop->width; /* 6/12/01, must be multiple of 16 */ Int height = video->currVop->height; MOT **mot = video->mot; UChar use_4mv = video->encParams->MV8x8_Enabled; UChar h263_mode = video->encParams->H263_Enabled; Int(*SAD_Macroblock)(UChar*, UChar*, Int, void*) = video->functionPointer->SAD_Macroblock; Int(*SAD_Block)(UChar*, UChar*, Int, Int, void*) = video->functionPointer->SAD_Block; VideoEncParams *encParams = video->encParams; Int range = encParams->SearchRange; Int lx = video->currVop->pitch; /* padding */ Int comp; Int i, j, imin, jmin, ilow, ihigh, jlow, jhigh, iorg, jorg; Int d, dmin, dn[9]; #if (ZERO_MV_PREF==1) /* compute (0,0) MV at the end */ Int d0; #endif Int k; Int mvx[5], mvy[5], imin0, jmin0; Int num_can, center_again; Int last_loc, new_loc = 0; Int step, max_step = range >> 1; Int next; ref = video->forwardRefVop->yChan; /* origin of actual frame */ cur = video->currYMB; /* use smaller memory space for current MB */ /* find limit of the search (adjusting search range)*/ if (!h263_mode) { ilow = i0 - range; if (ilow < -15) ilow = -15; ihigh = i0 + range - 1; if (ihigh > width - 1) ihigh = width - 1; jlow = j0 - range; if (jlow < -15) jlow = -15; jhigh = j0 + range - 1; if (jhigh > height - 1) jhigh = height - 1; } else { ilow = i0 - range; if (ilow < 0) ilow = 0; ihigh = i0 + range - 1; if (ihigh > width - 16) ihigh = width - 16; jlow = j0 - range; if (jlow < 0) jlow = 0; jhigh = j0 + range - 1; if (jhigh > height - 16) jhigh = height - 16; } imin = i0; jmin = j0; /* needed for fullsearch */ ncand = ref + imin + jmin * lx; /* for first row of MB, fullsearch can be used */ if (FS_en) { *hp_guess = 0; /* no guess for fast half-pel */ dmin = fullsearch(video, currVol, ref, cur, &imin, &jmin, ilow, ihigh, jlow, jhigh); ncand = ref + imin + jmin * lx; mot[mbnum][0].sad = dmin; mot[mbnum][0].x = (imin - i0) << 1; mot[mbnum][0].y = (jmin - j0) << 1; imin0 = imin << 1; /* 16x16 MV in half-pel resolution */ jmin0 = jmin << 1; best_cand[0] = ncand; } else { /* 4/7/01, modified this testing for fullsearch the top row to only upto (0,3) MB */ /* upto 30% complexity saving with the same complexity */ if (video->forwardRefVop->predictionType == I_VOP && j0 == 0 && i0 <= 64 && type_pred != 1) { *hp_guess = 0; /* no guess for fast half-pel */ dmin = fullsearch(video, currVol, ref, cur, &imin, &jmin, ilow, ihigh, jlow, jhigh); ncand = ref + imin + jmin * lx; } else { /************** initialize candidate **************************/ /* find initial motion vector */ CandidateSelection(mvx, mvy, &num_can, i0 >> 4, j0 >> 4, video, type_pred); dmin = 65535; /* check if all are equal */ if (num_can == ALL_CAND_EQUAL) { i = i0 + mvx[0]; j = j0 + mvy[0]; if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh) { cand = ref + i + j * lx; d = (*SAD_Macroblock)(cand, cur, (dmin << 16) | lx, extra_info); if (d < dmin) { dmin = d; imin = i; jmin = j; ncand = cand; } } } else { /************** evaluate unique candidates **********************/ for (k = 0; k < num_can; k++) { i = i0 + mvx[k]; j = j0 + mvy[k]; if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh) { cand = ref + i + j * lx; d = (*SAD_Macroblock)(cand, cur, (dmin << 16) | lx, extra_info); if (d < dmin) { dmin = d; imin = i; jmin = j; ncand = cand; } else if ((d == dmin) && PV_ABS(mvx[k]) + PV_ABS(mvy[k]) < PV_ABS(i0 - imin) + PV_ABS(j0 - jmin)) { dmin = d; imin = i; jmin = j; ncand = cand; } } } } if (num_can == 0 || dmin == 65535) /* no candidate selected */ { ncand = ref + i0 + j0 * lx; /* use (0,0) MV as initial value */ mot[mbnum][7].sad = dmin = (*SAD_Macroblock)(ncand, cur, (65535 << 16) | lx, extra_info); #if (ZERO_MV_PREF==1) /* compute (0,0) MV at the end */ d0 = dmin; #endif imin = i0; jmin = j0; } #if (ZERO_MV_PREF==0) /* COMPUTE ZERO VECTOR FIRST !!!!!*/ dmin -= PREF_NULL_VEC; #endif /******************* local refinement ***************************/ center_again = 0; last_loc = new_loc = 0; // ncand = ref + jmin*lx + imin; /* center of the search */ step = 0; dn[0] = dmin; while (!center_again && step <= max_step) { MoveNeighborSAD(dn, last_loc); center_again = 1; i = imin; j = jmin - 1; cand = ref + i + j * lx; /* starting from [0,-1] */ /* spiral check one step at a time*/ for (k = 2; k <= 8; k += 2) { if (!tab_exclude[last_loc][k]) /* exclude last step computation */ { /* not already computed */ if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh) { d = (*SAD_Macroblock)(cand, cur, (dmin << 16) | lx, extra_info); dn[k] = d; /* keep it for half pel use */ if (d < dmin) { ncand = cand; dmin = d; imin = i; jmin = j; center_again = 0; new_loc = k; } else if ((d == dmin) && PV_ABS(i0 - i) + PV_ABS(j0 - j) < PV_ABS(i0 - imin) + PV_ABS(j0 - jmin)) { ncand = cand; imin = i; jmin = j; center_again = 0; new_loc = k; } } } if (k == 8) /* end side search*/ { if (!center_again) { k = -1; /* start diagonal search */ cand -= lx; j--; } } else { next = refine_next[k][0]; i += next; cand += next; next = refine_next[k][1]; j += next; cand += lx * next; } } last_loc = new_loc; step ++; } if (!center_again) MoveNeighborSAD(dn, last_loc); *hp_guess = FindMin(dn); } #if (ZERO_MV_PREF==1) /* compute (0,0) MV at the end */ if (d0 - PREF_NULL_VEC < dmin) { ncand = ref + i0 + j0 * lx; dmin = d0; imin = i0; jmin = j0; } #endif mot[mbnum][0].sad = dmin; mot[mbnum][0].x = (imin - i0) << 1; mot[mbnum][0].y = (jmin - j0) << 1; imin0 = imin << 1; /* 16x16 MV in half-pel resolution */ jmin0 = jmin << 1; best_cand[0] = ncand; } /* imin and jmin is the best 1 MV */ #ifndef NO_INTER4V /******************* Find 4 motion vectors ****************************/ if (use_4mv && !h263_mode) { #ifdef _SAD_STAT num_Blk += 4; #endif /* starting from the best 1MV */ //offset = imin + jmin*lx; iorg = i0; jorg = j0; for (comp = 0; comp < 4; comp++) { i0 = iorg + ((comp & 1) << 3); j0 = jorg + ((comp & 2) << 2); imin = (imin0 >> 1) + ((comp & 1) << 3); /* starting point from 16x16 MV */ jmin = (jmin0 >> 1) + ((comp & 2) << 2); ncand = ref + imin + jmin * lx; cur8 = cur + ((comp & 1) << 3) + (((comp & 2) << 2) << 4) ; /* 11/30/05, smaller cache */ /* find limit of the search (adjusting search range)*/ ilow = i0 - range; ihigh = i0 + range - 1 ;/* 4/9/01 */ if (ilow < -15) ilow = -15; if (ihigh > width - 1) ihigh = width - 1; jlow = j0 - range; jhigh = j0 + range - 1 ;/* 4/9/01 */ if (jlow < -15) jlow = -15; if (jhigh > height - 1) jhigh = height - 1; SAD_Block = video->functionPointer->SAD_Block; if (FS_en) /* fullsearch enable, center around 16x16 MV */ { dmin = fullsearchBlk(video, currVol, ncand, cur8, &imin, &jmin, ilow, ihigh, jlow, jhigh, range); ncand = ref + imin + jmin * lx; mot[mbnum][comp+1].sad = dmin; mot[mbnum][comp+1].x = (imin - i0) << 1; mot[mbnum][comp+1].y = (jmin - j0) << 1; best_cand[comp+1] = ncand; } else /* no fullsearch, do local search */ { /* starting point from 16x16 */ dmin = (*SAD_Block)(ncand, cur8, 65536, lx, extra_info); /******************* local refinement ***************************/ center_again = 0; last_loc = 0; while (!center_again) { center_again = 1; i = imin; j = jmin - 1; cand = ref + i + j * lx; /* starting from [0,-1] */ /* spiral check one step at a time*/ for (k = 2; k <= 8; k += 2) { if (!tab_exclude[last_loc][k]) /* exclude last step computation */ { /* not already computed */ if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh) { d = (*SAD_Block)(cand, cur8, dmin, lx, extra_info); if (d < dmin) { ncand = cand; dmin = d; imin = i; jmin = j; center_again = 0; new_loc = k; } else if ((d == dmin) && PV_ABS(i0 - i) + PV_ABS(j0 - j) < PV_ABS(i0 - imin) + PV_ABS(j0 - jmin)) { ncand = cand; imin = i; jmin = j; center_again = 0; new_loc = k; } } } if (k == 8) /* end side search*/ { if (!center_again) { k = -1; /* start diagonal search */ if (j <= height - 1 && j > 0) cand -= lx; j--; } } else { next = refine_next[k][0]; cand += next; i += next; next = refine_next[k][1]; cand += lx * next; j += next; } } last_loc = new_loc; } mot[mbnum][comp+1].sad = dmin; mot[mbnum][comp+1].x = (imin - i0) << 1; mot[mbnum][comp+1].y = (jmin - j0) << 1; best_cand[comp+1] = ncand; } /********************************************/ } } else #endif /* NO_INTER4V */ { mot[mbnum][1].sad = mot[mbnum][2].sad = mot[mbnum][3].sad = mot[mbnum][4].sad = (dmin + 2) >> 2; mot[mbnum][1].x = mot[mbnum][2].x = mot[mbnum][3].x = mot[mbnum][4].x = mot[mbnum][0].x; mot[mbnum][1].y = mot[mbnum][2].y = mot[mbnum][3].y = mot[mbnum][4].y = mot[mbnum][0].y; best_cand[1] = best_cand[2] = best_cand[3] = best_cand[4] = ncand; } return ; } /*=============================================================================== Function: fullsearch Date: 09/16/2000 Purpose: Perform full-search motion estimation over the range of search region in a spiral-outward manner. Input/Output: VideoEncData, current Vol, previou Vop, pointer to the left corner of current VOP, current coord (also output), boundaries. ===============================================================================*/ Int fullsearch(VideoEncData *video, Vol *currVol, UChar *prev, UChar *cur, Int *imin, Int *jmin, Int ilow, Int ihigh, Int jlow, Int jhigh) { Int range = video->encParams->SearchRange; UChar *cand; Int i, j, k, l; Int d, dmin; Int i0 = *imin; /* current position */ Int j0 = *jmin; Int(*SAD_Macroblock)(UChar*, UChar*, Int, void*) = video->functionPointer->SAD_Macroblock; void *extra_info = video->sad_extra_info; // UChar h263_mode = video->encParams->H263_Enabled; Int lx = video->currVop->pitch; /* with padding */ Int offset = i0 + j0 * lx; OSCL_UNUSED_ARG(currVol); cand = prev + offset; dmin = (*SAD_Macroblock)(cand, cur, (65535 << 16) | lx, (void*)extra_info) - PREF_NULL_VEC; /* perform spiral search */ for (k = 1; k <= range; k++) { i = i0 - k; j = j0 - k; cand = prev + i + j * lx; for (l = 0; l < 8*k; l++) { /* no need for boundary checking again */ if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh) { d = (*SAD_Macroblock)(cand, cur, (dmin << 16) | lx, (void*)extra_info); if (d < dmin) { dmin = d; *imin = i; *jmin = j; } else if ((d == dmin) && PV_ABS(i0 - i) + PV_ABS(j0 - j) < PV_ABS(i0 - *imin) + PV_ABS(j0 - *jmin)) { dmin = d; *imin = i; *jmin = j; } } if (l < (k << 1)) { i++; cand++; } else if (l < (k << 2)) { j++; cand += lx; } else if (l < ((k << 2) + (k << 1))) { i--; cand--; } else { j--; cand -= lx; } } } return dmin; } #ifndef NO_INTER4V /*=============================================================================== Function: fullsearchBlk Date: 01/9/2001 Purpose: Perform full-search motion estimation of an 8x8 block over the range of search region in a spiral-outward manner centered at the 16x16 MV. Input/Output: VideoEncData, MB coordinate, pointer to the initial MV on the reference, pointer to coor of current block, search range. ===============================================================================*/ Int fullsearchBlk(VideoEncData *video, Vol *currVol, UChar *cent, UChar *cur, Int *imin, Int *jmin, Int ilow, Int ihigh, Int jlow, Int jhigh, Int range) { UChar *cand, *ref; Int i, j, k, l, istart, jstart; Int d, dmin; Int lx = video->currVop->pitch; /* with padding */ Int(*SAD_Block)(UChar*, UChar*, Int, Int, void*) = video->functionPointer->SAD_Block; void *extra_info = video->sad_extra_info; OSCL_UNUSED_ARG(currVol); /* starting point centered at 16x16 MV */ ref = cent; istart = *imin; jstart = *jmin; dmin = (*SAD_Block)(ref, cur, 65536, lx, (void*)extra_info); cand = ref; /* perform spiral search */ for (k = 1; k <= range; k++) { i = istart - k; j = jstart - k; cand -= (lx + 1); /* candidate region */ for (l = 0; l < 8*k; l++) { /* no need for boundary checking again */ if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh) { d = (*SAD_Block)(cand, cur, dmin, lx, (void*)extra_info); if (d < dmin) { dmin = d; *imin = i; *jmin = j; } else if ((d == dmin) && PV_ABS(istart - i) + PV_ABS(jstart - j) < PV_ABS(istart - *imin) + PV_ABS(jstart - *jmin)) { dmin = d; *imin = i; *jmin = j; } } if (l < (k << 1)) { i++; cand++; } else if (l < (k << 2)) { j++; cand += lx; } else if (l < ((k << 2) + (k << 1))) { i--; cand--; } else { j--; cand -= lx; } } } return dmin; } #endif /* NO_INTER4V */ /*=============================================================================== Function: CandidateSelection Date: 09/16/2000 Purpose: Fill up the list of candidate using spatio-temporal correlation among neighboring blocks. Input/Output: type_pred = 0: first pass, 1: second pass, or no SCD Modified: 09/23/01, get rid of redundant candidates before passing back. ===============================================================================*/ void CandidateSelection(Int *mvx, Int *mvy, Int *num_can, Int imb, Int jmb, VideoEncData *video, Int type_pred) { MOT **mot = video->mot; MOT *pmot; Int mbnum = video->mbnum; Vol *currVol = video->vol[video->currLayer]; Int mbwidth = currVol->nMBPerRow; Int mbheight = currVol->nMBPerCol; Int i, j, same, num1; *num_can = 0; if (video->forwardRefVop->predictionType == P_VOP) { /* Spatio-Temporal Candidate (five candidates) */ if (type_pred == 0) /* first pass */ { pmot = &mot[mbnum][0]; /* same coordinate previous frame */ mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; if (imb >= (mbwidth >> 1) && imb > 0) /*left neighbor previous frame */ { pmot = &mot[mbnum-1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } else if (imb + 1 < mbwidth) /*right neighbor previous frame */ { pmot = &mot[mbnum+1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (jmb < mbheight - 1) /*bottom neighbor previous frame */ { pmot = &mot[mbnum+mbwidth][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } else if (jmb > 0) /*upper neighbor previous frame */ { pmot = &mot[mbnum-mbwidth][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (imb > 0 && jmb > 0) /* upper-left neighbor current frame*/ { pmot = &mot[mbnum-mbwidth-1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (jmb > 0 && imb < mbheight - 1) /* upper right neighbor current frame*/ { pmot = &mot[mbnum-mbwidth+1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } } else /* second pass */ /* original ST1 algorithm */ { pmot = &mot[mbnum][0]; /* same coordinate previous frame */ mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; if (imb > 0) /*left neighbor current frame */ { pmot = &mot[mbnum-1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (jmb > 0) /*upper neighbor current frame */ { pmot = &mot[mbnum-mbwidth][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (imb < mbwidth - 1) /*right neighbor previous frame */ { pmot = &mot[mbnum+1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (jmb < mbheight - 1) /*bottom neighbor previous frame */ { pmot = &mot[mbnum+mbwidth][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } } } else /* only Spatial Candidate (four candidates)*/ { if (type_pred == 0) /*first pass*/ { if (imb > 1) /* neighbor two blocks away to the left */ { pmot = &mot[mbnum-2][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (imb > 0 && jmb > 0) /* upper-left neighbor */ { pmot = &mot[mbnum-mbwidth-1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (jmb > 0 && imb < mbheight - 1) /* upper right neighbor */ { pmot = &mot[mbnum-mbwidth+1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } } //#ifdef SCENE_CHANGE_DETECTION /* second pass (ST2 algorithm)*/ else if (type_pred == 1) /* 4/7/01 */ { if (imb > 0) /*left neighbor current frame */ { pmot = &mot[mbnum-1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (jmb > 0) /*upper neighbor current frame */ { pmot = &mot[mbnum-mbwidth][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (imb < mbwidth - 1) /*right neighbor current frame */ { pmot = &mot[mbnum+1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } if (jmb < mbheight - 1) /*bottom neighbor current frame */ { pmot = &mot[mbnum+mbwidth][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } } //#else else /* original ST1 algorithm */ { if (imb > 0) /*left neighbor current frame */ { pmot = &mot[mbnum-1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; if (jmb > 0) /*upper-left neighbor current frame */ { pmot = &mot[mbnum-mbwidth-1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } } if (jmb > 0) /*upper neighbor current frame */ { pmot = &mot[mbnum-mbwidth][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; if (imb < mbheight - 1) /*upper-right neighbor current frame */ { pmot = &mot[mbnum-mbwidth+1][0]; mvx[(*num_can)] = (pmot->x) >> 1; mvy[(*num_can)++] = (pmot->y) >> 1; } } } //#endif } /* 3/23/01, remove redundant candidate (possible k-mean) */ num1 = *num_can; *num_can = 1; for (i = 1; i < num1; i++) { same = 0; j = 0; while (!same && j < *num_can) { #if (CANDIDATE_DISTANCE==0) if (mvx[i] == mvx[j] && mvy[i] == mvy[j]) #else // modified k-mean, 3/24/01, shouldn't be greater than 3 if (PV_ABS(mvx[i] - mvx[j]) + PV_ABS(mvy[i] - mvy[j]) < CANDIDATE_DISTANCE) #endif same = 1; j++; } if (!same) { mvx[*num_can] = mvx[i]; mvy[*num_can] = mvy[i]; (*num_can)++; } } #ifdef _SAD_STAT num_cand += (*num_can); #endif if (num1 == 5 && *num_can == 1) *num_can = ALL_CAND_EQUAL; /* all are equal */ return ; } /*=========================================================================== Function: RasterIntraUpdate Date: 2/26/01 Purpose: To raster-scan assign INTRA-update . N macroblocks are updated (also was programmable). ===========================================================================*/ void RasterIntraUpdate(UChar *intraArray, UChar *Mode, Int totalMB, Int numRefresh) { Int indx, i; /* find the last refresh MB */ indx = 0; while (indx < totalMB && intraArray[indx] == 1) indx++; /* add more */ for (i = 0; i < numRefresh && indx < totalMB; i++) { Mode[indx] = MODE_INTRA; intraArray[indx++] = 1; } /* if read the end of frame, reset and loop around */ if (indx >= totalMB - 1) { ResetIntraUpdate(intraArray, totalMB); indx = 0; while (i < numRefresh && indx < totalMB) { intraArray[indx] = 1; Mode[indx++] = MODE_INTRA; i++; } } return ; } /*=========================================================================== Function: ResetIntraUpdate Date: 11/28/00 Purpose: Reset already intra updated flags to all zero ===========================================================================*/ void ResetIntraUpdate(UChar *intraArray, Int totalMB) { M4VENC_MEMSET(intraArray, 0, sizeof(UChar)*totalMB); return ; } /*=========================================================================== Function: ResetIntraUpdateRegion Date: 12/1/00 Purpose: Reset already intra updated flags in one region to all zero ===========================================================================*/ void ResetIntraUpdateRegion(UChar *intraArray, Int start_i, Int rwidth, Int start_j, Int rheight, Int mbwidth, Int mbheight) { Int indx, j; if (start_i + rwidth >= mbwidth) rwidth = mbwidth - start_i; if (start_j + rheight >= mbheight) rheight = mbheight - start_j; for (j = start_j; j < start_j + rheight; j++) { indx = j * mbwidth; M4VENC_MEMSET(intraArray + indx + start_i, 0, sizeof(UChar)*rwidth); } return ; } /************************************************************* Function: MoveNeighborSAD Date: 3/27/01 Purpose: Move neighboring SAD around when center has shifted *************************************************************/ void MoveNeighborSAD(Int dn[], Int new_loc) { Int tmp[9]; tmp[0] = dn[0]; tmp[1] = dn[1]; tmp[2] = dn[2]; tmp[3] = dn[3]; tmp[4] = dn[4]; tmp[5] = dn[5]; tmp[6] = dn[6]; tmp[7] = dn[7]; tmp[8] = dn[8]; dn[0] = dn[1] = dn[2] = dn[3] = dn[4] = dn[5] = dn[6] = dn[7] = dn[8] = 65536; switch (new_loc) { case 0: break; case 1: dn[4] = tmp[2]; dn[5] = tmp[0]; dn[6] = tmp[8]; break; case 2: dn[4] = tmp[3]; dn[5] = tmp[4]; dn[6] = tmp[0]; dn[7] = tmp[8]; dn[8] = tmp[1]; break; case 3: dn[6] = tmp[4]; dn[7] = tmp[0]; dn[8] = tmp[2]; break; case 4: dn[1] = tmp[2]; dn[2] = tmp[3]; dn[6] = tmp[5]; dn[7] = tmp[6]; dn[8] = tmp[0]; break; case 5: dn[1] = tmp[0]; dn[2] = tmp[4]; dn[8] = tmp[6]; break; case 6: dn[1] = tmp[8]; dn[2] = tmp[0]; dn[3] = tmp[4]; dn[4] = tmp[5]; dn[8] = tmp[7]; break; case 7: dn[2] = tmp[8]; dn[3] = tmp[0]; dn[4] = tmp[6]; break; case 8: dn[2] = tmp[1]; dn[3] = tmp[2]; dn[4] = tmp[0]; dn[5] = tmp[6]; dn[6] = tmp[7]; break; } dn[0] = tmp[new_loc]; return ; } /* 3/28/01, find minimal of dn[9] */ Int FindMin(Int dn[]) { Int min, i; Int dmin; dmin = dn[1]; min = 1; for (i = 2; i < 9; i++) { if (dn[i] < dmin) { dmin = dn[i]; min = i; } } return min; }