/*
 ** Copyright 2003-2010, VisualOn, Inc.
 **
 ** 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.
 */

/***********************************************************************
*      File: p_med_ol.c                                                *
*                                                                      *
*      Description: Compute the open loop pitch lag                    *
*	            output: open loop pitch lag                        *                            
************************************************************************/

#include "typedef.h"
#include "basic_op.h"
#include "acelp.h"
#include "oper_32b.h"
#include "math_op.h"
#include "p_med_ol.tab"

Word16 Pitch_med_ol(
		   Word16      wsp[],        /*   i: signal used to compute the open loop pitch*/  
                                     /*      wsp[-pit_max] to wsp[-1] should be known */
		   Coder_State *st,          /* i/o: codec global structure */
		   Word16      L_frame       /*   i: length of frame to compute pitch */
		)
{
	Word16 Tm;
	Word16 hi, lo;
	Word16 *ww, *we, *hp_wsp;
	Word16 exp_R0, exp_R1, exp_R2;
	Word32 i, j, max, R0, R1, R2;
	Word16 *p1, *p2;
	Word16 L_min = 17;                   /* minimum pitch lag: PIT_MIN / OPL_DECIM */
	Word16 L_max = 115;                  /* maximum pitch lag: PIT_MAX / OPL_DECIM */
	Word16 L_0 = st->old_T0_med;         /* old open-loop pitch */
	Word16 *gain = &(st->ol_gain);       /* normalize correlation of hp_wsp for the lag */
	Word16 *hp_wsp_mem = st->hp_wsp_mem; /* memory of the hypass filter for hp_wsp[] (lg = 9)*/
	Word16 *old_hp_wsp = st->old_hp_wsp; /* hypass wsp[] */
	Word16 wght_flg = st->ol_wght_flg;   /* is weighting function used */

	ww = &corrweight[198];
	we = &corrweight[98 + L_max - L_0];

	max = MIN_32;                          
	Tm = 0;                                
	for (i = L_max; i > L_min; i--)
	{
		/* Compute the correlation */
		R0 = 0;
		p1 = wsp;
		p2 = &wsp[-i];
		for (j = 0; j < L_frame; j+=4)
		{
			R0 += vo_L_mult((*p1++), (*p2++));
			R0 += vo_L_mult((*p1++), (*p2++));
			R0 += vo_L_mult((*p1++), (*p2++));
			R0 += vo_L_mult((*p1++), (*p2++));     
		}
		/* Weighting of the correlation function.   */
		hi = R0>>16;
		lo = (R0 & 0xffff)>>1;

		R0 = Mpy_32_16(hi, lo, *ww);
		ww--;

		if ((L_0 > 0) && (wght_flg > 0))
		{
			/* Weight the neighbourhood of the old lag. */
			hi = R0>>16;
			lo = (R0 & 0xffff)>>1;
			R0 = Mpy_32_16(hi, lo, *we);
			we--;
		}
		if(R0 >= max)
		{
			max = R0;
			Tm = i;
		}
	}

	/* Hypass the wsp[] vector */
	hp_wsp = old_hp_wsp + L_max;           
	Hp_wsp(wsp, hp_wsp, L_frame, hp_wsp_mem);

	/* Compute normalize correlation at delay Tm */
	R0 = 0;                                
	R1 = 0;                               
	R2 = 0; 
	p1 = hp_wsp;
	p2 = hp_wsp - Tm;
	for (j = 0; j < L_frame; j+=4)
	{
		R2 += vo_mult32(*p1, *p1);
		R1 += vo_mult32(*p2, *p2);
		R0 += vo_mult32(*p1++, *p2++);
		R2 += vo_mult32(*p1, *p1);
		R1 += vo_mult32(*p2, *p2);
		R0 += vo_mult32(*p1++, *p2++);
		R2 += vo_mult32(*p1, *p1);
		R1 += vo_mult32(*p2, *p2);
		R0 += vo_mult32(*p1++, *p2++);
		R2 += vo_mult32(*p1, *p1);
		R1 += vo_mult32(*p2, *p2);
		R0 += vo_mult32(*p1++, *p2++);
	}
	R0 = R0 <<1;
	R1 = (R1 <<1) + 1L;
	R2 = (R2 <<1) + 1L;
	/* gain = R0/ sqrt(R1*R2) */

	exp_R0 = norm_l(R0);
	R0 = (R0 << exp_R0);

	exp_R1 = norm_l(R1);
	R1 = (R1 << exp_R1);

	exp_R2 = norm_l(R2);
	R2 = (R2 << exp_R2);


	R1 = vo_L_mult(vo_round(R1), vo_round(R2));

	i = norm_l(R1);
	R1 = (R1 << i);

	exp_R1 += exp_R2;
	exp_R1 += i;
	exp_R1 = 62 - exp_R1;

	Isqrt_n(&R1, &exp_R1);

	R0 = vo_L_mult(voround(R0), voround(R1));
	exp_R0 = 31 - exp_R0;
	exp_R0 += exp_R1;

	*gain = vo_round(L_shl(R0, exp_R0));

	/* Shitf hp_wsp[] for next frame */

	for (i = 0; i < L_max; i++)
	{
		old_hp_wsp[i] = old_hp_wsp[i + L_frame];
	}

	return (Tm);
}

/************************************************************************
*  Function: median5                                                    *
*                                                                       *
*      Returns the median of the set {X[-2], X[-1],..., X[2]},          *
*      whose elements are 16-bit integers.                              *
*                                                                       *
*  Input:                                                               *
*      X[-2:2]   16-bit integers.                                       *
*                                                                       *
*  Return:                                                              *
*      The median of {X[-2], X[-1],..., X[2]}.                          *
************************************************************************/

Word16 median5(Word16 x[])
{
	Word16 x1, x2, x3, x4, x5;
	Word16 tmp;

	x1 = x[-2];                            
	x2 = x[-1];                            
	x3 = x[0];                             
	x4 = x[1];                             
	x5 = x[2];                             

	if (x2 < x1)
	{
		tmp = x1;
		x1 = x2;
		x2 = tmp;                          
	}
	if (x3 < x1)
	{
		tmp = x1;
		x1 = x3;
		x3 = tmp;                          
	}
	if (x4 < x1)
	{
		tmp = x1;
		x1 = x4;
		x4 = tmp;                          
	}
	if (x5 < x1)
	{
		x5 = x1;                           
	}
	if (x3 < x2)
	{
		tmp = x2;
		x2 = x3;
		x3 = tmp;                          
	}
	if (x4 < x2)
	{
		tmp = x2;
		x2 = x4;
		x4 = tmp;                          
	}
	if (x5 < x2)
	{
		x5 = x2;                           
	}
	if (x4 < x3)
	{
		x3 = x4;                           
	}
	if (x5 < x3)
	{
		x3 = x5;                           
	}
	return (x3);
}


Word16 Med_olag(                           /* output : median of  5 previous open-loop lags       */
		Word16 prev_ol_lag,                /* input  : previous open-loop lag                     */
		Word16 old_ol_lag[5]
	       )
{
	Word32 i;

	/* Use median of 5 previous open-loop lags as old lag */

	for (i = 4; i > 0; i--)
	{
		old_ol_lag[i] = old_ol_lag[i - 1]; 
	}

	old_ol_lag[0] = prev_ol_lag;           

	i = median5(&old_ol_lag[2]);

	return i;

}