if (dx == 1) {        result = (result + imY[pres_y][max(0,min(maxold_x,x_pos))])/2;      }      else if (dx == 3) {        result = (result + imY[pres_y][max(0,min(maxold_x,x_pos+1))])/2;      }    }    else if (dx == 0) {      pres_x = max(0,min(maxold_x,x_pos));      for(y=-2;y<4;y++) {        pres_y = max(0,min(maxold_y,y_pos+y));        result += imY[pres_y][pres_x]*COEF[y+2];      }      result = max(0, min(255, (result+16)/32));      if (dy == 1) {        result = (result + imY[max(0,min(maxold_y,y_pos))][pres_x])/2;      }      else if (dy == 3) {        result = (result + imY[max(0,min(maxold_y,y_pos+1))][pres_x])/2;      }    }    else if (dx == 2) {      for(y=-2;y<4;y++) {        result = 0;        pres_y = max(0,min(maxold_y,y_pos+y));        for(x=-2;x<4;x++) {          pres_x = max(0,min(maxold_x,x_pos+x));          result += imY[pres_y][pres_x]*COEF[x+2];        }        tmp_res[y+2] = result;      }      result = 0;      for(y=-2;y<4;y++) {        result += tmp_res[y+2]*COEF[y+2];      }      result = max(0, min(255, (result+512)/1024));      if (dy == 1) {        result = (result + max(0, min(255, (tmp_res[2]+16)/32)))/2;      }      else if (dy == 3) {        result = (result + max(0, min(255, (tmp_res[3]+16)/32)))/2;      }    }    else if (dy == 2) {      for(x=-2;x<4;x++) {        result = 0;        pres_x = max(0,min(maxold_x,x_pos+x));        for(y=-2;y<4;y++) {          pres_y = max(0,min(maxold_y,y_pos+y));          result += imY[pres_y][pres_x]*COEF[y+2];        }        tmp_res[x+2] = result;      }      result = 0;      for(x=-2;x<4;x++) {        result += tmp_res[x+2]*COEF[x+2];      }      result = max(0, min(255, (result+512)/1024));      if (dx == 1) {        result = (result + max(0, min(255, (tmp_res[2]+16)/32)))/2;      }      else {        result = (result + max(0, min(255, (tmp_res[3]+16)/32)))/2;      }    }    else {      result = 0;      pres_y = dy == 1 ? y_pos : y_pos+1;      pres_y = max(0,min(maxold_y,pres_y));      for(x=-2;x<4;x++) {        pres_x = max(0,min(maxold_x,x_pos+x));        result += imY[pres_y][pres_x]*COEF[x+2];      }      result1 = max(0, min(255, (result+16)/32));      result = 0;      pres_x = dx == 1 ? x_pos : x_pos+1;      pres_x = max(0,min(maxold_x,pres_x));      for(y=-2;y<4;y++) {        pres_y = max(0,min(maxold_y,y_pos+y));        result += imY[pres_y][pres_x]*COEF[y+2];      }      result2 = max(0, min(255, (result+16)/32));      result = (result1+result2)/2;    }  }  return result;}  /*!  ************************************************************************************* * \brief *    Performs the simulation of the packet losses, calls the error concealment funcs *    and copies the decoded images to the reference frame buffers of the decoders  * ************************************************************************************* */void UpdateDecoders(){  int k;  for (k=0; k<input->NoOfDecoders; k++)  {    Build_Status_Map(status_map); // simulates the packet losses    Error_Concealment(decY_best[k], status_map, decref[k]); // for the moment error concealment is just a "copy"    // Move decoded frames to reference buffers: (at the decoders this is done     // without interpolation (upsampling) - upsampling is done while decoding    DecOneForthPix(decY_best[k], decref[k]);   }}/*!  ************************************************************************************* * \brief *    Copies one (reconstructed) image to the respective reference frame buffer * * \note *    This is used at the "many decoders in the encoder" * \param dY *    The reconstructed image * \param dref *    The reference buffer ************************************************************************************* */void DecOneForthPix(byte **dY, byte ***dref){  int j, ref=img->number%img->buf_cycle;  for (j=0; j<img->height; j++)    memcpy(dref[ref][j], dY[j], img->width);}/*!  ************************************************************************************* * \brief *    Gives the prediction residue for this MB. * * \param mode *    The encoding mode of this MB. ************************************************************************************* */void compute_residue(int mode){  int i,j;  if (mode == MBMODE_INTRA16x16)  /* Intra 16 MB*/    for (i=0; i<MB_BLOCK_SIZE; i++)      for (j=0; j<MB_BLOCK_SIZE; j++)        resY[j][i] = imgY[img->pix_y+j][img->pix_x+i]-img->mprr_2[mode][j][i]; /* SOS: Is this correct? or maybe mprr_2[][i][j] ??*/  else    for (i=0; i<MB_BLOCK_SIZE; i++)  /* Inter MB */      for (j=0; j<MB_BLOCK_SIZE; j++)        resY[j][i] = imgY[img->pix_y+j][img->pix_x+i]-img->mpr[i][j];}/*!  ************************************************************************************* * \brief *    Builds a random status map showing whether each MB is received or lost, based *    on the packet loss rate and the slice structure. * * \param s_map *    The status map to be filled ************************************************************************************* */void Build_Status_Map(byte **s_map){  int i,j,slice=-1,mb=0,jj,ii,packet_lost;  jj = img->height/MB_BLOCK_SIZE;  ii = img->width/MB_BLOCK_SIZE;  for (j=0 ; j<jj; j++)    for (i=0 ; i<ii; i++)    {      if (!input->slice_mode || img->mb_data[mb].slice_nr != slice) /* new slice */      {        if ((double)rand()/(double)RAND_MAX*100 < input->LossRate)          packet_lost=1;        else          packet_lost=0;                slice++;      }      if (packet_lost)        s_map[j][i]=0;      else        s_map[j][i]=1;      mb++;    }}/*!  ************************************************************************************* * \brief *    Performs some sort of error concealment for the areas that are lost according *    to the status_map *     * \param inY *    Error concealment is performed on this frame imY[][] * \param s_map *    The status map shows which areas are lost. * \param refY *    The set of reference frames - may be used for the error concealment. ************************************************************************************* */void Error_Concealment(byte **inY, byte **s_map, byte ***refY){  int mb_y, mb_x, mb_h, mb_w;  mb_h = img->height/MB_BLOCK_SIZE;  mb_w = img->width/MB_BLOCK_SIZE;    for (mb_y=0; mb_y < mb_h; mb_y++)    for (mb_x=0; mb_x < mb_w; mb_x++)      if (!s_map[mb_y][mb_x])        Conceal_Error(inY, mb_y, mb_x, refY);}/*!  ************************************************************************************* * \brief *    Copies a certain MB (mb_y,mb_x) of the frame inY[][] from the previous frame. *    For the time there is no better EC... ************************************************************************************* */void Conceal_Error(byte **inY, int mb_y, int mb_x, byte ***refY){  int i,j;  int ref_inx = (img->number-1)%img->no_multpred;  int pos_y = mb_y*MB_BLOCK_SIZE, pos_x = mb_x*MB_BLOCK_SIZE;  if (img->number)  {    for (j=0;j<MB_BLOCK_SIZE;j++)      for (i=0;i<MB_BLOCK_SIZE;i++)        inY[pos_y+j][pos_x+i] = refY[ref_inx][pos_y+j][pos_x+i];  }  else  {    for (j=0;j<MB_BLOCK_SIZE;j++)      for (i=0;i<MB_BLOCK_SIZE;i++)        inY[pos_y+j][pos_x+i] = 127;  }}