interpolate8x8.cpp

一个用于智能手机的多媒体库适合S60 WinCE的跨平台开发库

      interpolate8x8_avg2(halfpel_v+8, src+1 + 8, halfpel_h+8, stride, rounding, 9);
      interpolate8x8_avg2(halfpel_v+8*stride, src+1 + 8*stride, halfpel_h+8*stride, stride, rounding, 9);
      interpolate8x8_avg2(halfpel_v+8*stride+8, src+1+8*stride+8, halfpel_h+8*stride+8, stride, rounding, 9);
      interpolate16x16_lowpass_v(dst, halfpel_v, stride, rounding);
      break;

   case 12:
      interpolate16x16_lowpass_v(halfpel_v, src, stride, rounding);
      interpolate8x8_avg2(dst, src+stride, halfpel_v, stride, rounding, 8);
      interpolate8x8_avg2(dst+8, src+stride+8, halfpel_v+8, stride, rounding, 8);
      interpolate8x8_avg2(dst+8*stride, src+stride+8*stride, halfpel_v+8*stride, stride, rounding, 8);
      interpolate8x8_avg2(dst+8*stride+8, src+stride+8*stride+8, halfpel_v+8*stride+8, stride, rounding, 8);
      break;

   case 13:
      interpolate16x16_lowpass_h(halfpel_h, src, stride, rounding);
      interpolate8x8_avg2(halfpel_v, src, halfpel_h, stride, rounding, 9);
      interpolate8x8_avg2(halfpel_v+8, src + 8, halfpel_h+8, stride, rounding, 9);
      interpolate8x8_avg2(halfpel_v+8*stride, src + 8*stride, halfpel_h+8*stride, stride, rounding, 9);
      interpolate8x8_avg2(halfpel_v+8*stride+8, src+8*stride+8, halfpel_h+8*stride+8, stride, rounding, 9);

      interpolate16x16_lowpass_v(halfpel_hv, halfpel_v, stride, rounding);
      interpolate8x8_avg2(dst, halfpel_hv, halfpel_v+stride, stride, rounding, 8);
      interpolate8x8_avg2(dst+8, halfpel_hv+8, halfpel_v+stride+8, stride, rounding, 8);
      interpolate8x8_avg2(dst+8*stride, halfpel_hv+8*stride, halfpel_v+stride+8*stride, stride, rounding, 8);
      interpolate8x8_avg2(dst+8*stride+8, halfpel_hv+8*stride+8, halfpel_v+stride+8*stride+8, stride, rounding, 8);
      break;

   case 14:
      interpolate16x16_lowpass_hv(halfpel_hv, halfpel_h, src, stride, rounding);
      interpolate8x8_avg2(dst, halfpel_h+stride, halfpel_hv, stride, rounding, 8);
      interpolate8x8_avg2(dst+8, halfpel_h+stride+8, halfpel_hv+8, stride, rounding, 8);
      interpolate8x8_avg2(dst+8*stride, halfpel_h+stride+8*stride, halfpel_hv+8*stride, stride, rounding, 8);
      interpolate8x8_avg2(dst+8*stride+8, halfpel_h+stride+8*stride+8, halfpel_hv+8*stride+8, stride, rounding, 8);
      break;

   case 15:
      interpolate16x16_lowpass_h(halfpel_h, src, stride, rounding);
      interpolate8x8_avg2(halfpel_v, src+1, halfpel_h, stride, rounding, 9);
      interpolate8x8_avg2(halfpel_v+8, src+1 + 8, halfpel_h+8, stride, rounding, 9);
      interpolate8x8_avg2(halfpel_v+8*stride, src+1 + 8*stride, halfpel_h+8*stride, stride, rounding, 9);
      interpolate8x8_avg2(halfpel_v+8*stride+8, src+1+8*stride+8, halfpel_h+8*stride+8, stride, rounding, 9);

      interpolate16x16_lowpass_v(halfpel_hv, halfpel_v, stride, rounding);
      interpolate8x8_avg2(dst, halfpel_hv, halfpel_v+stride, stride, rounding, 8);
      interpolate8x8_avg2(dst+8, halfpel_hv+8, halfpel_v+stride+8, stride, rounding, 8);
      interpolate8x8_avg2(dst+8*stride, halfpel_hv+8*stride, halfpel_v+stride+8*stride, stride, rounding, 8);
      interpolate8x8_avg2(dst+8*stride+8, halfpel_hv+8*stride+8, halfpel_v+stride+8*stride+8, stride, rounding, 8);
      break;
   }
}

//----------------------------

void interpolate8x8_avg2(byte *dst, const byte *src1, const byte *src2, dword stride, bool rounding, dword height){

   const int round = 1 - rounding;
   for(dword i = 0; i < height; i++){
      dst[0] = (src1[0] + src2[0] + round) >> 1;
      dst[1] = (src1[1] + src2[1] + round) >> 1;
      dst[2] = (src1[2] + src2[2] + round) >> 1;
      dst[3] = (src1[3] + src2[3] + round) >> 1;
      dst[4] = (src1[4] + src2[4] + round) >> 1;
      dst[5] = (src1[5] + src2[5] + round) >> 1;
      dst[6] = (src1[6] + src2[6] + round) >> 1;
      dst[7] = (src1[7] + src2[7] + round) >> 1;
      
      dst += stride;
      src1 += stride;
      src2 += stride;
   }
}

//----------------------------

#ifndef _ARM_

void interpolate8x8_halfpel_h(byte *dst, const byte *src, dword stride, bool rounding){

#if defined USE_ARM_ASM && 1
   int y, tmp, tmp1, tmp2, tmp3;
   if(rounding){
      asm volatile(
         "mov %7, #8\n\t"
      "\n.ihh_loop:\n\t"
         "ldrb %2, [%1, #8]\n\t"
                                 //7+8
         "ldrb %3, [%1, #7]\n\t"
         "add %4, %2, %3\n\t"
         "mov %4, %4, asr #1\n\t"
                                 //6+7
         "ldrb %2, [%1, #6]\n\t"
         "add %5, %2, %3\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"
                                 //5+6
         "ldrb %3, [%1, #5]\n\t"
         "add %5, %2, %3\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"
                                 //4+5
         "ldrb %2, [%1, #4]\n\t"
         "add %5, %2, %3\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"

         "str %4, [%0, #4]\n\t"

                                 //3+4
         "ldrb %3, [%1, #3]\n\t"
         "add %4, %2, %3\n\t"
         "mov %4, %4, asr #1\n\t"
                                 //2+3
         "ldrb %2, [%1, #2]\n\t"
         "add %5, %2, %3\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"
                                 //1+2
         "ldrb %3, [%1, #1]\n\t"
         "add %5, %2, %3\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"
                                 //0+1
         "ldrb %2, [%1, #0]\n\t"
         "add %5, %2, %3\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"

         "str %4, [%0, #0]\n\t"

         "add %0, %0, %6\n   add %1, %1, %6\n\t"
         "subs %7, %7, #1\n   bne .ihh_loop\n\t"
         : "+r"(dst), "+r"(src), "&=r"(tmp), "&=r"(tmp1), "&=r"(tmp2), "&=r"(tmp3)
         : "r"(stride), "%r"(y)
         );
   }else{
      asm volatile(
         "mov %7, #8\n\t"
      "\n.ihh_loop1:\n\t"
         "ldrb %2, [%1, #8]\n\t"
                                 //7+8
         "ldrb %3, [%1, #7]\n\t"
         "add %4, %2, %3\n\t"
         "add %4, %4, #1\n\t"
         "mov %4, %4, asr #1\n\t"
                                 //6+7
         "ldrb %2, [%1, #6]\n\t"
         "add %5, %2, %3\n\t"
         "add %5, %5, #1\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"
                                 //5+6
         "ldrb %3, [%1, #5]\n\t"
         "add %5, %2, %3\n\t"
         "add %5, %5, #1\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"
                                 //4+5
         "ldrb %2, [%1, #4]\n\t"
         "add %5, %2, %3\n\t"
         "add %5, %5, #1\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"

         "str %4, [%0, #4]\n\t"

                                 //3+4
         "ldrb %3, [%1, #3]\n\t"
         "add %4, %2, %3\n\t"
         "add %4, %4, #1\n\t"
         "mov %4, %4, asr #1\n\t"
                                 //2+3
         "ldrb %2, [%1, #2]\n\t"
         "add %5, %2, %3\n\t"
         "add %5, %5, #1\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"
                                 //1+2
         "ldrb %3, [%1, #1]\n\t"
         "add %5, %2, %3\n\t"
         "add %5, %5, #1\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"
                                 //0+1
         "ldrb %2, [%1, #0]\n\t"
         "add %5, %2, %3\n\t"
         "add %5, %5, #1\n\t"
         "mov %5, %5, asr #1\n\t"
         "orr %4, %5, %4, asl #8\n\t"

         "str %4, [%0, #0]\n\t"

         "add %0, %0, %6\n   add %1, %1, %6\n\t"
         "subs %7, %7, #1\n   bne .ihh_loop1\n\t"
         : "+r"(dst), "+r"(src), "&=r"(tmp), "&=r"(tmp1), "&=r"(tmp2), "&=r"(tmp3)
         : "r"(stride), "%r"(y)
         );
   }
#else
   if(rounding){
      for(dword j = 0; j < 8*stride; j+=stride){
         dst[j + 0] = byte((src[j + 0] + src[j + 1] )>>1);
         dst[j + 1] = byte((src[j + 1] + src[j + 2] )>>1);
         dst[j + 2] = byte((src[j + 2] + src[j + 3] )>>1);
         dst[j + 3] = byte((src[j + 3] + src[j + 4] )>>1);
         dst[j + 4] = byte((src[j + 4] + src[j + 5] )>>1);
         dst[j + 5] = byte((src[j + 5] + src[j + 6] )>>1);
         dst[j + 6] = byte((src[j + 6] + src[j + 7] )>>1);
         dst[j + 7] = byte((src[j + 7] + src[j + 8] )>>1);
      }
   }else{
      for(dword j = 0; j < 8*stride; j+=stride){
                              //forward or backwards? Who knows ...
         dst[j + 0] = byte((src[j + 0] + src[j + 1] + 1)>>1);
         dst[j + 1] = byte((src[j + 1] + src[j + 2] + 1)>>1);
         dst[j + 2] = byte((src[j + 2] + src[j + 3] + 1)>>1);
         dst[j + 3] = byte((src[j + 3] + src[j + 4] + 1)>>1);
         dst[j + 4] = byte((src[j + 4] + src[j + 5] + 1)>>1);
         dst[j + 5] = byte((src[j + 5] + src[j + 6] + 1)>>1);
         dst[j + 6] = byte((src[j + 6] + src[j + 7] + 1)>>1);
         dst[j + 7] = byte((src[j + 7] + src[j + 8] + 1)>>1);
      }
   }
#endif
}

#endif

//----------------------------

#ifndef _ARM_

void interpolate8x8_halfpel_v(byte *dst, const byte *src, dword stride, bool rounding){

#if defined USE_ARM_ASM && 1
   int y, tmp, tmp1, tmp2, tmp3, tmp4;
   if(rounding){
      asm volatile(
         "mov %7, #8\n\t"
      "\n.ihv_loop:\n\t"
         "add %5, %1, %6\n\t"
                                 //3
         "ldrb %2, [%1, #3]\n   ldrb %3, [%5, #3]\n\t"
         "add %4, %2, %3\n   mov %4, %4, asr #1\n\t"
                                 //2
         "ldrb %2, [%1, #2]\n   ldrb %3, [%5, #2]\n\t"
         "add %2, %2, %3\n   mov %2, %2, asr #1\n\t"
         "orr %4, %2, %4, asl #8\n\t"
                                 //1
         "ldrb %2, [%1, #1]\n   ldrb %3, [%5, #1]\n\t"
         "add %2, %2, %3\n   mov %2, %2, asr #1\n\t"
         "orr %4, %2, %4, asl #8\n\t"
                                 //0
         "ldrb %2, [%1, #0]\n   ldrb %3, [%5, #0]\n\t"
         "add %2, %2, %3\n   mov %2, %2, asr #1\n\t"
         "orr %4, %2, %4, asl #8\n\t"

         "str %4, [%0, #0]\n\t"

                                 //7
         "ldrb %2, [%1, #7]\n   ldrb %3, [%5, #7]\n\t"
         "add %4, %2, %3\n   mov %4, %4, asr #1\n\t"
                                 //6
         "ldrb %2, [%1, #6]\n   ldrb %3, [%5, #6]\n\t"
         "add %2, %2, %3\n   mov %2, %2, asr #1\n\t"
         "orr %4, %2, %4, asl #8\n\t"
                                 //5
         "ldrb %2, [%1, #5]\n   ldrb %3, [%5, #5]\n\t"
         "add %2, %2, %3\n   mov %2, %2, asr #1\n\t"
         "orr %4, %2, %4, asl #8\n\t"
                                 //4
         "ldrb %2, [%1, #4]\n   ldrb %3, [%5, #4]\n\t"
         "add %2, %2, %3\n   mov %2, %2, asr #1\n\t"
         "orr %4, %2, %4, asl #8\n\t"

         "str %4, [%0, #4]\n\t"

         "add %0, %0, %6\n   add %1, %1, %6\n\t"
         "subs %7, %7, #1\n   bne .ihv_loop\n\t"
         : "+r"(dst), "+r"(src), "&=r"(tmp), "&=r"(tmp1), "&=r"(tmp2), "&=r"(tmp3)
         : "r"(stride), "%r"(y)
         );
   }else{
      asm volatile(
         "mov %7, #8\n\t"
      "\n.ihv_loop1:\n\t"
         "add %5, %1, %6\n\t"
                                 //3
         "ldrb %2, [%1, #3]\n   ldrb %3, [%5, #3]\n\t"
         "add %4, %2, %3\n   add %4, %4, #1\n   mov %4, %4, asr #1\n\t"
                                 //2