wavelet.cpp

用于语音压缩的小波变换编解码程序

				pointer = 8;
			}
			if (count1 == stlength)
				break;
		}
		if (count1 == stlength)
			break;
		for (k = 1, count = lsp[0] + 1; k <= last_lsp_adds[0]; k++, count++)
			lsp[count] = last_lsp_adds[k];
		lsp[0] += last_lsp_adds[0];
	}
	if (pointer < 8)
	{
		byt <<= pointer;
      		ch[m]=byt;

	}
}

void wdecom(double image[], unsigned long int * nn, int ndim, int direction, int ns)
{
	void daub4(double a[], unsigned long n, int isign);
	void bior44(double a[], unsigned long n, int isign);
	void wtn(double a[], unsigned long nn[], int ndim, int isign,
	void (*wtstep)(double [], unsigned long, int), int);

	wtn(image, nn, ndim, direction, bior44, ns);
}
void daub4(double a[], unsigned long n, int isign)
{
	double * wksp;
	unsigned long nh, nh1, i, j;

	if (n < 4) return;
	wksp = (double *)malloc(n * sizeof(double));
	nh1 = (nh = n >> 1);
	if (isign >= 0)
	{
		for (i = 0, j = 0; j < n-3; j += 2, i++)
		{
			wksp[i] = C0 * a[j] + C1 * a[j+1] + C2 * a[j+2] + C3 * a[j+3];
			wksp[i+nh] = C3 * a[j] - C2 * a[j+1] + C1 * a[j+2] - C0 * a[j+3];
		}
		wksp[i] = C0 * a[n-2] + C1 * a[n-1] + C2 * a[0] + C3 * a[1];
		wksp[i+nh] = C3 * a[n-2] - C2 * a[n-1] + C1 * a[0] - C0 * a[1];
	}
	else
	{
		wksp[0] = C2 * a[nh-1] + C1 * a[n-1] + C0 * a[0] + C3 * a[nh1];
		wksp[1] = C3 * a[nh-1] - C0 * a[n-1] + C1 * a[0] - C2 * a[nh1];
		for (i = 0, j = 2; i < (nh - 1); i++)
		{
			wksp[j++] = C2 * a[i] + C1 * a[i+nh] + C0 * a[i+1] + C3 * a[i+nh1+1];
			wksp[j++] = C3 * a[i] - C0 * a[i+nh] + C1 * a[i+1] - C2 * a[i+nh1+1];
		}
	}
	for (i = 0; i < n; i++) a[i] = wksp[i];
	free(wksp);
}
void bior44(double a[], unsigned long n, int isign)
{
	double * wksp;
	int nh, i, j;

	if (n < 4) return;
	wksp = (double *)malloc(n * sizeof(double));
	nh = (n >> 1);
	if (isign >= 0)
	{
		for (i = 0, j = 0; j < 4; j += 2, i++)
		{
			wksp[i] = LD0 * a[j+4] + LD1 * a[j+3] + LD2 * a[j+2] + LD3 * a[j+1];
			wksp[i] += LD4 * a[j] + LD5 * a[abs(j-1)] + LD6 * a[abs(j-2)] + LD7 * a[abs(j-3)];
			wksp[i] += LD8 * a[abs(j-4)];

			wksp[i+nh] = HD0 * a[j+4] + HD1 * a[j+3] + HD2 * a[j+2] + HD3 * a[j+1];
			wksp[i+nh] += HD4 * a[j] + HD5 * a[abs(j-1)] + HD6 * a[abs(j-2)];

		}
		for ( ; j < (n - 4); j += 2, i++)
		{
			wksp[i] = LD0 * a[j+4] + LD1 * a[j+3] + LD2 * a[j+2] + LD3 * a[j+1];
			wksp[i] += LD4 * a[j] + LD5 * a[j-1] + LD6 * a[j-2] + LD7 * a[j-3];
			wksp[i] += LD8 * a[j-4];

			wksp[i+nh] = HD0 * a[j+4] + HD1 * a[j+3] + HD2 * a[j+2] + HD3 * a[j+1];
			wksp[i+nh] += HD4 * a[j] + HD5 * a[j-1] + HD6 * a[j-2];
		}
		for (  ; j < n; j += 2, i++)
		{
			wksp[i] = LD0 * a[n-1-abs(j+5-n)] + LD1 * a[n-1-abs(j+4-n)] + LD2 * a[n-1-abs(j+3-n)] + LD3 * a[n-1-abs(j+2-n)];
			wksp[i] += LD4 * a[j] + LD5 * a[j-1] + LD6 * a[j-2];
			wksp[i] += LD7 * a[j-3] + LD8 * a[j-4];

			wksp[i+nh] = HD0 * a[n-1-abs(j+5-n)] + HD1 * a[n-1-abs(j+4-n)] + HD2 * a[n-1-abs(j+3-n)] + HD3 * a[n-1-abs(j+2-n)];
			wksp[i+nh] += HD4 * a[j] + HD5 * a[j-1] + HD6 * a[j-2];
		}
	}
	else
	{
		for ( i = 0, j = 0; i < 2; i++)
		{
			wksp[j] = LR1 * a[i+1] + HR1 * a[i+1+nh] + LR3 * a[i];
			wksp[j] += HR3 * a[nh+i] + LR5 * a[abs(i-1)] + HR5 * a[((i-1) < 0 ? -i : (i-1))+nh];
			wksp[j++] += HR7 * a[((i-2) < 0 ? (1-i) : (i-2))+nh];

			wksp[j] = LR0 * a[i+2] + HR0 * a[nh+i+2] + LR2 * a[i+1] + HR2 * a[nh+i+1];
			wksp[j] += LR4 * a[i] + HR4 * a[i+nh];
			wksp[j] += LR6 * a[abs(i-1)] + HR6 * a[((i-1) < 0 ? -i : (i-1))+nh];
			wksp[j++] += HR8 * a[((i-2) < 0 ? 1-i : (i-2))+nh];
		}
		for ( ; i < nh - 2; i++)
		{
			wksp[j] = LR1 * a[i+1] + HR1 * a[i+1+nh] + LR3 * a[i];
			wksp[j] += HR3 * a[nh+i] + LR5 * a[i-1] + HR5 * a[i-1+nh];
			wksp[j++] += HR7 * a[i-2+nh];

			wksp[j] = LR0 * a[i+2] + HR0 * a[nh+i+2] + LR2 * a[i+1] + HR2 * a[nh+i+1];
			wksp[j] += LR4 * a[i] + HR4 * a[i+nh];
			wksp[j] += LR6 * a[i-1] + HR6 * a[i-1+nh];
			wksp[j++] += HR8 * a[i-2+nh];
		}
		for ( ; i < nh; i++)
		{
			wksp[j] = LR1 * a[(i+1) < nh ? (i+1) : (nh+nh-i-2)] + HR1 * a[nh+nh-1-abs(i+2-nh)] + LR3 * a[i] + HR3 * a[nh+i];
			wksp[j] += LR5 * a[i-1] + HR5 * a[nh+i-1];
			wksp[j++] += HR7 * a[i-2+nh];

			wksp[j] = LR0 * a[(i+2) < nh ? (i+2) : (nh+nh-i-3)] + HR0 * a[nh+nh-1-abs(i+3-nh)] + LR2 * a[(i+1) < nh ? (i+1) : (nh+nh-i-2)] + HR2 * a[nh+nh-1-abs(i+2-nh)];
			wksp[j] += LR4 * a[i] + HR4 * a[nh+i];
			wksp[j] += LR6 * a[i-1] + HR6 * a[nh+i-1];
			wksp[j++] += HR8 * a[i-2+nh];
		}
	}
	for (i = 0; i < n; i++) a[i] = wksp[i];
	free(wksp);
}
void wtn(double a[], unsigned long nn[], int ndim, int isign,
		 void (*wtstep)(double [], unsigned long, int), int ns)
{
	unsigned long i1, i2, i3, k, n, nnew, nprev, ntot = 1;
	int idim, i;
	double * wksp;
	for (idim = 0; idim < ndim; idim++) ntot *= nn[idim];
	wksp = (double *)malloc(ntot * sizeof(double));
	if (isign >= 0)
	{
		ntot <<= 1;
		for ( i = 0; i < ns; i++)
		{
			nprev = 1;
			ntot >>= 1;
			for (idim = 0; idim < ndim; idim++)
			{
				n = nn[idim];
				nnew = n * nprev;
				if (n > 4)
				{
					for (i2 = 0; i2 < ntot; i2 += nnew)
					{
						for (i1 = 0; i1 < (nprev >> (idim * i)); i1++)
						{
							for (i3 = i1 + i2, k = 0; k < (n >> i); k++, i3 += nprev)
								wksp[k] = a[i3];
							(*wtstep)(wksp, (n >> i), isign);
							for (i3 = i1 + i2, k = 0; k < (n >> i); k++, i3 += nprev)
								a[i3] = wksp[k];
						}
						nprev = nnew;
					}
				}
			}
		}
	}
	else
	{
		ntot >>= ns;
		for ( i = 0; i < ns; i++)
		{
			nprev = 1;
			ntot <<= 1;
			for (idim = 0; idim < ndim; idim++)
			{
				n = nn[idim];
				nnew = n * nprev;
				if (n > 4)
				{
					for (i2 = 0; i2 < ntot; i2 += nnew)
					{
						for (i1 = 0; i1 < (nprev >> (idim * (ns - i -1))); i1++)
						{
							for (i3 = i1 + i2, k = 0; k < (n >> (ns - i - 1)); k++, i3 += nprev)
								wksp[k] = a[i3];
							(*wtstep)(wksp, (n >> (ns - i - 1)), isign);
							for (i3 = i1 + i2, k = 0; k < (n >> (ns - i -1)); k++, i3 += nprev)
								a[i3] = wksp[k];
						}
						nprev = nnew;
					}
				}
			}
		}
	}
	free(wksp);
}

void function2( unsigned char u[], double checked1[])
{
	double image[len],temp,byt1, s[len];
	unsigned long int imagelength;
	unsigned long int nn[2]={512, 512};
	int linelength, dims[2] = {1, 512*512};
	unsigned int n1 = 0, row, col, ns, i, j, k, l, lnn[2], width, length;
	unsigned int lis[len/4+1], lip[len+1], lsp[len+1], last_lsp_adds[len+1], count, stlength;
	unsigned int count2, threshold, count3, row1;
	unsigned int O[2], index;
	unsigned char  type[len/4+1], byt,pointer, checked[len/4+1];
	char sn;
	stlength = len/2;
	index = 0;
	n1 = u[index];
   	ns=3;
   	linelength=16;
   	imagelength=256;
   	row=16;
   	col=16;
	nn[0] = row;
	nn[1] = col;
	for (i = ns + 1; i > 0; i--)
	{
	    s[i] = row >> (ns + 1 -i);
	    s[i + ns + 2] = col >> (ns + 1 -i);
	}
	s[0] = s[1];
	s[ns + 2] = s[ns + 3];


	for (i = 0; i < imagelength; i++)
		image[i] = 0;

	dims[1] =  imagelength + 1;

	lsp[0] = 0;
	lip[0] = (unsigned int)imagelength;
	lnn[0] = (unsigned int)nn[0];
	lnn[1] = (unsigned int)nn[1];
	for (i = 0; i < ns; i++)
	{
		lip[0] /= 4;
		lnn[0] /= 2;
		lnn[1] /= 2;
	}
	lis[0] = 3 * lip[0] / 4;
	count = 1;
	for (i = 0; i < lnn[0]; i+= 2)
	{
		for (j = 0; j < lnn[1]; j+= 2)
		{
			for ( k = 0; k < 4; k++, count++)
			{
				lip[count] = (j + (k % 2)) * linelength + (i + ( k > 1));
			}
		}
	}
	count = 1;
	for (i = 0; i < lnn[0]; i += 2)
	{
		for (j = 0; j < lnn[1]; j += 2)
		{
			for (k = 0; k < 3; k++, count++)
			{
				type[count] = 'a';
				lis[count] = (j + (k + 1) % 2) * linelength + (i + ( k > 0));
			}
		}
	}
	pointer = 0;
	threshold = 1;
	for ( i = 0; i < (n1 + 1); i++)
		threshold <<= 1;
	while (index < stlength)
	{
		threshold >>= 1;
		last_lsp_adds[0] = 0;
		row = (int)nn[0];
		col = (int)nn[1];
		count = 1;
		count3 = 1;

		while (count <= lip[0])
		{
			if (!pointer)
			{
				pointer = 8;
				index++;
				if (index == stlength)
					break;
				byt = u[index];
			}
			sn = !!(byt & ( 1 << --pointer));

			if (!sn)
				count++;
			else
				break;
		}

		if (index == stlength)
			break;
		for ( count2 = count; count < lip[0]; )
		{
			while ((count < lip[0]) && sn)
			{
				last_lsp_adds[count3] = lip[count];
				count++;
				count3++;
				if (!pointer)
				{
					pointer = 8;
					index++;
					if (index == stlength)
						break;
					byt = u[index];
				}
				sn = !!(byt & ( 1 << --pointer));
				image[lip[count - 1]] = (1 - 2 * sn) * 1.5 * threshold;
				if (!pointer)
				{
					pointer = 8;
					index++;
					if (index == stlength)
						break;
					byt = u[index];
				}
				sn = !!(byt & ( 1 << --pointer));
			}
			if (index == stlength)
				break;
			while ((count < lip[0]) && !sn)
			{
				lip[count2] = lip[count];
				count++;
				count2++;
				if (!pointer)
				{
					pointer = 8;
					index++;
					if (index == stlength)
						break;
					byt = u[index];
				}
				sn = !!(byt & ( 1 << --pointer));
			}
			if (index == stlength)
				break;
		}
		if (count == lip[0])
		{
			if (sn)
			{
				last_lsp_adds[count3] = lip[count];
				count++;
				count3++;
				if (!pointer)
				{
					pointer = 8;
					index++;
					if (index == stlength)
						break;
					byt = u[index];
				}
				sn = !!(byt & ( 1 << --pointer));
				image[lip[count - 1]] = (1 - 2 * sn) * 1.5 * threshold;
			}
			else
			{
				lip[count2] = lip[count];
				count2++;
			}
		}
		if (index == stlength)
			break;
		lip[0] = count2 - 1;
		last_lsp_adds[0] = count3 - 1;
		row1 = lis[0];
		for (j = 1; j <= row1; j++)
			checked[j] = 0;
		j = 1;
		while ( j <= row1)
		{
			if (checked[j] == 0)
			{
				checked[j] = 1;
				if (!pointer)
				{
					pointer = 8;
					index++;
					if (index == stlength)
						break;
					byt = u[index];
				}
				sn = !!(byt & ( 1 << --pointer));
				width = lis[j] % row;
				length = lis[j] / row;
				if ((width >= lnn[0]) || (length >= lnn[1]))
				{
					width <<= 1;
					length <<= 1;
				}
				else if (!(width % 2))
					length += lnn[1] -1;
				else if (!(length % 2))
					width += lnn[0] -1;
				else
				{
					length += lnn[1] -1;
					width += lnn[0] -1;
				}
				O[0] = width;
				O[1] = length;
				//2.2.1 type A
				if (type[j] == 'a')
				{
					if (!sn)
						j++;
					else
					{
						for (k = 0; k < 2; k++)
						{
							for (l = 0; l < 2; l++)
							{
								if (!pointer)
								{
									pointer = 8;
									index++;
									if (index == stlength)
										break;
									byt = u[index];
								}
								sn = !!(byt & ( 1 << --pointer));
								if (sn)
								{
									last_lsp_adds[count3++] = O[0] + k + (O[1] + l) * row;
									last_lsp_adds[0]++;
									if (!pointer)
									{
										pointer = 8;
										index++;
										if (index == stlength)
											break;
										byt = u[index];
									}
									sn = !!(byt & ( 1 << --pointer));
									image[O[0] + k + (O[1] + l) * row] = (1 - 2 * sn) * 1.5 * threshold;
								}
								else
								{
									lip[count2++] = O[0] + k + (O[1] + l) * row;
									lip[0]++;
								}

							}
							if (index == stlength)
								break;
						}
						if (index == stlength)
							break;
						if (((O[0] << 1) < row) && ((O[1] << 1) < col))//if L(i,j)!= {},
						{
							l = lis[j];
							for (k = j + 1; k <= row1; k++)
							{
								lis[k - 1] = lis[k];
								type[k - 1] = type[k];
								checked[k - 1] = checked[k];
							}
							lis[row1] = l;
							type[row1]= 'b';
							checked[row1] = 1;
							if (!pointer)
							{
								pointer = 8;
								index++;
								if (index == stlength)
									break;
								byt = u[index];
							}
							sn = !!(byt & ( 1 << --pointer));
							if (sn)
							{
								count = row1;
								for (k = 0; k < 2; k++)
									for (l = 0; l < 2; l++, count++)
									{
										lis[count] = O[0] + k + (O[1] + l) * row ;
										type[count] = 'a';
										checked[count] = 0;
									}
								row1 += 3;
								lis[0] = row1;
							}
						}
						else
						{
							for (k = j + 1; k <= row1; k++)
							{
								lis[k - 1] = lis[k];
								type[k - 1] = type[k];
								checked[k - 1] = checked[k];
							}
							row1--;
							lis[0]--;
						}
					}
					if (index == stlength)
						break;
				}
				else
				{
					if (sn)
					{
						for (k = j + 1; k <= row1; k++)
						{
							lis[k - 1] = lis[k];
							type[k - 1] = type[k];
							checked[k - 1] = checked[k];
						}
						count = row1;
						for (k = 0; k < 2; k++)
							for (l = 0; l < 2; l++, count++)
							{
								lis[count] = O[0] + k + (O[1] + l) * row ;
								type[count] = 'a';
								checked[count] = 0;
							}
						row1 += 3;
						lis[0] = row1;
					}
					else
						j++;
				}
			}
			else
				j++;
			if (index == stlength)
				break;
		}
		if (index == stlength)
			break;
		row1 = lsp[0];
		for (j = 1; j <= row1; j++)
		{
			if (!pointer)
			{
				pointer = 8;
				index++;
				if (index == stlength)
					break;
				byt = u[index];
			}
			sn = !!(byt & ( 1 << --pointer));
			temp = (image[lsp[j]] >= 0) ? 1 : -1;
			image[lsp[j]] = fabs(image[lsp[j]]) + (((int)sn << 1) - 1) * ((int)threshold >> 1);
			image[lsp[j]] *= temp;
		}
		if (index == stlength)
			break;
		for (k = 1, count = lsp[0] + 1; k <= last_lsp_adds[0]; k++, count++)
			lsp[count] = last_lsp_adds[k];
		lsp[0] += last_lsp_adds[0];
	}

    wdecom(image, nn, 2, -1, ns);

	for ( j = 0; j < (unsigned int)(nn[0]*nn[1]); j++)
	{
	   temp = image[j];
		byt1 = temp;
		checked1[j] = byt1;
	}
}