/* GdkPixbuf library - Scaling and compositing functions
*
- * Copyright (C) 1999 The Free Software Foundation
- *
+ * Original:
+ * Copyright (C) 2000 Red Hat, Inc
* Author: Owen Taylor <otaylor@redhat.com>
- * Modified for YUV422 by Dan Dennedy <dan@dennedy.org>
+ *
+ * Modification for MLT:
+ * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
+ * Author: Dan Dennedy <dan@dennedy.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
-
+
#include <math.h>
#include <glib.h>
#include <stdio.h>
/* mmx function declarations */
-#ifdef USE_MMX
-guchar *pixops_scale_line_22_33_mmx ( guint32 weights[ 16 ][ 8 ], guchar *p, guchar *q1, guchar *q2, int x_step, guchar *p_stop, int x_init );
+#if defined(USE_MMX) && !defined(ARCH_X86_64)
+guchar *pixops_scale_line_22_yuv_mmx ( guint32 weights[ 16 ][ 8 ], guchar *p, guchar *q1, guchar *q2, int x_step, guchar *p_stop, int x_init, int destx );
int pixops_have_mmx ( void );
#endif
double scale_y )
{
register int i, j;
- register int x;
register int x_step = ( 1 << SCALE_SHIFT ) / scale_x;
register int y_step = ( 1 << SCALE_SHIFT ) / scale_y;
+ register int x, x_scaled;
for ( i = 0; i < ( render_y1 - render_y0 ); i++ )
{
const guchar *src = src_buf + ( ( ( i + render_y0 ) * y_step + ( y_step >> 1 ) ) >> SCALE_SHIFT ) * src_rowstride;
guchar *dest = dest_buf + i * dest_rowstride;
-
x = render_x0 * x_step + ( x_step >> 1 );
for ( j = 0; j < ( render_x1 - render_x0 ); j++ )
{
- int x_scaled = x >> SCALE_SHIFT;
+ x_scaled = x >> SCALE_SHIFT;
*dest++ = src[ x_scaled << 1 ];
*dest++ = src[ ( ( x_scaled >> 1 ) << 2 ) + ( ( j & 1 ) << 1 ) + 1 ];
x += x_step;
guchar **src,
int x_init, int x_step, int src_width )
{
- int x = x_init;
- register int i, j, dx = 0;
+ register int x = x_init;
+ register int i, j, x_scaled, y_index, uv_index;
while ( dest < dest_end )
{
- int x_scaled = x >> SCALE_SHIFT;
- int *pixel_weights;
unsigned int y = 0, uv = 0;
+ int *pixel_weights = weights + ( ( x >> ( SCALE_SHIFT - SUBSAMPLE_BITS ) ) & SUBSAMPLE_MASK ) * n_x * n_y;
- pixel_weights = weights + ( ( x >> ( SCALE_SHIFT - SUBSAMPLE_BITS ) ) & SUBSAMPLE_MASK ) * n_x * n_y;
+ x_scaled = x >> SCALE_SHIFT;
+ y_index = x_scaled << 1;
+ uv_index = ( ( x_scaled >> 1 ) << 2 ) + ( ( dest_x & 1 ) << 1 ) + 1;
for ( i = 0; i < n_y; i++ )
{
{
unsigned int ta = line_weights[ j ];
- y += ta * q[ ( x_scaled << 1 ) ];
- uv += ta * q[ ( ( x_scaled >> 1 ) << 2 ) + ( ( dx & 1 ) << 1 ) + 1 ];
+ y += ta * q[ y_index ];
+ uv += ta * q[ uv_index ];
}
}
*dest++ = ( uv + 0xffff ) >> SCALE_SHIFT;
x += x_step;
- dx++;
+ dest_x++;
}
return dest;
}
-#ifdef USE_MMX
+#if defined(USE_MMX) && !defined(ARCH_X86_64)
static inline guchar *
-scale_line_22_33_mmx_stub ( int *weights, int n_x, int n_y,
+scale_line_22_yuv_mmx_stub ( int *weights, int n_x, int n_y,
guchar *dest, int dest_x, guchar *dest_end,
guchar **src,
int x_init, int x_step, int src_width )
mmx_weights[ j ][ 7 ] = 0x00010001 * ( weights[ 4 * j + 3 ] >> 8 );
}
- return pixops_scale_line_22_33_mmx ( mmx_weights, dest, src[ 0 ], src[ 1 ], x_step, dest_end, x_init );
+ return pixops_scale_line_22_yuv_mmx ( mmx_weights, dest, src[ 0 ], src[ 1 ], x_step, dest_end, x_init, dest_x );
}
#endif /* USE_MMX */
static inline guchar *
-scale_line_22_33 ( int *weights, int n_x, int n_y,
+scale_line_22_yuv ( int *weights, int n_x, int n_y,
guchar *dest, int dest_x, guchar *dest_end,
guchar **src,
int x_init, int x_step, int src_width )
{
- int x = x_init;
- guchar *src0 = src[ 0 ];
- guchar *src1 = src[ 1 ];
- int dx = 0;
+ register int x = x_init;
+ register guchar *src0 = src[ 0 ];
+ register guchar *src1 = src[ 1 ];
+ register unsigned int p;
+ register guchar *q0, *q1;
+ register int w1, w2, w3, w4;
+ register int x_scaled, x_aligned, uv_index;
while ( dest < dest_end )
{
- unsigned int y, uv;
- int x_scaled = x >> SCALE_SHIFT;
- int *pixel_weights;
- guchar *q0, *q1;
- int w1, w2, w3, w4;
- int x_aligned = ( ( x_scaled >> 1 ) << 2 );
- int uv_index = ( ( dx & 1 ) << 1 ) + 1;
+ int *pixel_weights = weights + ( ( x >> ( SCALE_SHIFT - SUBSAMPLE_BITS ) ) & SUBSAMPLE_MASK ) * 4;
- pixel_weights = weights + ( ( x >> ( SCALE_SHIFT - SUBSAMPLE_BITS ) ) & SUBSAMPLE_MASK ) * 4;
+ x_scaled = x >> SCALE_SHIFT;
w1 = pixel_weights[ 0 ];
w2 = pixel_weights[ 1 ];
w3 = pixel_weights[ 2 ];
w4 = pixel_weights[ 3 ];
+ /* process Y */
q0 = src0 + ( x_scaled << 1 );
q1 = src1 + ( x_scaled << 1 );
+ p = w1 * q0[ 0 ];
+ p += w2 * q0[ 2 ];
+ p += w3 * q1[ 0 ];
+ p += w4 * q1[ 2 ];
+ *dest++ = ( p + 0x8000 ) >> SCALE_SHIFT;
- y = w1 * q0[ 0 ];
- y += w2 * q0[ 2 ];
- y += w3 * q1[ 0 ];
- y += w4 * q1[ 2 ];
- *dest++ = ( y + 0x8000 ) >> 16;
+ /* process U/V */
+ x_aligned = ( ( x_scaled >> 1 ) << 2 );
+ uv_index = ( ( dest_x & 1 ) << 1 ) + 1;
q0 = src0 + x_aligned;
q1 = src1 + x_aligned;
-
- uv = w1 * q0[ uv_index ];
- uv += w2 * q0[ uv_index ];
- uv += w3 * q1[ uv_index ];
- uv += w4 * q1[ uv_index ];
- *dest++ = ( uv + 0x8000 ) >> 16;
+ p = w1 * q0[ uv_index ];
+ p += w3 * q1[ uv_index ];
+ p += w2 * q0[ uv_index ];
+ p += w4 * q1[ uv_index ];
x += x_step;
- dx++;
+ dest_x ++;
+
+ *dest++ = ( p + 0x8000 ) >> SCALE_SHIFT;
}
return dest;
int x_start, int src_width )
{
register unsigned int y = 0, uv = 0;
- register int i, j, dx = 0;
+ register int i, j;
+ int uv_index = ( ( dest_x & 1 ) << 1 ) + 1;
for ( i = 0; i < n_y; i++ )
{
if ( x_start + j < 0 )
{
y += ta * src[ i ][ 0 ];
- uv += ta * src[ i ][ ( ( dx & 1 ) << 1 ) + 1 ];
+ uv += ta * src[ i ][ uv_index ];
}
else if ( x_start + j < src_width )
{
y += ta * src[ i ][ ( x_start + j ) << 1 ];
- uv += ta * src[ i ][ ( ( ( x_start + j ) >> 1 ) << 2) + ( ( dx & 1 ) << 1 ) + 1 ];
+ uv += ta * src[ i ][ ( ( ( x_start + j ) >> 1 ) << 2) + uv_index ];
}
else
{
y += ta * src[ i ][ ( src_width - 1 ) << 1 ];
- uv += ta * src[ i ][ ( ( ( src_width - 1 ) >> 1 ) << 2) + ( ( dx & 1 ) << 1 ) + 1 ];
+ uv += ta * src[ i ][ ( ( ( src_width - 1 ) >> 1 ) << 2) + uv_index ];
}
}
}
*dest++ = ( y + 0xffffff ) >> 24;
*dest++ = ( uv + 0xffffff ) >> 24;
- dx++;
}
x_start = x >> SCALE_SHIFT;
dest_x++;
outbuf += dest_channels;
-
- process_pixel ( run_weights + ( ( x >> ( SCALE_SHIFT - SUBSAMPLE_BITS ) ) & SUBSAMPLE_MASK ) * ( filter->x.n * filter->y.n ),
- filter->x.n, filter->y.n,
- outbuf, dest_x, dest_channels,
- line_bufs, src_channels,
- x >> SCALE_SHIFT, src_width );
-
- x += x_step;
- x_start = x >> SCALE_SHIFT;
- dest_x++;
- outbuf += dest_channels;
}
new_outbuf = ( *line_func ) ( run_weights, filter->x.n, filter->y.n,
double scale_y,
PixopsInterpType interp_type )
{
- PixopsFilter filter;
+ PixopsFilter filter = { { 0, 0, 0}, { 0, 0, 0 }, 0 };
PixopsLineFunc line_func;
-#ifdef USE_MMX
+#if defined(USE_MMX) && !defined(ARCH_X86_64)
gboolean found_mmx = pixops_have_mmx();
#endif
filter.overall_alpha = 1.0;
make_weights ( &filter, interp_type, scale_x, scale_y );
-//fprintf( stderr, "RESCALE: %d %d\n", filter.x.n, filter.y.n );
if ( filter.x.n == 2 && filter.y.n == 2 )
{
-#ifdef USE_MMX
- if ( 0 && found_mmx )
- line_func = scale_line_22_33_mmx_stub;
+#if defined(USE_MMX) && !defined(ARCH_X86_64)
+ if ( found_mmx )
+ {
+ //fprintf( stderr, "rescale: using mmx\n" );
+ line_func = scale_line_22_yuv_mmx_stub;
+ }
else
#endif
- line_func = scale_line_22_33;
+ line_func = scale_line_22_yuv;
}
else
line_func = scale_line;
projects / melted / blobdiff