bsumsq.c

Motion JPEG编解码器源代码

	bL = vec_add(bL, tL);                                               

	/* (unsigned short[]) pbb[0-7] */  
	vu8(tH) = vec_mergeh(zero, vbb);   
			
	/* (unsigned short[]) pbb[8-15] */ 
	vu8(tL) = vec_mergel(zero, vbb);   

	/* (pb[i]+pba[i]) + pbb[i] */                                       
	bH = vec_add(bH, tH);                                                
	bL = vec_add(bL, tL);                                                
			
	/* (unsigned short[]) pbc[0-7] */  
	vu8(tH) = vec_mergeh(zero, vbc);   
			
	/* (unsigned short[]) pbc[8-15] */ 
	vu8(tL) = vec_mergel(zero, vbc);   

	/* (pb[i]+pba[i]+pbb[i]) + pbc[i] */
	bH = vec_add(bH, tH);                                                
	bL = vec_add(bL, tL);                                                

							
	/* (pb[i]+pba[i]+pbb[i]+pbc[i]) + 2 */
	bH = vec_add(bH, two);                                                
	bL = vec_add(bL, two);                                                
							
	/* (pb[i]+pba[i]+pbb[i]+pbc[i]+2) >> 2 */
	bH = vec_sra(bH, two);                                                
	bL = vec_sra(bL, two);                                                



	/* ((pf[i]+pfa[i]+pfb[i]+pfc[i]+2)>>2) +
	 * ((pb[i]+pba[i]+pbb[i]+pbc[i]+2)>>2)
         */
	tH = vec_add(fH, bH);                                                
	tL = vec_add(fL, bL);                                                


	/* (((pf[i]+pfa[i]+pfb[i]+pfc[i]+2)>>2)+
	 *  ((pb[i]+pba[i]+pbb[i]+pbc[i]+2)>>2)) + 1
         */
	tH = vec_add(tH, one);                                                
	tL = vec_add(tL, one);                                                
							

	/* (((pf[i]+pfa[i]+pfb[i]+pfc[i]+2)>>2)+
	 *  ((pb[i]+pba[i]+pbb[i]+pbc[i]+2)>>2)+1) >> 1
         */
	tH = vec_sra(tH, one);                                                
	tL = vec_sra(tL, one);                                                


	/* absolute value increases parallelism (x16 instead of x8)
	 * since a bit isn't lost on the sign.
	 * 
	 * d = abs( ((((pf[i]+pfa[i]+pfb[i]+pfc[i]+2)>>2)+
	 *            ((pb[i]+pba[i]+pbb[i]+pbc[i]+2)>>2)+1)>>1) - p2[i] )
         */
	vu8(tH) = vec_packsu(tH, tL);                                         
	min = vec_min(vu8(tH), lR);                                           
	max = vec_max(vu8(tH), lR);                                           
	dif = vec_sub(max, min);                                              
							
	/* sum += (d * d) */                                                   
	sum = vec_msum(dif, dif, sum);                                        

    } while (--i);


    vf = vec_perm(vfb, vfc, permF0);
    vfa = vec_perm(vfb, vfc, permF1);
    vfb = vec_perm(l0, l1, permF0);
    vfc = vec_perm(l0, l1, permF1);

    vbb = vec_ld(0, pb);	 /* use vbb & vbc as temp for vb & vba */
    vbc = vec_ld(16, pb);
    l0 = vec_ld(0, pby);
    l1 = vec_ld(16, pby);


    /* (unsigned short[]) pf[0-7] */    
    vu8(fH) = vec_mergeh(zero, vf);   
			
    /* (unsigned short[]) pf[8-15] */   
    vu8(fL) = vec_mergel(zero, vf);   
			
    /* (unsigned short[]) pfa[0-7] */    
    vu8(tH) = vec_mergeh(zero, vfa);   
			
    /* (unsigned short[]) pfa[8-15] */   
    vu8(tL) = vec_mergel(zero, vfa);   

    /* pf[i] + pfa[i] */                                                 
    fH = vec_add(fH, tH);                                               
    fL = vec_add(fL, tL);                                               

    /* (unsigned short[]) pfb[0-7] */  
    vu8(tH) = vec_mergeh(zero, vfb);   
			
    /* (unsigned short[]) pfb[8-15] */ 
    vu8(tL) = vec_mergel(zero, vfb);   

    /* (pf[i]+pfa[i]) + pfb[i] */                                       
    fH = vec_add(fH, tH);                                                
    fL = vec_add(fL, tL);                                                
			
    /* (unsigned short[]) pfc[0-7] */  
    vu8(tH) = vec_mergeh(zero, vfc);   
			
    /* (unsigned short[]) pfc[8-15] */ 
    vu8(tL) = vec_mergel(zero, vfc);   

    /* (pf[i]+pfa[i]+pfb[i]) + pfc[i] */
    fH = vec_add(fH, tH);                                                
    fL = vec_add(fL, tL);                                                

							
    /* (pf[i]+pfa[i]+pfb[i]+pfc[i]) + 2 */
    fH = vec_add(fH, two);                                                
    fL = vec_add(fL, two);                                                
							
    /* (pf[i]+pfa[i]+pfb[i]+pfc[i]+2) >> 2 */
    fH = vec_sra(fH, two);                                                
    fL = vec_sra(fL, two);                                                


    lR = vec_ld(0, p2);


    vb = vec_perm(vbb, vbc, permB0);
    vba = vec_perm(vbb, vbc, permB1);
    vbb = vec_perm(l0, l1, permB0);
    vbc = vec_perm(l0, l1, permB1);


    /* (unsigned short[]) pb[0-7] */    
    vu8(bH) = vec_mergeh(zero, vb);   
			
    /* (unsigned short[]) pb[8-15] */   
    vu8(bL) = vec_mergel(zero, vb);   
			
    /* (unsigned short[]) pba[0-7] */    
    vu8(tH) = vec_mergeh(zero, vba);   
			
    /* (unsigned short[]) pba[8-15] */   
    vu8(tL) = vec_mergel(zero, vba);   

    /* pb[i] + pba[i] */                                                 
    bH = vec_add(bH, tH);                                               
    bL = vec_add(bL, tL);                                               

    /* (unsigned short[]) pbb[0-7] */  
    vu8(tH) = vec_mergeh(zero, vbb);   
			
    /* (unsigned short[]) pbb[8-15] */ 
    vu8(tL) = vec_mergel(zero, vbb);   

    /* (pb[i]+pba[i]) + pbb[i] */                                       
    bH = vec_add(bH, tH);                                                
    bL = vec_add(bL, tL);                                                
			
    /* (unsigned short[]) pbc[0-7] */  
    vu8(tH) = vec_mergeh(zero, vbc);   
			
    /* (unsigned short[]) pbc[8-15] */ 
    vu8(tL) = vec_mergel(zero, vbc);   

    /* (pb[i]+pba[i]+pbb[i]) + pbc[i] */
    bH = vec_add(bH, tH);                                                
    bL = vec_add(bL, tL);                                                

							
    /* (pb[i]+pba[i]+pbb[i]+pbc[i]) + 2 */
    bH = vec_add(bH, two);                                                
    bL = vec_add(bL, two);                                                
							
    /* (pb[i]+pba[i]+pbb[i]+pbc[i]+2) >> 2 */
    bH = vec_sra(bH, two);                                                
    bL = vec_sra(bL, two);                                                



    /* ((pf[i]+pfa[i]+pfb[i]+pfc[i]+2)>>2) +
     * ((pb[i]+pba[i]+pbb[i]+pbc[i]+2)>>2)
     */
    tH = vec_add(fH, bH);                                                
    tL = vec_add(fL, bL);                                                


    /* (((pf[i]+pfa[i]+pfb[i]+pfc[i]+2)>>2)+
     *  ((pb[i]+pba[i]+pbb[i]+pbc[i]+2)>>2)) + 1
     */
    tH = vec_add(tH, one);                                                
    tL = vec_add(tL, one);                                                
							

    /* (((pf[i]+pfa[i]+pfb[i]+pfc[i]+2)>>2)+
     *  ((pb[i]+pba[i]+pbb[i]+pbc[i]+2)>>2)+1) >> 1
     */
    tH = vec_sra(tH, one);                                                
    tL = vec_sra(tL, one);                                                
    

    /* absolute value increases parallelism (x16 instead of x8)
     * since a bit isn't lost on the sign.
     * 
     * d = abs( ((((pf[i]+pfa[i]+pfb[i]+pfc[i]+2)>>2)+
     *            ((pb[i]+pba[i]+pbb[i]+pbc[i]+2)>>2)+1)>>1) - p2[i] )
     */
    vu8(tH) = vec_packsu(tH, tL);                                         
    min = vec_min(vu8(tH), lR);                                           
    max = vec_max(vu8(tH), lR);                                           
    dif = vec_sub(max, min);                                              
							
    /* sum += (d * d) */                                                   
    sum = vec_msum(dif, dif, sum);                                        



    /* sum all parts of difference into one 32 bit quantity */
    vo.v = vec_sums(vs32(sum), vs32(zero));

    AMBER_STOP;

    return vo.s.sum;
}


#if ALTIVEC_TEST_FUNCTION(bsumsq)

#undef BENCHMARK_FREQUENCY
#define BENCHMARK_FREQUENCY  1000   /* benchmark every (n) calls */

ALTIVEC_TEST(bsumsq, int, (BSUMSQ_PDECL),
  "pf=0x%X, pb=0x%X, p2=0x%X, rowstride=%d, "
  "hxf=%d, hyf=%d, hxb=%d, hyb=%d, h=%d",
  BSUMSQ_ARGS);
#endif
/* vim:set foldmethod=marker foldlevel=0: */