BAND *bd_copy(const BAND *A, BAND *B)
#endif
{
int lb,ub,i,j,n;
if ( !A )
error(E_NULL,"bd_copy");
if (A == B) return B;
n = A->mat->n;
if ( !B )
B = bd_get(A->lb,A->ub,n);
else if (B->lb != A->lb || B->ub != A->ub || B->mat->n != n )
B = bd_resize(B,A->lb,A->ub,n);
if (A->mat == B->mat) return B;
ub = B->ub = A->ub;
lb = B->lb = A->lb;
for ( i=0, j=n-lb; i <= lb; i++, j++ )
MEM_COPY(A->mat->me[i],B->mat->me[i],j*sizeof(Real));
for ( i=lb+1, j=1; i <= lb+ub; i++, j++ )
MEM_COPY(A->mat->me[i]+j,B->mat->me[i]+j,(n - j)*sizeof(Real));
return B;
}
BAND *bd_resize(BAND *A, int new_lb, int new_ub, int new_n)
#endif
{
int lb,ub,i,j,l,shift,umin;
Real **Av;
if (new_lb < 0 || new_ub < 0 || new_n <= 0)
error(E_NEG,"bd_resize");
if ( ! A )
return bd_get(new_lb,new_ub,new_n);
if ( A->lb+A->ub+1 > A->mat->m )
error(E_INTERN,"bd_resize");
if ( A->lb == new_lb && A->ub == new_ub && A->mat->n == new_n )
return A;
lb = A->lb;
ub = A->ub;
Av = A->mat->me;
umin = min(ub,new_ub);
/* ensure that unused triangles at edges are zero'd */
for ( i = 0; i < lb; i++ )
for ( j = A->mat->n - lb + i; j < A->mat->n; j++ )
Av[i][j] = 0.0;
for ( i = lb+1,l=1; l <= umin; i++,l++ )
for ( j = 0; j < l; j++ )
Av[i][j] = 0.0;
new_lb = A->lb = min(new_lb,new_n-1);
new_ub = A->ub = min(new_ub,new_n-1);
A->mat = m_resize(A->mat,new_lb+new_ub+1,new_n);
Av = A->mat->me;
/* if new_lb != lb then move the rows to get the main diag
in the new_lb row */
if (new_lb > lb) {
shift = new_lb-lb;
for (i=lb+umin, l=i+shift; i >= 0; i--,l--)
MEM_COPY(Av[i],Av[l],new_n*sizeof(Real));
for (l=shift-1; l >= 0; l--)
__zero__(Av[l],new_n);
}
else if (new_lb < lb) {
shift = lb - new_lb;
for (i=shift, l=0; i <= lb+umin; i++,l++)
MEM_COPY(Av[i],Av[l],new_n*sizeof(Real));
for (i=lb+umin+1; i <= new_lb+new_ub; i++)
__zero__(Av[i],new_n);
}
return A;
}
CWav::CData & CWav::CData::operator=( const CData & roData )
{
m_uiSampleCount = roData.m_uiSampleCount;
Init();
MEM_COPY( m_ptBuffer, roData.m_ptBuffer, m_uiSampleCount * sizeof(TValue) );
return *this;
}
VEC *LTsolve(const MAT *L, const VEC *b, VEC *out, double diag)
{
unsigned int dim;
int i, i_lim;
MatrixReal **L_me, *b_ve, *out_ve, tmp, invdiag, tiny;
if ( ! L || ! b )
error(E_NULL,"LTsolve");
dim = mat_min(L->m,L->n);
if ( b->dim < dim )
error(E_SIZES,"LTsolve");
out = v_resize(out,L->n);
L_me = L->me; b_ve = b->ve; out_ve = out->ve;
tiny = (10.0/HUGE_VAL);
for ( i=dim-1; i>=0; i-- )
if ( b_ve[i] != 0.0 )
break;
i_lim = i;
if ( b != out )
{
__zero__(out_ve,out->dim);
MEM_COPY(b_ve,out_ve,(i_lim+1)*sizeof(MatrixReal));
}
if ( diag == 0.0 )
{
for ( ; i>=0; i-- )
{
tmp = L_me[i][i];
if ( fabs(tmp) <= tiny*fabs(out_ve[i]) )
error(E_SING,"LTsolve");
out_ve[i] /= tmp;
__mltadd__(out_ve,L_me[i],-out_ve[i],i);
}
}
else
{
invdiag = 1.0/diag;
for ( ; i>=0; i-- )
{
out_ve[i] *= invdiag;
__mltadd__(out_ve,L_me[i],-out_ve[i],i);
}
}
return (out);
}
VEC *UTsolve(const MAT *U, const VEC *b, VEC *out, double diag)
{
unsigned int dim, i, i_lim;
MatrixReal **U_me, *b_ve, *out_ve, tmp, invdiag, tiny;
if ( ! U || ! b )
error(E_NULL,"UTsolve");
dim = mat_min(U->m,U->n);
if ( b->dim < dim )
error(E_SIZES,"UTsolve");
out = v_resize(out,U->n);
U_me = U->me; b_ve = b->ve; out_ve = out->ve;
tiny = (10.0/HUGE_VAL);
for ( i=0; i<dim; i++ )
if ( b_ve[i] != 0.0 )
break;
else
out_ve[i] = 0.0;
i_lim = i;
if ( b != out )
{
__zero__(out_ve,out->dim);
MEM_COPY(&(b_ve[i_lim]),&(out_ve[i_lim]),(dim-i_lim)*sizeof(MatrixReal));
}
if ( diag == 0.0 )
{
for ( ; i<dim; i++ )
{
tmp = U_me[i][i];
if ( fabs(tmp) <= tiny*fabs(out_ve[i]) )
error(E_SING,"UTsolve");
out_ve[i] /= tmp;
__mltadd__(&(out_ve[i+1]),&(U_me[i][i+1]),-out_ve[i],dim-i-1);
}
}
else
{
invdiag = 1.0/diag;
for ( ; i<dim; i++ )
{
out_ve[i] *= invdiag;
__mltadd__(&(out_ve[i+1]),&(U_me[i][i+1]),-out_ve[i],dim-i-1);
}
}
return (out);
}
/* v_move -- copies selected pieces of a vector
-- moves the length dim0 subvector with initial index i0
to the corresponding subvector of out with initial index i1
-- out is resized if necessary */
VEC *v_move(VEC *in,int i0,int dim0,VEC *out,int i1)
{
if ( ! in )
error(E_NULL,"v_move");
if ( i0 < 0 || dim0 < 0 || i1 < 0 ||
i0+dim0 > in->dim )
error(E_BOUNDS,"v_move");
if ( (! out) || i1+dim0 > out->dim )
out = v_resize(out,i1+dim0);
MEM_COPY(&(in->ve[i0]),&(out->ve[i1]),dim0*sizeof(Real));
return out;
}
/* _v_copy -- copies vector into new area */
VEC *_v_copy(VEC *in,VEC *out,unsigned int i0)
{
/* unsigned int i,j; */
if ( in==VNULL )
error(E_NULL,"_v_copy");
if ( in==out )
return (out);
if ( out==VNULL || out->dim < in->dim )
out = v_resize(out,in->dim);
MEM_COPY(&(in->ve[i0]),&(out->ve[i0]),(in->dim - i0)*sizeof(Real));
/* for ( i=i0; i < in->dim; i++ )
out->ve[i] = in->ve[i]; */
return (out);
}
/* px_copy -- copies permutation 'in' to 'out' */
PERM *px_copy(PERM *in,PERM *out)
{
/* int i; */
if ( in == PNULL )
error(E_NULL,"px_copy");
if ( in == out )
return out;
if ( out == PNULL || out->size != in->size )
out = px_resize(out,in->size);
MEM_COPY(in->pe,out->pe,in->size*sizeof(unsigned int));
/* for ( i = 0; i < in->size; i++ )
out->pe[i] = in->pe[i]; */
return out;
}
/* _m_copy -- copies matrix into new area */
MAT *_m_copy(MAT *in,MAT *out,unsigned int i0,unsigned int j0)
{
unsigned int i /* ,j */;
if ( in==MNULL )
error(E_NULL,"_m_copy");
if ( in==out )
return (out);
if ( out==MNULL || out->m < in->m || out->n < in->n )
out = m_resize(out,in->m,in->n);
for ( i=i0; i < in->m; i++ )
MEM_COPY(&(in->me[i][j0]),&(out->me[i][j0]),
(in->n - j0)*sizeof(Real));
/* for ( j=j0; j < in->n; j++ )
out->me[i][j] = in->me[i][j]; */
return (out);
}
/* mv_move -- copies selected piece of matrix to a vector
-- moves the m0 x n0 submatrix with top-left co-ordinate (i0,j0) to
the subvector with initial index i1 (and length m0*n0)
-- rows are copied contiguously
-- out is resized if necessary */
VEC *mv_move(MAT *in,int i0,int j0,int m0,int n0,VEC *out,int i1)
{
int dim1, i;
if ( ! in )
error(E_NULL,"mv_move");
if ( i0 < 0 || j0 < 0 || m0 < 0 || n0 < 0 || i1 < 0 ||
i0+m0 > in->m || j0+n0 > in->n )
error(E_BOUNDS,"mv_move");
dim1 = m0*n0;
if ( (! out) || i1+dim1 > out->dim )
out = v_resize(out,i1+dim1);
for ( i = 0; i < m0; i++ )
MEM_COPY(&(in->me[i0+i][j0]),&(out->ve[i1+i*n0]),n0*sizeof(Real));
return out;
}
/* vm_move -- copies selected piece of vector to a matrix
-- moves the subvector with initial index i0 and length m1*n1 to
the m1 x n1 submatrix with top-left co-ordinate (i1,j1)
-- copying is done by rows
-- out is resized if necessary */
MAT *vm_move(VEC *in,int i0,MAT *out,int i1,int j1,int m1,int n1)
{
int i;
if ( ! in )
error(E_NULL,"vm_move");
if ( i0 < 0 || i1 < 0 || j1 < 0 || m1 < 0 || n1 < 0 ||
i0+m1*n1 > in->dim )
error(E_BOUNDS,"vm_move");
if ( ! out )
out = m_resize(out,i1+m1,j1+n1);
else
out = m_resize(out,max(i1+m1,out->m),max(j1+n1,out->n));
for ( i = 0; i < m1; i++ )
MEM_COPY(&(in->ve[i0+i*n1]),&(out->me[i1+i][j1]),n1*sizeof(Real));
return out;
}
/* m_move -- copies selected pieces of a matrix
-- moves the m0 x n0 submatrix with top-left cor-ordinates (i0,j0)
to the corresponding submatrix of out with top-left co-ordinates
(i1,j1)
-- out is resized (& created) if necessary */
MAT *m_move(MAT *in,int i0,int j0,int m0,int n0,MAT *out,int i1,int j1)
{
int i;
if ( ! in )
error(E_NULL,"m_move");
if ( i0 < 0 || j0 < 0 || i1 < 0 || j1 < 0 || m0 < 0 || n0 < 0 ||
i0+m0 > in->m || j0+n0 > in->n )
error(E_BOUNDS,"m_move");
if ( ! out )
out = m_resize(out,i1+m0,j1+n0);
else if ( i1+m0 > out->m || j1+n0 > out->n )
out = m_resize(out,max(out->m,i1+m0),max(out->n,j1+n0));
for ( i = 0; i < m0; i++ )
MEM_COPY(&(in->me[i0+i][j0]),&(out->me[i1+i][j1]),
n0*sizeof(Real));
return out;
}
DEF_FUNC(mlib_ImageDivAlpha_U8, mlib_u8)
{
mlib_d64 mask7FFF = vis_to_double_dup(0x7FFF7FFF);
mlib_d64 *p_tbl;
mlib_d64 *buffs, *buffd;
mlib_d64 *sp, *dp;
mlib_d64 ss, d0, d1, dd, a0, a1;
mlib_s32 cmask = (1 << (channel - alpha - 1));
mlib_s32 ww, dflag, i, j;
vis_write_gsr(7 << 3);
cmask |= (cmask << channel);
cmask |= (cmask << 2 * channel);
if (channel == 3) {
p_tbl = (mlib_d64 *)mlib_DivAlpha_tbl;
} else {
p_tbl = (mlib_d64 *)mlib_DivAlpha_tbl4 + alpha * 256;
}
width *= channel;
ww = (width + 7) / 8;
if (channel == 3) {
ww = 3 * ((ww + 2) / 3);
}
buffs = __mlib_malloc(2 * sizeof (mlib_d64) * ww);
if (buffs == NULL) {
return (MLIB_FAILURE);
}
buffd = buffs + ww;
for (j = 0; j < height; j++) {
mlib_u8 *ap = sl + alpha;
if (((int)sl & 7)) {
MEM_COPY(sl, buffs, width * sizeof (mlib_u8));
sp = buffs;
} else {
sp = (mlib_d64 *)sl;
}
dflag = 0;
if (((int)dl | width) & 7) {
dp = buffd;
dflag = 1;
} else {
dp = (mlib_d64 *)dl;
}
if (channel == 4) {
#pragma pipeloop(0)
for (i = 0; i < ww; i++) {
ss = *sp;
GET_ALPHA(a0, sp, alpha);
GET_ALPHA(a1, sp, alpha + 4);
DIV_ALPHA(d0, vis_read_hi(ss), a0);
DIV_ALPHA(d1, vis_read_lo(ss), a1);
*dp = vis_fpack16_pair(d0, d1);
sp++;
dp++;
}
} else if (channel == 3) {
mlib_d64 a0, a1, a2, aa;
mlib_d64 b0, b1, b2, bb;
mlib_d64 s0, s1, s2;
mlib_d64 d0, d1;
mlib_s32 cmask0, cmask1, cmask2;
cmask0 = 0x492 >> alpha;
cmask1 = 0x492 >> (alpha + 1);
cmask2 = 0x492 >> (alpha + 2);
vis_alignaddr((void *)0, 4);
if (alpha == 0) {
#pragma pipeloop(0)
for (i = 0; i < ww - 3; i += 3) {
GET_ALPHA_3CH_0();
DIV_ALPHA_3CH();
}
if (i < ww) {
GET_ALPHA_3CH_0_NF();
DIV_ALPHA_3CH_NF();
}
} else if (alpha == 1) {
#pragma pipeloop(0)
for (i = 0; i < ww - 3; i += 3) {
GET_ALPHA_3CH_1();
DIV_ALPHA_3CH();
}
if (i < ww) {
GET_ALPHA_3CH_1_NF();
DIV_ALPHA_3CH_NF();
}
} else { /* if (alpha == 2) */
#pragma pipeloop(0)
for (i = 0; i < ww - 3; i += 3) {
GET_ALPHA_3CH_2();
DIV_ALPHA_3CH();
}
if (i < ww) {
GET_ALPHA_3CH_2_NF();
DIV_ALPHA_3CH_NF();
}
}
} else { /* if (channel == 2) */
#pragma pipeloop(0)
for (i = 0; i < ww; i++) {
/* m_resize -- returns the matrix A of size new_m x new_n; A is zeroed
-- if A == NULL on entry then the effect is equivalent to m_get() */
extern MAT *m_resize(MAT *A, int new_m, int new_n)
{
int i;
int new_max_m, new_max_n, new_size, old_m, old_n;
if (new_m < 0 || new_n < 0)
error(E_NEG,"m_resize");
if ( ! A )
return m_get(new_m,new_n);
/* nothing was changed */
if (new_m == A->m && new_n == A->n)
return A;
old_m = A->m; old_n = A->n;
if ( new_m > A->max_m )
{ /* re-allocate A->me */
if (mem_info_is_on()) {
mem_bytes(TYPE_MAT,A->max_m*sizeof(Real *),
new_m*sizeof(Real *));
}
A->me = RENEW(A->me,new_m,Real *);
if ( ! A->me )
error(E_MEM,"m_resize");
}
new_max_m = max(new_m,A->max_m);
new_max_n = max(new_n,A->max_n);
#ifndef SEGMENTED
new_size = new_max_m*new_max_n;
if ( new_size > A->max_size )
{ /* re-allocate A->base */
if (mem_info_is_on()) {
mem_bytes(TYPE_MAT,A->max_m*A->max_n*sizeof(Real),
new_size*sizeof(Real));
}
A->base = RENEW(A->base,new_size,Real);
if ( ! A->base )
error(E_MEM,"m_resize");
A->max_size = new_size;
}
/* now set up A->me[i] */
for ( i = 0; i < new_m; i++ )
A->me[i] = &(A->base[i*new_n]);
/* now shift data in matrix */
if ( old_n > new_n )
{
for ( i = 1; i < min(old_m,new_m); i++ )
MEM_COPY((char *)&(A->base[i*old_n]),
(char *)&(A->base[i*new_n]),
sizeof(Real)*new_n);
}
else if ( old_n < new_n )
{
for ( i = (int)(min(old_m,new_m))-1; i > 0; i-- )
{ /* copy & then zero extra space */
MEM_COPY((char *)&(A->base[i*old_n]),
(char *)&(A->base[i*new_n]),
sizeof(Real)*old_n);
__zero__(&(A->base[i*new_n+old_n]),(new_n-old_n));
}
__zero__(&(A->base[old_n]),(new_n-old_n));
A->max_n = new_n;
}
/* zero out the new rows.. */
for ( i = old_m; i < new_m; i++ )
__zero__(&(A->base[i*new_n]),new_n);
#else
if ( A->max_n < new_n )
{
Real *tmp;
for ( i = 0; i < A->max_m; i++ )
{
if (mem_info_is_on()) {
mem_bytes(TYPE_MAT,A->max_n*sizeof(Real),
new_max_n*sizeof(Real));
}
if ( (tmp = RENEW(A->me[i],new_max_n,Real)) == NULL )
error(E_MEM,"m_resize");
else {
A->me[i] = tmp;
}
}
for ( i = A->max_m; i < new_max_m; i++ )
{
if ( (tmp = NEW_A(new_max_n,Real)) == NULL )
error(E_MEM,"m_resize");
else {
A->me[i] = tmp;
if (mem_info_is_on()) {
mem_bytes(TYPE_MAT,0,new_max_n*sizeof(Real));
}
}
}
}
else if ( A->max_m < new_m )
{
for ( i = A->max_m; i < new_m; i++ )
if ( (A->me[i] = NEW_A(new_max_n,Real)) == NULL )
error(E_MEM,"m_resize");
else if (mem_info_is_on()) {
mem_bytes(TYPE_MAT,0,new_max_n*sizeof(Real));
}
}
if ( old_n < new_n )
{
for ( i = 0; i < old_m; i++ )
__zero__(&(A->me[i][old_n]),new_n-old_n);
}
/* zero out the new rows.. */
for ( i = old_m; i < new_m; i++ )
__zero__(A->me[i],new_n);
#endif
A->max_m = new_max_m;
A->max_n = new_max_n;
A->max_size = A->max_m*A->max_n;
A->m = new_m; A->n = new_n;
return A;
}
SPMAT *spLUfactor(SPMAT *A, PERM *px, double alpha)
#endif
{
int i, best_i, k, idx, len, best_len, m, n;
SPROW *r, *r_piv, tmp_row;
STATIC SPROW *merge = (SPROW *)NULL;
Real max_val, tmp;
STATIC VEC *col_vals=VNULL;
if ( ! A || ! px )
error(E_NULL,"spLUfctr");
if ( alpha <= 0.0 || alpha > 1.0 )
error(E_RANGE,"alpha in spLUfctr");
if ( px->size <= A->m )
px = px_resize(px,A->m);
px_ident(px);
col_vals = v_resize(col_vals,A->m);
MEM_STAT_REG(col_vals,TYPE_VEC);
m = A->m; n = A->n;
if ( ! A->flag_col )
sp_col_access(A);
if ( ! A->flag_diag )
sp_diag_access(A);
A->flag_col = A->flag_diag = FALSE;
if ( ! merge ) {
merge = sprow_get(20);
MEM_STAT_REG(merge,TYPE_SPROW);
}
for ( k = 0; k < n; k++ )
{
/* find pivot row/element for partial pivoting */
/* get first row with a non-zero entry in the k-th column */
max_val = 0.0;
for ( i = k; i < m; i++ )
{
r = &(A->row[i]);
idx = sprow_idx(r,k);
if ( idx < 0 )
tmp = 0.0;
else
tmp = r->elt[idx].val;
if ( fabs(tmp) > max_val )
max_val = fabs(tmp);
col_vals->ve[i] = tmp;
}
if ( max_val == 0.0 )
continue;
best_len = n+1; /* only if no possibilities */
best_i = -1;
for ( i = k; i < m; i++ )
{
tmp = fabs(col_vals->ve[i]);
if ( tmp == 0.0 )
continue;
if ( tmp >= alpha*max_val )
{
r = &(A->row[i]);
idx = sprow_idx(r,k);
len = (r->len) - idx;
if ( len < best_len )
{
best_len = len;
best_i = i;
}
}
}
/* swap row #best_i with row #k */
MEM_COPY(&(A->row[best_i]),&tmp_row,sizeof(SPROW));
MEM_COPY(&(A->row[k]),&(A->row[best_i]),sizeof(SPROW));
MEM_COPY(&tmp_row,&(A->row[k]),sizeof(SPROW));
/* swap col_vals entries */
tmp = col_vals->ve[best_i];
col_vals->ve[best_i] = col_vals->ve[k];
col_vals->ve[k] = tmp;
px_transp(px,k,best_i);
r_piv = &(A->row[k]);
for ( i = k+1; i < n; i++ )
{
/* compute and set multiplier */
tmp = col_vals->ve[i]/col_vals->ve[k];
if ( tmp != 0.0 )
sp_set_val(A,i,k,tmp);
else
continue;
/* perform row operations */
merge->len = 0;
r = &(A->row[i]);
sprow_mltadd(r,r_piv,-tmp,k+1,merge,TYPE_SPROW);
idx = sprow_idx(r,k+1);
if ( idx < 0 )
idx = -(idx+2);
/* see if r needs expanding */
if ( r->maxlen < idx + merge->len )
sprow_xpd(r,idx+merge->len,TYPE_SPMAT);
r->len = idx+merge->len;
MEM_COPY((char *)(merge->elt),(char *)&(r->elt[idx]),
merge->len*sizeof(row_elt));
}
}
#ifdef THREADSAFE
sprow_free(merge); V_FREE(col_vals);
#endif
return A;
}
mlib_status
mlib_ImageMulAlpha_U8(
mlib_u8 *sl,
mlib_u8 *dl,
mlib_s32 sstride,
mlib_s32 dstride,
mlib_s32 width,
mlib_s32 height,
mlib_s32 channel,
mlib_s32 alpha)
{
mlib_f32 fzeros = vis_fzeros();
mlib_d64 dmask = vis_to_double_dup(0x00FF00FF);
mlib_d64 done = vis_to_double_dup(0x01000100);
mlib_d64 *buffs, *buffd;
mlib_d64 *sp, *dp;
mlib_d64 ss, s1, rr, d0, d1;
mlib_d64 amask0, amask1, amask2;
mlib_s32 ww, dflag, cmask, i, j;
vis_write_gsr(7 << 3);
width *= channel;
ww = (width + 7) / 8;
if (channel == 3) {
ww = 3 * ((ww + 2) / 3);
}
buffs = __mlib_malloc(2 * sizeof (mlib_d64) * ww);
if (buffs == NULL) {
return (MLIB_FAILURE);
}
buffd = buffs + ww;
if (channel == 4) {
cmask = 1 << (3 - alpha);
cmask |= (cmask << 4);
} else if (channel == 3) {
amask0 = ((mlib_d64 *)mlib_amask3_arr)[alpha];
amask1 = ((mlib_d64 *)mlib_amask3_arr)[alpha + 1];
amask2 = ((mlib_d64 *)mlib_amask3_arr)[alpha + 2];
}
for (j = 0; j < height; j++) {
if (((int)sl & 7)) {
MEM_COPY(sl, buffs, width);
sp = buffs;
} else {
sp = (mlib_d64 *)sl;
}
dflag = 0;
if (((int)dl | width) & 7) {
dp = buffd;
dflag = 1;
} else {
dp = (mlib_d64 *)dl;
}
if (channel == 4) {
mlib_d64 a0, a1;
if (alpha == 0) {
#pragma pipeloop(0)
for (i = 0; i < ww; i++) {
MUL_ALPHA_4CH(hi, au);
}
} else if (alpha == 1) {
#pragma pipeloop(0)
for (i = 0; i < ww; i++) {
MUL_ALPHA_4CH(hi, al);
}
} else if (alpha == 2) {
#pragma pipeloop(0)
for (i = 0; i < ww; i++) {
MUL_ALPHA_4CH(lo, au);
}
} else { /* if (alpha == 3) */
#pragma pipeloop(0)
for (i = 0; i < ww; i++) {
MUL_ALPHA_4CH(lo, al);
}
}
} else if (channel == 3) {
mlib_d64 s0, s1, s2;
mlib_d64 a0, a1, a2;
mlib_s32 cmask0, cmask1, cmask2;
cmask0 = 0x492 >> alpha;
cmask1 = 0x492 >> (alpha + 1);
cmask2 = 0x492 >> (alpha + 2);
if (alpha == 0) {
vis_alignaddr((void *)0, 7);
#pragma pipeloop(0)
for (i = 0; i < ww - 3; i += 3) {
LOAD_3CH_0();
MUL_ALPHA_3CH();
}
if (i < ww) {
LOAD_3CH_0_NF();
MUL_ALPHA_3CH();
}
} else if (alpha == 1) {
mlib_d64 b0, b1, b2;
#pragma pipeloop(0)
for (i = 0; i < ww - 3; i += 3) {
LOAD_3CH_1();
MUL_ALPHA_3CH();
}
if (i < ww) {
LOAD_3CH_1_NF();
MUL_ALPHA_3CH();
}
} else { /* if (alpha == 2) */
vis_alignaddr((void *)0, 1);
#pragma pipeloop(0)
for (i = 0; i < ww - 3; i += 3) {
LOAD_3CH_2();
MUL_ALPHA_3CH();
}
if (i < ww) {
LOAD_3CH_2_NF();
MUL_ALPHA_3CH();
}
}
} else { /* if (channel == 2) */
if (alpha == 0) {
BAND *bd_transp(const BAND *in, BAND *out)
#endif
{
int i, j, jj, l, k, lb, ub, lub, n, n1;
int in_situ;
Real **in_v, **out_v;
if ( in == (BAND *)NULL || in->mat == (MAT *)NULL )
error(E_NULL,"bd_transp");
lb = in->lb;
ub = in->ub;
lub = lb+ub;
n = in->mat->n;
n1 = n-1;
in_situ = ( in == out );
if ( ! in_situ )
out = bd_resize(out,ub,lb,n);
else
{ /* only need to swap lb and ub fields */
out->lb = ub;
out->ub = lb;
}
in_v = in->mat->me;
if (! in_situ) {
int sh_in,sh_out;
out_v = out->mat->me;
for (i=0, l=lub, k=lb-i; i <= lub; i++,l--,k--) {
sh_in = max(-k,0);
sh_out = max(k,0);
MEM_COPY(&(in_v[i][sh_in]),&(out_v[l][sh_out]),
(n-sh_in-sh_out)*sizeof(Real));
/**********************************
for (j=n1-sh_out, jj=n1-sh_in; j >= sh_in; j--,jj--) {
out_v[l][jj] = in_v[i][j];
}
**********************************/
}
}
else if (ub == lb) {
Real tmp;
for (i=0, l=lub, k=lb-i; i < lb; i++,l--,k--) {
for (j=n1-k, jj=n1; j >= 0; j--,jj--) {
tmp = in_v[l][jj];
in_v[l][jj] = in_v[i][j];
in_v[i][j] = tmp;
}
}
}
else if (ub > lb) { /* hence i-ub <= 0 & l-lb >= 0 */
int p,pp,lbi;
for (i=0, l=lub; i < (lub+1)/2; i++,l--) {
lbi = lb-i;
for (j=l-lb, jj=0, p=max(-lbi,0), pp = max(l-ub,0); j <= n1;
j++,jj++,p++,pp++) {
in_v[l][pp] = in_v[i][p];
in_v[i][jj] = in_v[l][j];
}
for ( ; p <= n1-max(lbi,0); p++,pp++)
in_v[l][pp] = in_v[i][p];
}
if (lub%2 == 0) { /* shift only */
i = lub/2;
for (j=max(i-lb,0), jj=0; jj <= n1-ub+i; j++,jj++)
in_v[i][jj] = in_v[i][j];
}
}
else { /* ub < lb, hence ub-l <= 0 & lb-i >= 0 */
int p,pp,ubi;
for (i=0, l=lub; i < (lub+1)/2; i++,l--) {
ubi = i-ub;
for (j=n1-max(lb-l,0), jj=n1-max(-ubi,0), p=n1-lb+i, pp=n1;
p >= 0; j--, jj--, pp--, p--) {
in_v[i][jj] = in_v[l][j];
in_v[l][pp] = in_v[i][p];
}
for ( ; jj >= max(ubi,0); j--, jj--)
in_v[i][jj] = in_v[l][j];
}
if (lub%2 == 0) { /* shift only */
i = lub/2;
for (j=n1-lb+i, jj=n1-max(ub-i,0); j >= 0; j--, jj--)
in_v[i][jj] = in_v[i][j];
}
}
return out;
}
