MultiSource/Applications/ALAC/decode/dp_enc.c - third_party/llvm-test-suite - Git at Google

 /*
  * Copyright (c) 2011 Apple Inc. All rights reserved.
  *
  * @APPLE_APACHE_LICENSE_HEADER_START@
  *
  * 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.
  *
  * @APPLE_APACHE_LICENSE_HEADER_END@
  */

 /*
 	File:		dp_enc.c

 	Contains:	Dynamic Predictor encode routines

 	Copyright:	(c) 2001-2011 Apple, Inc.
 */

 #include "dplib.h"
 #include <string.h>

 #if __GNUC__
 #define ALWAYS_INLINE		__attribute__((always_inline))
 #else
 #define ALWAYS_INLINE
 #endif

 #if TARGET_CPU_PPC && (__MWERKS__ >= 0x3200)
 // align loops to a 16 byte boundary to make the G5 happy
 #pragma function_align 16
 #define LOOP_ALIGN			asm { align 16 }
 #else
 #define LOOP_ALIGN
 #endif

 void init_coefs( int16_t * coefs, uint32_t denshift, int32_t numPairs )
 {
 	int32_t		k;
 	int32_t		den = 1 << denshift;

 	coefs[0] = (AINIT * den) >> 4;
 	coefs[1] = (BINIT * den) >> 4;
 	coefs[2] = (CINIT * den) >> 4;
 	for ( k = 3; k < numPairs; k++ )
 		coefs[k]  = 0;
 }

 void copy_coefs( int16_t * srcCoefs, int16_t * dstCoefs, int32_t numPairs )
 {
 	int32_t k;

 	for ( k = 0; k < numPairs; k++ )
 		dstCoefs[k] = srcCoefs[k];
 }

 static inline int32_t ALWAYS_INLINE sign_of_int( int32_t i )
 {
     int32_t negishift;

     negishift = ((uint32_t)-i) >> 31;
     return negishift | (i >> 31);
 }

 void pc_block( int32_t * in, int32_t * pc1, int32_t num, int16_t * coefs, int32_t numactive, uint32_t chanbits, uint32_t denshift )
 {
 	register int16_t	a0, a1, a2, a3;
 	register int32_t	b0, b1, b2, b3;
 	int32_t					j, k, lim;
 	int32_t *			pin;
 	int32_t				sum1, dd;
 	int32_t				sg, sgn;
 	int32_t				top;
 	int32_t				del, del0;
 	uint32_t			chanshift = 32 - chanbits;
 	int32_t				denhalf = 1 << (denshift - 1);

 	pc1[0] = in[0];
 	if ( numactive == 0 )
 	{
 		// just copy if numactive == 0 (but don't bother if in/out pointers the same)
 		if ( (num > 1) && (in != pc1) )
 			memcpy( &pc1[1], &in[1], (num - 1) * sizeof(int32_t) );
 		return;
 	}
 	if ( numactive == 31 )
 	{
 		// short-circuit if numactive == 31
 		for( j = 1; j < num; j++ )
 		{
 			del = in[j] - in[j-1];
 			pc1[j] = (del << chanshift) >> chanshift;
 		}
 		return;
 	}

 	for ( j = 1; j <= numactive; j++ )
 	{
 		del = in[j] - in[j-1];
 		pc1[j] = (del << chanshift) >> chanshift;
 	}

 	lim = numactive + 1;

 	if ( numactive == 4 )
 	{
 		// optimization for numactive == 4
 		a0 = coefs[0];
 		a1 = coefs[1];
 		a2 = coefs[2];
 		a3 = coefs[3];

 		for ( j = lim; j < num; j++ )
 		{
 			LOOP_ALIGN

 			top = in[j - lim];
 			pin = in + j - 1;

 			b0 = top - pin[0];
 			b1 = top - pin[-1];
 			b2 = top - pin[-2];
 			b3 = top - pin[-3];

 			sum1 = (denhalf - a0 * b0 - a1 * b1 - a2 * b2 - a3 * b3) >> denshift;

 			del = in[j] - top - sum1;
 			del = (del << chanshift) >> chanshift;
 			pc1[j] = del;
 			del0 = del;

 			sg = sign_of_int(del);
 			if ( sg > 0 )
 			{
 				sgn = sign_of_int( b3 );
 				a3 -= sgn;
 				del0 -= (4 - 3) * ((sgn * b3) >> denshift);
 				if ( del0 <= 0 )
 					continue;

 				sgn = sign_of_int( b2 );
 				a2 -= sgn;
 				del0 -= (4 - 2) * ((sgn * b2) >> denshift);
 				if ( del0 <= 0 )
 					continue;

 				sgn = sign_of_int( b1 );
 				a1 -= sgn;
 				del0 -= (4 - 1) * ((sgn * b1) >> denshift);
 				if ( del0 <= 0 )
 					continue;

 				a0 -= sign_of_int( b0 );
 			}
 			else if ( sg < 0 )
 			{
 				// note: to avoid unnecessary negations, we flip the value of "sgn"
 				sgn = -sign_of_int( b3 );
 				a3 -= sgn;
 				del0 -= (4 - 3) * ((sgn * b3) >> denshift);
 				if ( del0 >= 0 )
 					continue;

 				sgn = -sign_of_int( b2 );
 				a2 -= sgn;
 				del0 -= (4 - 2) * ((sgn * b2) >> denshift);
 				if ( del0 >= 0 )
 					continue;

 				sgn = -sign_of_int( b1 );
 				a1 -= sgn;
 				del0 -= (4 - 1) * ((sgn * b1) >> denshift);
 				if ( del0 >= 0 )
 					continue;

 				a0 += sign_of_int( b0 );
 			}
 		}

 		coefs[0] = a0;
 		coefs[1] = a1;
 		coefs[2] = a2;
 		coefs[3] = a3;
 	}
 	else if ( numactive == 8 )
 	{
 		// optimization for numactive == 8
 		register int16_t	a4, a5, a6, a7;
 		register int32_t	b4, b5, b6, b7;

 		a0 = coefs[0];
 		a1 = coefs[1];
 		a2 = coefs[2];
 		a3 = coefs[3];
 		a4 = coefs[4];
 		a5 = coefs[5];
 		a6 = coefs[6];
 		a7 = coefs[7];

 		for ( j = lim; j < num; j++ )
 		{
 			LOOP_ALIGN

 			top = in[j - lim];
 			pin = in + j - 1;

 			b0 = top - (*pin--);
 			b1 = top - (*pin--);
 			b2 = top - (*pin--);
 			b3 = top - (*pin--);
 			b4 = top - (*pin--);
 			b5 = top - (*pin--);
 			b6 = top - (*pin--);
 			b7 = top - (*pin);
 			pin += 8;

 			sum1 = (denhalf - a0 * b0 - a1 * b1 - a2 * b2 - a3 * b3
 					- a4 * b4 - a5 * b5 - a6 * b6 - a7 * b7) >> denshift;

 			del = in[j] - top - sum1;
 			del = (del << chanshift) >> chanshift;
 			pc1[j] = del;
 			del0 = del;

 			sg = sign_of_int(del);
 			if ( sg > 0 )
 			{
 				sgn = sign_of_int( b7 );
 				a7 -= sgn;
 				del0 -= 1 * ((sgn * b7) >> denshift);
 				if ( del0 <= 0 )
 					continue;

 				sgn = sign_of_int( b6 );
 				a6 -= sgn;
 				del0 -= 2 * ((sgn * b6) >> denshift);
 				if ( del0 <= 0 )
 					continue;

 				sgn = sign_of_int( b5 );
 				a5 -= sgn;
 				del0 -= 3 * ((sgn * b5) >> denshift);
 				if ( del0 <= 0 )
 					continue;

 				sgn = sign_of_int( b4 );
 				a4 -= sgn;
 				del0 -= 4 * ((sgn * b4) >> denshift);
 				if ( del0 <= 0 )
 					continue;

 				sgn = sign_of_int( b3 );
 				a3 -= sgn;
 				del0 -= 5 * ((sgn * b3) >> denshift);
 				if ( del0 <= 0 )
 					continue;

 				sgn = sign_of_int( b2 );
 				a2 -= sgn;
 				del0 -= 6 * ((sgn * b2) >> denshift);
 				if ( del0 <= 0 )
 					continue;

 				sgn = sign_of_int( b1 );
 				a1 -= sgn;
 				del0 -= 7 * ((sgn * b1) >> denshift);
 				if ( del0 <= 0 )
 					continue;

 				a0 -= sign_of_int( b0 );
 			}
 			else if ( sg < 0 )
 			{
 				// note: to avoid unnecessary negations, we flip the value of "sgn"
 				sgn = -sign_of_int( b7 );
 				a7 -= sgn;
 				del0 -= 1 * ((sgn * b7) >> denshift);
 				if ( del0 >= 0 )
 					continue;

 				sgn = -sign_of_int( b6 );
 				a6 -= sgn;
 				del0 -= 2 * ((sgn * b6) >> denshift);
 				if ( del0 >= 0 )
 					continue;

 				sgn = -sign_of_int( b5 );
 				a5 -= sgn;
 				del0 -= 3 * ((sgn * b5) >> denshift);
 				if ( del0 >= 0 )
 					continue;

 				sgn = -sign_of_int( b4 );
 				a4 -= sgn;
 				del0 -= 4 * ((sgn * b4) >> denshift);
 				if ( del0 >= 0 )
 					continue;

 				sgn = -sign_of_int( b3 );
 				a3 -= sgn;
 				del0 -= 5 * ((sgn * b3) >> denshift);
 				if ( del0 >= 0 )
 					continue;

 				sgn = -sign_of_int( b2 );
 				a2 -= sgn;
 				del0 -= 6 * ((sgn * b2) >> denshift);
 				if ( del0 >= 0 )
 					continue;

 				sgn = -sign_of_int( b1 );
 				a1 -= sgn;
 				del0 -= 7 * ((sgn * b1) >> denshift);
 				if ( del0 >= 0 )
 					continue;

 				a0 += sign_of_int( b0 );
 			}
 		}

 		coefs[0] = a0;
 		coefs[1] = a1;
 		coefs[2] = a2;
 		coefs[3] = a3;
 		coefs[4] = a4;
 		coefs[5] = a5;
 		coefs[6] = a6;
 		coefs[7] = a7;
 	}
 	else
 	{
 //pc_block_general:
 		// general case
 		for ( j = lim; j < num; j++ )
 		{
 			LOOP_ALIGN

 			top = in[j - lim];
 			pin = in + j - 1;

 			sum1 = 0;
 			for ( k = 0; k < numactive; k++ )
 				sum1 -= coefs[k] * (top - pin[-k]);

 			del = in[j] - top - ((sum1 + denhalf) >> denshift);
 			del = (del << chanshift) >> chanshift;
 			pc1[j] = del;
 			del0 = del;

 			sg = sign_of_int( del );
 			if ( sg > 0 )
 			{
 				for ( k = (numactive - 1); k >= 0; k-- )
 				{
 					dd = top - pin[-k];
 					sgn = sign_of_int( dd );
 					coefs[k] -= sgn;
 					del0 -= (numactive - k) * ((sgn * dd) >> denshift);
 					if ( del0 <= 0 )
 						break;
 				}
 			}
 			else if ( sg < 0 )
 			{
 				for ( k = (numactive - 1); k >= 0; k-- )
 				{
 					dd = top - pin[-k];
 					sgn = sign_of_int( dd );
 					coefs[k] += sgn;
 					del0 -= (numactive - k) * ((-sgn * dd) >> denshift);
 					if ( del0 >= 0 )
 						break;
 				}
 			}
 		}
 	}
 }
	/*
	* Copyright (c) 2011 Apple Inc. All rights reserved.
	*
	* @APPLE_APACHE_LICENSE_HEADER_START@
	*
	* 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.
	*
	* @APPLE_APACHE_LICENSE_HEADER_END@
	*/

	/*
	File: dp_enc.c

	Contains: Dynamic Predictor encode routines

	Copyright: (c) 2001-2011 Apple, Inc.
	*/

	#include "dplib.h"
	#include <string.h>

	#if __GNUC__
	#define ALWAYS_INLINE __attribute__((always_inline))
	#else
	#define ALWAYS_INLINE
	#endif

	#if TARGET_CPU_PPC && (__MWERKS__ >= 0x3200)
	// align loops to a 16 byte boundary to make the G5 happy
	#pragma function_align 16
	#define LOOP_ALIGN asm { align 16 }
	#else
	#define LOOP_ALIGN
	#endif

	void init_coefs( int16_t * coefs, uint32_t denshift, int32_t numPairs )
	{
	int32_t k;
	int32_t den = 1 << denshift;

	coefs[0] = (AINIT * den) >> 4;
	coefs[1] = (BINIT * den) >> 4;
	coefs[2] = (CINIT * den) >> 4;
	for ( k = 3; k < numPairs; k++ )
	coefs[k] = 0;
	}

	void copy_coefs( int16_t * srcCoefs, int16_t * dstCoefs, int32_t numPairs )
	{
	int32_t k;

	for ( k = 0; k < numPairs; k++ )
	dstCoefs[k] = srcCoefs[k];
	}

	static inline int32_t ALWAYS_INLINE sign_of_int( int32_t i )
	{
	int32_t negishift;

	negishift = ((uint32_t)-i) >> 31;
	return negishift \| (i >> 31);
	}

	void pc_block( int32_t * in, int32_t * pc1, int32_t num, int16_t * coefs, int32_t numactive, uint32_t chanbits, uint32_t denshift )
	{
	register int16_t a0, a1, a2, a3;
	register int32_t b0, b1, b2, b3;
	int32_t j, k, lim;
	int32_t * pin;
	int32_t sum1, dd;
	int32_t sg, sgn;
	int32_t top;
	int32_t del, del0;
	uint32_t chanshift = 32 - chanbits;
	int32_t denhalf = 1 << (denshift - 1);

	pc1[0] = in[0];
	if ( numactive == 0 )
	{
	// just copy if numactive == 0 (but don't bother if in/out pointers the same)
	if ( (num > 1) && (in != pc1) )
	memcpy( &pc1[1], &in[1], (num - 1) * sizeof(int32_t) );
	return;
	}
	if ( numactive == 31 )
	{
	// short-circuit if numactive == 31
	for( j = 1; j < num; j++ )
	{
	del = in[j] - in[j-1];
	pc1[j] = (del << chanshift) >> chanshift;
	}
	return;
	}

	for ( j = 1; j <= numactive; j++ )
	{
	del = in[j] - in[j-1];
	pc1[j] = (del << chanshift) >> chanshift;
	}

	lim = numactive + 1;

	if ( numactive == 4 )
	{
	// optimization for numactive == 4
	a0 = coefs[0];
	a1 = coefs[1];
	a2 = coefs[2];
	a3 = coefs[3];

	for ( j = lim; j < num; j++ )
	{
	LOOP_ALIGN

	top = in[j - lim];
	pin = in + j - 1;

	b0 = top - pin[0];
	b1 = top - pin[-1];
	b2 = top - pin[-2];
	b3 = top - pin[-3];

	sum1 = (denhalf - a0 * b0 - a1 * b1 - a2 * b2 - a3 * b3) >> denshift;

	del = in[j] - top - sum1;
	del = (del << chanshift) >> chanshift;
	pc1[j] = del;
	del0 = del;

	sg = sign_of_int(del);
	if ( sg > 0 )
	{
	sgn = sign_of_int( b3 );
	a3 -= sgn;
	del0 -= (4 - 3) * ((sgn * b3) >> denshift);
	if ( del0 <= 0 )
	continue;

	sgn = sign_of_int( b2 );
	a2 -= sgn;
	del0 -= (4 - 2) * ((sgn * b2) >> denshift);
	if ( del0 <= 0 )
	continue;

	sgn = sign_of_int( b1 );
	a1 -= sgn;
	del0 -= (4 - 1) * ((sgn * b1) >> denshift);
	if ( del0 <= 0 )
	continue;

	a0 -= sign_of_int( b0 );
	}
	else if ( sg < 0 )
	{
	// note: to avoid unnecessary negations, we flip the value of "sgn"
	sgn = -sign_of_int( b3 );
	a3 -= sgn;
	del0 -= (4 - 3) * ((sgn * b3) >> denshift);
	if ( del0 >= 0 )
	continue;

	sgn = -sign_of_int( b2 );
	a2 -= sgn;
	del0 -= (4 - 2) * ((sgn * b2) >> denshift);
	if ( del0 >= 0 )
	continue;

	sgn = -sign_of_int( b1 );
	a1 -= sgn;
	del0 -= (4 - 1) * ((sgn * b1) >> denshift);
	if ( del0 >= 0 )
	continue;

	a0 += sign_of_int( b0 );
	}
	}

	coefs[0] = a0;
	coefs[1] = a1;
	coefs[2] = a2;
	coefs[3] = a3;
	}
	else if ( numactive == 8 )
	{
	// optimization for numactive == 8
	register int16_t a4, a5, a6, a7;
	register int32_t b4, b5, b6, b7;

	a0 = coefs[0];
	a1 = coefs[1];
	a2 = coefs[2];
	a3 = coefs[3];
	a4 = coefs[4];
	a5 = coefs[5];
	a6 = coefs[6];
	a7 = coefs[7];

	for ( j = lim; j < num; j++ )
	{
	LOOP_ALIGN

	top = in[j - lim];
	pin = in + j - 1;

	b0 = top - (*pin--);
	b1 = top - (*pin--);
	b2 = top - (*pin--);
	b3 = top - (*pin--);
	b4 = top - (*pin--);
	b5 = top - (*pin--);
	b6 = top - (*pin--);
	b7 = top - (*pin);
	pin += 8;

	sum1 = (denhalf - a0 * b0 - a1 * b1 - a2 * b2 - a3 * b3
	- a4 * b4 - a5 * b5 - a6 * b6 - a7 * b7) >> denshift;

	del = in[j] - top - sum1;
	del = (del << chanshift) >> chanshift;
	pc1[j] = del;
	del0 = del;

	sg = sign_of_int(del);
	if ( sg > 0 )
	{
	sgn = sign_of_int( b7 );
	a7 -= sgn;
	del0 -= 1 * ((sgn * b7) >> denshift);
	if ( del0 <= 0 )
	continue;

	sgn = sign_of_int( b6 );
	a6 -= sgn;
	del0 -= 2 * ((sgn * b6) >> denshift);
	if ( del0 <= 0 )
	continue;

	sgn = sign_of_int( b5 );
	a5 -= sgn;
	del0 -= 3 * ((sgn * b5) >> denshift);
	if ( del0 <= 0 )
	continue;

	sgn = sign_of_int( b4 );
	a4 -= sgn;
	del0 -= 4 * ((sgn * b4) >> denshift);
	if ( del0 <= 0 )
	continue;

	sgn = sign_of_int( b3 );
	a3 -= sgn;
	del0 -= 5 * ((sgn * b3) >> denshift);
	if ( del0 <= 0 )
	continue;

	sgn = sign_of_int( b2 );
	a2 -= sgn;
	del0 -= 6 * ((sgn * b2) >> denshift);
	if ( del0 <= 0 )
	continue;

	sgn = sign_of_int( b1 );
	a1 -= sgn;
	del0 -= 7 * ((sgn * b1) >> denshift);
	if ( del0 <= 0 )
	continue;

	a0 -= sign_of_int( b0 );
	}
	else if ( sg < 0 )
	{
	// note: to avoid unnecessary negations, we flip the value of "sgn"
	sgn = -sign_of_int( b7 );
	a7 -= sgn;
	del0 -= 1 * ((sgn * b7) >> denshift);
	if ( del0 >= 0 )
	continue;

	sgn = -sign_of_int( b6 );
	a6 -= sgn;
	del0 -= 2 * ((sgn * b6) >> denshift);
	if ( del0 >= 0 )
	continue;

	sgn = -sign_of_int( b5 );
	a5 -= sgn;
	del0 -= 3 * ((sgn * b5) >> denshift);
	if ( del0 >= 0 )
	continue;

	sgn = -sign_of_int( b4 );
	a4 -= sgn;
	del0 -= 4 * ((sgn * b4) >> denshift);
	if ( del0 >= 0 )
	continue;

	sgn = -sign_of_int( b3 );
	a3 -= sgn;
	del0 -= 5 * ((sgn * b3) >> denshift);
	if ( del0 >= 0 )
	continue;

	sgn = -sign_of_int( b2 );
	a2 -= sgn;
	del0 -= 6 * ((sgn * b2) >> denshift);
	if ( del0 >= 0 )
	continue;

	sgn = -sign_of_int( b1 );
	a1 -= sgn;
	del0 -= 7 * ((sgn * b1) >> denshift);
	if ( del0 >= 0 )
	continue;

	a0 += sign_of_int( b0 );
	}
	}

	coefs[0] = a0;
	coefs[1] = a1;
	coefs[2] = a2;
	coefs[3] = a3;
	coefs[4] = a4;
	coefs[5] = a5;
	coefs[6] = a6;
	coefs[7] = a7;
	}
	else
	{
	//pc_block_general:
	// general case
	for ( j = lim; j < num; j++ )
	{
	LOOP_ALIGN

	top = in[j - lim];
	pin = in + j - 1;

	sum1 = 0;
	for ( k = 0; k < numactive; k++ )
	sum1 -= coefs[k] * (top - pin[-k]);

	del = in[j] - top - ((sum1 + denhalf) >> denshift);
	del = (del << chanshift) >> chanshift;
	pc1[j] = del;
	del0 = del;

	sg = sign_of_int( del );
	if ( sg > 0 )
	{
	for ( k = (numactive - 1); k >= 0; k-- )
	{
	dd = top - pin[-k];
	sgn = sign_of_int( dd );
	coefs[k] -= sgn;
	del0 -= (numactive - k) * ((sgn * dd) >> denshift);
	if ( del0 <= 0 )
	break;
	}
	}
	else if ( sg < 0 )
	{
	for ( k = (numactive - 1); k >= 0; k-- )
	{
	dd = top - pin[-k];
	sgn = sign_of_int( dd );
	coefs[k] += sgn;
	del0 -= (numactive - k) * ((-sgn * dd) >> denshift);
	if ( del0 >= 0 )
	break;
	}
	}
	}
	}
	}