themusicgod1
/
evacuated-infinity-plugin
1
0
Fork 0
Code Issues 14 Pull Requests Projects Releases Wiki Activity

Merge pull request #4 from CBke/pull-request#2 

Awesome! Thanks.
This commit is contained in:
Duilio Protti 2016-02-13 12:41:43 -03:00
parent 1abb212131 025ce0fbfd
commit 8584545b27
21 changed files with 1836 additions and 2435 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

498
src/compute.c
View File

@ -12,7 +12,7 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
*/
#include <math.h>
#include <glib.h>
@ -24,306 +24,302 @@
#endif
typedef struct t_coord {
gint32 x,y;
gint32 x, y;
} t_coord;
typedef struct t_complex {
gfloat x,y;
gfloat x, y;
} t_complex;
static t_screen_parameters scr_par;
static byte* surface1;
static byte* surface2;
static byte *surface1;
static byte *surface2;
static inline t_complex fct (t_complex a,guint32 n,gint32 p1,gint32 p2) /* p1 et p2:0-4 */
static inline t_complex fct(t_complex a, guint32 n, gint32 p1, gint32 p2) /* p1 et p2:0-4 */
{
t_complex b;
gfloat fact;
gfloat an;
gfloat circle_size;
gfloat speed;
gfloat co,si;
a.x-=scr_par.width/2;
a.y-=scr_par.height/2;
switch (n) {
case 0:
an=0.025*(p1-2)+0.002;
co=cos(an);
si=sin(an);
circle_size=scr_par.height*0.25;
speed=(gfloat)2000+p2*500;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
fact=-(sqrt(b.x*b.x+b.y*b.y)-circle_size)/speed+1;
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
case 1:
an=0.015*(p1-2)+0.002;
co=cos(an);
si=sin(an);
circle_size=scr_par.height*0.45;
speed=(gfloat)4000+p2*1000;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
fact=(sqrt(b.x*b.x+b.y*b.y)-circle_size)/speed+1;
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
case 2:
an=0.002;
co=cos(an);
si=sin(an);
circle_size=scr_par.height*0.25;
speed=(gfloat)400+p2*100;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
fact=-(sqrt(b.x*b.x+b.y*b.y)-circle_size)/speed+1;
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
case 3:
an=(sin(sqrt(a.x*a.x+a.y*a.y)/20)/20)+0.002;
co=cos(an);
si=sin(an);
circle_size=scr_par.height*0.25;
speed=(gfloat)4000;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
fact=-(sqrt(b.x*b.x+b.y*b.y)-circle_size)/speed+1;
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
case 4:
an=0.002;
co=cos(an);
si=sin(an);
circle_size=scr_par.height*0.25;
speed=sin(sqrt(a.x*a.x+a.y*a.y)/5)*3000+4000;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
fact=-(sqrt(b.x*b.x+b.y*b.y)-circle_size)/speed+1;
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
case 5:
b.x=a.x*1.02;
b.y=a.y*1.02;
break;
case 6:
an=0.002;
co=cos(an);
si=sin(an);
circle_size=scr_par.height*0.25;
fact=1+cos(atan(a.x/(a.y+0.00001))*6)*0.02;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
default:
b.x=(gfloat)0.0;
b.y=(gfloat)0.0;
}
b.x += scr_par.width/2;
b.y += scr_par.height/2;
if (b.x < 0.0 )
b.x = 0.0;
if (b.y < 0.0)
b.y = 0.0;
if (b.x > (gfloat) scr_par.width - 1)
b.x = (gfloat)scr_par.width - 1;
if (b.y > (gfloat) scr_par.height - 1)
b.y = (gfloat)scr_par.height - 1;
return b;
t_complex b;
gfloat fact;
gfloat an;
gfloat circle_size;
gfloat speed;
gfloat co, si;
a.x -= scr_par.width / 2;
a.y -= scr_par.height / 2;
switch (n) {
case 0:
an = 0.025 * (p1 - 2) + 0.002;
co = cos(an);
si = sin(an);
circle_size = scr_par.height * 0.25;
speed = (gfloat)2000 + p2 * 500;
b.x = (co * a.x - si * a.y);
b.y = (si * a.x + co * a.y);
fact = -(sqrt(b.x * b.x + b.y * b.y) - circle_size) / speed + 1;
b.x *= fact;
b.y *= fact;
break;
case 1:
an = 0.015 * (p1 - 2) + 0.002;
co = cos(an);
si = sin(an);
circle_size = scr_par.height * 0.45;
speed = (gfloat)4000 + p2 * 1000;
b.x = (co * a.x - si * a.y);
b.y = (si * a.x + co * a.y);
fact = (sqrt(b.x * b.x + b.y * b.y) - circle_size) / speed + 1;
b.x *= fact;
b.y *= fact;
break;
case 2:
an = 0.002;
co = cos(an);
si = sin(an);
circle_size = scr_par.height * 0.25;
speed = (gfloat)400 + p2 * 100;
b.x = (co * a.x - si * a.y);
b.y = (si * a.x + co * a.y);
fact = -(sqrt(b.x * b.x + b.y * b.y) - circle_size) / speed + 1;
b.x *= fact;
b.y *= fact;
break;
case 3:
an = (sin(sqrt(a.x * a.x + a.y * a.y) / 20) / 20) + 0.002;
co = cos(an);
si = sin(an);
circle_size = scr_par.height * 0.25;
speed = (gfloat)4000;
b.x = (co * a.x - si * a.y);
b.y = (si * a.x + co * a.y);
fact = -(sqrt(b.x * b.x + b.y * b.y) - circle_size) / speed + 1;
b.x *= fact;
b.y *= fact;
break;
case 4:
an = 0.002;
co = cos(an);
si = sin(an);
circle_size = scr_par.height * 0.25;
speed = sin(sqrt(a.x * a.x + a.y * a.y) / 5) * 3000 + 4000;
b.x = (co * a.x - si * a.y);
b.y = (si * a.x + co * a.y);
fact = -(sqrt(b.x * b.x + b.y * b.y) - circle_size) / speed + 1;
b.x *= fact;
b.y *= fact;
break;
case 5:
b.x = a.x * 1.02;
b.y = a.y * 1.02;
break;
case 6:
an = 0.002;
co = cos(an);
si = sin(an);
circle_size = scr_par.height * 0.25;
fact = 1 + cos(atan(a.x / (a.y + 0.00001)) * 6) * 0.02;
b.x = (co * a.x - si * a.y);
b.y = (si * a.x + co * a.y);
b.x *= fact;
b.y *= fact;
break;
default:
b.x = (gfloat)0.0;
b.y = (gfloat)0.0;
}
b.x += scr_par.width / 2;
b.y += scr_par.height / 2;
if (b.x < 0.0)
b.x = 0.0;
if (b.y < 0.0)
b.y = 0.0;
if (b.x > (gfloat)scr_par.width - 1)
b.x = (gfloat)scr_par.width - 1;
if (b.y > (gfloat)scr_par.height - 1)
b.y = (gfloat)scr_par.height - 1;
return b;
}
/* We are trusting here on vector_field != NULL !!! */
static inline void compute_generate_sector (guint32 g, guint32 f, guint32 p1, guint32 p2,
guint32 debut, guint32 step, vector_field_t *vector_field)
static inline void compute_generate_sector(guint32 g, guint32 f, guint32 p1, guint32 p2,
guint32 debut, guint32 step, vector_field_t *vector_field)
{
const guint32 width = (guint32) vector_field->width;
const guint32 height = (guint32) vector_field->height;
const guint32 prop_transmitted = 249;
const guint32 b_add = g * width * height;
t_interpol *vector = vector_field->vector;
guint32 fin = debut + step;
guint32 cx, cy;
const guint32 width = (guint32)vector_field->width;
const guint32 height = (guint32)vector_field->height;
const guint32 prop_transmitted = 249;
const guint32 b_add = g * width * height;
t_interpol *vector = vector_field->vector;
guint32 fin = debut + step;
guint32 cx, cy;
if (fin > height)
fin = height;
for (cy = debut; cy < fin; cy++) {
for (cx = 0; cx < width; cx++) {
t_complex a;
gfloat fpy;
guint32 rw, lw, add;
guint32 w1, w2, w3, w4;
guint32 x, y;
a.x = (gfloat) cx;
a.y = (gfloat) cy;
a = fct (a, f, p1, p2);
add = cx + cy * width;
x = (guint32) (a.x);
y = (guint32) (a.y);
vector[b_add+add].coord = (x << 16) | y;
if (fin > height)
fin = height;
for (cy = debut; cy < fin; cy++) {
for (cx = 0; cx < width; cx++) {
t_complex a;
gfloat fpy;
guint32 rw, lw, add;
guint32 w1, w2, w3, w4;
guint32 x, y;
fpy = a.y - floor (a.y);
rw = (guint32) ((a.x - floor (a.x)) * prop_transmitted);
lw = prop_transmitted - rw;
w4 = (guint32) (fpy * rw);
w2 = rw - w4;
w3 = (guint32) (fpy * lw);
w1 = lw - w3;
vector[b_add + add].weight = \
(w1 << 24) | (w2 << 16) | (w3 << 8) | w4;
a.x = (gfloat)cx;
a.y = (gfloat)cy;
a = fct(a, f, p1, p2);
add = cx + cy * width;
x = (guint32)(a.x);
y = (guint32)(a.y);
vector[b_add + add].coord = (x << 16) | y;
fpy = a.y - floor(a.y);
rw = (guint32)((a.x - floor(a.x)) * prop_transmitted);
lw = prop_transmitted - rw;
w4 = (guint32)(fpy * rw);
w2 = rw - w4;
w3 = (guint32)(fpy * lw);
w1 = lw - w3;
vector[b_add + add].weight = \
(w1 << 24) | (w2 << 16) | (w3 << 8) | w4;
}
}
}
}
/*
* Public functions
*/
void compute_init (void)
void compute_init(void)
{
scr_par.width = config_get_xres();
scr_par.height = config_get_yres();
scr_par.scale = config_get_sres();
scr_par.width = config_get_xres();
scr_par.height = config_get_yres();
scr_par.scale = config_get_sres();
surface1 = (byte*) g_malloc ((gulong)(scr_par.width+1) * (scr_par.height+1));
surface2 = (byte*) g_malloc ((gulong)(scr_par.width+1) * (scr_par.height+1));
surface1 = (byte *)g_malloc((gulong)(scr_par.width + 1) * (scr_par.height + 1));
surface2 = (byte *)g_malloc((gulong)(scr_par.width + 1) * (scr_par.height + 1));
}
void compute_resize (gint32 width, gint32 height)
void compute_resize(gint32 width, gint32 height)
{
scr_par.width = width;
scr_par.height = height;
g_free (surface1);
g_free (surface2);
surface1 = (byte*) g_malloc ((gulong)(scr_par.width+1) * (scr_par.height+1));
surface2 = (byte*) g_malloc ((gulong)(scr_par.width+1) * (scr_par.height+1));
scr_par.width = width;
scr_par.height = height;
g_free(surface1);
g_free(surface2);
surface1 = (byte *)g_malloc((gulong)(scr_par.width + 1) * (scr_par.height + 1));
surface2 = (byte *)g_malloc((gulong)(scr_par.width + 1) * (scr_par.height + 1));
}
vector_field_t *compute_vector_field_new (gint32 width, gint32 height)
vector_field_t *compute_vector_field_new(gint32 width, gint32 height)
{
vector_field_t *field;
vector_field_t *field;
field = g_new0 (vector_field_t, 1);
field->vector = g_new0 (t_interpol, width * height * NB_FCT);
field->width = width;
field->height = height;
return field;
field = g_new0(vector_field_t, 1);
field->vector = g_new0(t_interpol, width * height * NB_FCT);
field->width = width;
field->height = height;
return field;
}
void compute_vector_field_destroy (vector_field_t *vector_field)
void compute_vector_field_destroy(vector_field_t *vector_field)
{
g_return_if_fail (vector_field != NULL);
g_return_if_fail(vector_field != NULL);
g_free (vector_field->vector);
g_free (vector_field);
vector_field = NULL;
g_free(vector_field->vector);
g_free(vector_field);
vector_field = NULL;
}
void compute_quit ()
void compute_quit()
{
g_free (surface1);
g_free (surface2);
g_free(surface1);
g_free(surface2);
}
void compute_generate_vector_field (vector_field_t *vector_field)
void compute_generate_vector_field(vector_field_t *vector_field)
{
guint32 f, i, height;
guint32 f, i, height;
g_return_if_fail (vector_field != NULL);
g_return_if_fail (vector_field->height >= 0);
g_return_if_fail(vector_field != NULL);
g_return_if_fail(vector_field->height >= 0);
height = (guint32) vector_field->height;
height = (guint32)vector_field->height;
for (f = 0; f < NB_FCT; f++) {
for (i = 0; i < height; i += 10)
compute_generate_sector (f, f, 2, 2, i, 10, vector_field);
}
for (f = 0; f < NB_FCT; f++)
for (i = 0; i < height; i += 10)
compute_generate_sector(f, f, 2, 2, i, 10, vector_field);
}
inline byte *compute_surface (t_interpol* vector, gint32 width, gint32 height)
inline byte *compute_surface(t_interpol *vector, gint32 width, gint32 height)
{
gint32 i,j;
gint32 add_dest=0;
guint32 add_src;
t_interpol *interpol;
register byte* ptr_pix;
guint32 color;
byte* ptr_swap;
for (j = 0; j < height; j++)
for (i = 0; i < width; i++) {
interpol = &vector[add_dest];
add_src = (interpol->coord & 0xFFFF) * width + (interpol->coord >> 16);
ptr_pix = &((byte*)surface1)[add_src];
color = ((guint32)(*(ptr_pix)) * (interpol->weight >> 24)
+ (guint32)(*(ptr_pix+1)) * ((interpol->weight & 0xFFFFFF) >> 16)
+ (guint32)(*(ptr_pix+width)) * ((interpol->weight & 0xFFFF) >> 8)
+ (guint32)(*(ptr_pix+width+1)) * (interpol->weight & 0xFF)) >> 8;
if (color > 255)
surface2[add_dest] = (byte)255;
else
surface2[add_dest] = (byte)color;
add_dest++;
}
ptr_swap = surface2;
surface2 = surface1;
surface1 = ptr_swap;
gint32 i, j;
gint32 add_dest = 0;
guint32 add_src;
t_interpol *interpol;
register byte *ptr_pix;
guint32 color;
byte *ptr_swap;
return surface1;
for (j = 0; j < height; j++)
for (i = 0; i < width; i++) {
interpol = &vector[add_dest];
add_src = (interpol->coord & 0xFFFF) * width + (interpol->coord >> 16);
ptr_pix = &((byte *)surface1)[add_src];
color = ((guint32)(*(ptr_pix)) * (interpol->weight >> 24)
+ (guint32)(*(ptr_pix + 1)) * ((interpol->weight & 0xFFFFFF) >> 16)
+ (guint32)(*(ptr_pix + width)) * ((interpol->weight & 0xFFFF) >> 8)
+ (guint32)(*(ptr_pix + width + 1)) * (interpol->weight & 0xFF)) >> 8;
if (color > 255)
surface2[add_dest] = (byte)255;
else
surface2[add_dest] = (byte)color;
add_dest++;
}
ptr_swap = surface2;
surface2 = surface1;
surface1 = ptr_swap;
return surface1;
}
#if MMX_DETECTION
inline byte *compute_surface_mmx (t_interpol* vector, gint32 width, gint32 height)
inline byte *compute_surface_mmx(t_interpol *vector, gint32 width, gint32 height)
{
/*@unused@*/
volatile mmx_t mm0, mm1, mm2;
volatile mmx_t offsets, r;
t_interpol *interpol;
gint32 i, j, color;
gint32 add_dest = 0;
guint32 add_src;
register byte* ptr_pix;
byte* ptr_swap;
for (j = 0; j < height; j++)
for (i = 0; i < width; i++) {
interpol = &vector[add_dest];
add_src = (interpol->coord & 0xFFFF) * width + (interpol->coord >> 16);
ptr_pix = &((byte*)surface1)[add_src];
((guint16*)&offsets)[0] = (guint16)*(ptr_pix+width+1);
((guint16*)&offsets)[1] = (guint16)*(ptr_pix+width);
((guint16*)&offsets)[2] = (guint16)*(ptr_pix+1);
((guint16*)&offsets)[3] = (guint16)*(ptr_pix);
/* MMX mode entry */
movd_m2r(interpol->weight, mm1);
movq_m2r(offsets, mm2);
pxor_r2r(mm0, mm0);
punpcklbw_r2r(mm0, mm1);
pmaddwd_r2r(mm1, mm2);
movq_r2m(mm2, r);
emms();
/* MMX mode exit */
color = (((gint32*)&r)[0] + ((gint32*)&r)[1] ) >> 8;
if (color > 255)
surface2[add_dest] = 255;
else
surface2[add_dest] = (byte)color;
add_dest++;
}
ptr_swap = surface1;
surface1 = surface2;
surface2 = ptr_swap;
return surface1;
/*@unused@*/
volatile mmx_t mm0, mm1, mm2;
volatile mmx_t offsets, r;
t_interpol *interpol;
gint32 i, j, color;
gint32 add_dest = 0;
guint32 add_src;
register byte *ptr_pix;
byte *ptr_swap;
for (j = 0; j < height; j++)
for (i = 0; i < width; i++) {
interpol = &vector[add_dest];
add_src = (interpol->coord & 0xFFFF) * width + (interpol->coord >> 16);
ptr_pix = &((byte *)surface1)[add_src];
((guint16 *)&offsets)[0] = (guint16) * (ptr_pix + width + 1);
((guint16 *)&offsets)[1] = (guint16) * (ptr_pix + width);
((guint16 *)&offsets)[2] = (guint16) * (ptr_pix + 1);
((guint16 *)&offsets)[3] = (guint16) * (ptr_pix);
/* MMX mode entry */
movd_m2r(interpol->weight, mm1);
movq_m2r(offsets, mm2);
pxor_r2r(mm0, mm0);
punpcklbw_r2r(mm0, mm1);
pmaddwd_r2r(mm1, mm2);
movq_r2m(mm2, r);
emms();
/* MMX mode exit */
color = (((gint32 *)&r)[0] + ((gint32 *)&r)[1]) >> 8;
if (color > 255)
surface2[add_dest] = 255;
else
surface2[add_dest] = (byte)color;
add_dest++;
}
ptr_swap = surface1;
surface1 = surface2;
surface2 = ptr_swap;
return surface1;
}
#endif /* MMX_DETECTION */

36
src/compute.h
View File

@ -19,8 +19,8 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __INFINITY_COMPUTE__
*/
#ifndef __INFINITY_COMPUTE__
#define __INFINITY_COMPUTE__
@ -35,10 +35,8 @@
* Represents the interpollation information.
*/
typedef struct {
guint32 coord ; /**< Coordinates of the top left pixel. */
guint32 weight; /**< 32 bits = 4*8 = weights of the four corners */
guint32 coord; /**< Coordinates of the top left pixel. */
guint32 weight; /**< 32 bits = 4*8 = weights of the four corners */
} t_interpol;
@ -50,11 +48,9 @@ typedef struct {
* because this is actually not true.
*/
typedef struct {
gint32 width; /**< number of vectors */
gint32 height; /**< length of each vector */
t_interpol *vector; /**< pointer to the vector field */
gint32 width; /**< number of vectors */
gint32 height; /**< length of each vector */
t_interpol * vector; /**< pointer to the vector field */
} vector_field_t;
@ -62,20 +58,20 @@ typedef struct {
/*
* The constructor of the ::vector_field_t type.
*/
vector_field_t *compute_vector_field_new (int width, int height);
vector_field_t *compute_vector_field_new(int width, int height);
/**
* The destructor of the ::vector_field_t type.
*
* @param vector_field Must be non NULL pointer to a
* @param vector_field Must be non NULL pointer to a
* ::vector_field_t object.
*/
void compute_vector_field_destroy (vector_field_t *vector_field);
void compute_vector_field_destroy(vector_field_t *vector_field);
/**
* It frees any allocated resource and mades clenaup work.
*/
void compute_quit (void);
void compute_quit(void);
/**
* Initializes this module.
@ -85,19 +81,19 @@ void compute_quit (void);
* change, the module must be reinitialized in order to the
* changes take effect.
*/
void compute_init (void);
void compute_init(void);
/**
* Tells the module that the screen has been resized.
*
* \warning May be this will be deprecated.
*/
void compute_resize (gint32 width, gint32 height);
void compute_resize(gint32 width, gint32 height);
void compute_generate_vector_field (vector_field_t *vector_field);
void compute_generate_vector_field(vector_field_t *vector_field);
byte *compute_surface (t_interpol* vector, gint32 width, gint32 height);
byte *compute_surface_mmx (t_interpol* vector, gint32 width, gint32 height);
byte *compute_surface(t_interpol *vector, gint32 width, gint32 height);
byte *compute_surface_mmx(t_interpol *vector, gint32 width, gint32 height);
#endif /* __INFINITY_COMPUTE__ */

420
src/config-dialog.c
View File

@ -3,260 +3,260 @@
#include "gettext.h"
ConfigDialog* config_dialog_new (void)
ConfigDialog *config_dialog_new(void)
{
ConfigDialog *config_win;
GtkTooltips *tooltips;
ConfigDialog *config_win;
GtkTooltips *tooltips;
GtkWidget *window_main;
GtkWidget *vbox_main;
GtkWidget *label_scale_factor;
GtkWidget *hscale_scale_factor;
GtkWidget *frame_general;
GtkWidget *table_general;
GtkWidget *label_effect;
GtkWidget *label_palette;
GtkWidget *label_fps;
GtkWidget *checkbutton_show_title;
GtkWidget *hscale_effect;
GtkWidget *hscale_palette;
GtkObject *spinbutton_fps_adj;
GtkWidget *spinbutton_fps;
GtkWidget *hbuttonbox_main;
GtkWidget *button_ok;
GtkWidget *button_cancel;
GtkWidget *button_apply;
GtkWidget *window_main;
GtkWidget *vbox_main;
GtkWidget *label_scale_factor;
GtkWidget *hscale_scale_factor;
GtkWidget *frame_general;
GtkWidget *table_general;
GtkWidget *label_effect;
GtkWidget *label_palette;
GtkWidget *label_fps;
GtkWidget *checkbutton_show_title;
GtkWidget *hscale_effect;
GtkWidget *hscale_palette;
GtkObject *spinbutton_fps_adj;
GtkWidget *spinbutton_fps;
GtkWidget *hbuttonbox_main;
GtkWidget *button_ok;
GtkWidget *button_cancel;
GtkWidget *button_apply;
#if ENABLE_NLS
setlocale (LC_MESSAGES, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
textdomain (GETTEXT_PACKAGE);
setlocale(LC_MESSAGES, "");
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
textdomain(GETTEXT_PACKAGE);
#endif
window_main = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (window_main), "window_main", window_main);
gtk_window_set_title (GTK_WINDOW (window_main), _("Infinity Configuration"));
gtk_window_set_type_hint (GTK_WINDOW (window_main), GDK_WINDOW_TYPE_HINT_DIALOG);
window_main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_object_set_data(GTK_OBJECT(window_main), "window_main", window_main);
gtk_window_set_title(GTK_WINDOW(window_main), _("Infinity Configuration"));
gtk_window_set_type_hint(GTK_WINDOW(window_main), GDK_WINDOW_TYPE_HINT_DIALOG);
vbox_main = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox_main);
gtk_object_set_data_full (GTK_OBJECT (window_main), "vbox_main", vbox_main,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox_main);
gtk_container_add (GTK_CONTAINER (window_main), vbox_main);
gtk_container_set_border_width (GTK_CONTAINER (vbox_main), 2);
vbox_main = gtk_vbox_new(FALSE, 0);
gtk_widget_ref(vbox_main);
gtk_object_set_data_full(GTK_OBJECT(window_main), "vbox_main", vbox_main,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(vbox_main);
gtk_container_add(GTK_CONTAINER(window_main), vbox_main);
gtk_container_set_border_width(GTK_CONTAINER(vbox_main), 2);
frame_general = gtk_frame_new (_("Parameters"));
gtk_widget_ref (frame_general);
gtk_object_set_data_full (GTK_OBJECT (window_main), "frame_general", frame_general,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame_general);
gtk_box_pack_start (GTK_BOX (vbox_main), frame_general, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_general), 2);
frame_general = gtk_frame_new(_("Parameters"));
gtk_widget_ref(frame_general);
gtk_object_set_data_full(GTK_OBJECT(window_main), "frame_general", frame_general,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(frame_general);
gtk_box_pack_start(GTK_BOX(vbox_main), frame_general, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame_general), 2);
table_general = gtk_table_new (5, 3, FALSE);
gtk_widget_ref (table_general);
gtk_object_set_data_full (GTK_OBJECT (window_main), "table_general", table_general,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table_general);
gtk_container_add (GTK_CONTAINER (frame_general), table_general);
gtk_container_set_border_width (GTK_CONTAINER (table_general), 2);
gtk_table_set_row_spacings (GTK_TABLE (table_general), 2);
gtk_table_set_col_spacings (GTK_TABLE (table_general), 2);
table_general = gtk_table_new(5, 3, FALSE);
gtk_widget_ref(table_general);
gtk_object_set_data_full(GTK_OBJECT(window_main), "table_general", table_general,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(table_general);
gtk_container_add(GTK_CONTAINER(frame_general), table_general);
gtk_container_set_border_width(GTK_CONTAINER(table_general), 2);
gtk_table_set_row_spacings(GTK_TABLE(table_general), 2);
gtk_table_set_col_spacings(GTK_TABLE(table_general), 2);
label_effect = gtk_label_new (_("Effect period:"));
gtk_widget_ref (label_effect);
gtk_object_set_data_full (GTK_OBJECT (window_main), "label_effect", label_effect,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_effect);
gtk_table_attach (GTK_TABLE (table_general), label_effect, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_effect), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label_effect), 1, 0);
label_effect = gtk_label_new(_("Effect period:"));
gtk_widget_ref(label_effect);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_effect", label_effect,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_effect);
gtk_table_attach(GTK_TABLE(table_general), label_effect, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_effect), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_effect), 1, 0);
label_palette = gtk_label_new (_("Palette period:"));
gtk_widget_ref (label_palette);
gtk_object_set_data_full (GTK_OBJECT (window_main), "label_palette", label_palette,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_palette);
gtk_table_attach (GTK_TABLE (table_general), label_palette, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_palette), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label_palette), 1, 0);
label_palette = gtk_label_new(_("Palette period:"));
gtk_widget_ref(label_palette);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_palette", label_palette,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_palette);
gtk_table_attach(GTK_TABLE(table_general), label_palette, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_palette), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_palette), 1, 0);
label_scale_factor = gtk_label_new (_("Scale Factor"));
gtk_widget_ref (label_scale_factor);
gtk_object_set_data_full (GTK_OBJECT (window_main), "label_scale_factor", label_scale_factor,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_scale_factor);
gtk_table_attach (GTK_TABLE (table_general), label_scale_factor, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_scale_factor), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label_scale_factor), 1, 0);
label_scale_factor = gtk_label_new(_("Scale Factor"));
gtk_widget_ref(label_scale_factor);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_scale_factor", label_scale_factor,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_scale_factor);
gtk_table_attach(GTK_TABLE(table_general), label_scale_factor, 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_scale_factor), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_scale_factor), 1, 0);
label_fps = gtk_label_new (_("Maximum Frames per Second:"));
gtk_widget_ref (label_fps);
gtk_object_set_data_full (GTK_OBJECT (window_main), "label_fps", label_fps,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_fps);
gtk_table_attach (GTK_TABLE (table_general), label_fps, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_fps), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label_fps), 1, 0);
label_fps = gtk_label_new(_("Maximum Frames per Second:"));
gtk_widget_ref(label_fps);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_fps", label_fps,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_fps);
gtk_table_attach(GTK_TABLE(table_general), label_fps, 0, 1, 3, 4,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_fps), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_fps), 1, 0);
checkbutton_show_title = gtk_check_button_new_with_label (_("Show current play title"));
gtk_widget_ref (checkbutton_show_title);
gtk_object_set_data_full (GTK_OBJECT (window_main), "checkbutton_show_title", checkbutton_show_title,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (checkbutton_show_title);
gtk_table_attach (GTK_TABLE (table_general), checkbutton_show_title, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
checkbutton_show_title = gtk_check_button_new_with_label(_("Show current play title"));
gtk_widget_ref(checkbutton_show_title);
gtk_object_set_data_full(GTK_OBJECT(window_main), "checkbutton_show_title", checkbutton_show_title,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(checkbutton_show_title);
gtk_table_attach(GTK_TABLE(table_general), checkbutton_show_title, 0, 1, 4, 5,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
tooltips = gtk_tooltips_new ();
gtk_tooltips_set_tip (tooltips, checkbutton_show_title,
_("Check it if you want to see the current play "
"title on the Infinity's title bar"), NULL);
tooltips = gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips, checkbutton_show_title,
_("Check it if you want to see the current play "
"title on the Infinity's title bar"), NULL);
//spinbutton_fps_adj = gtk_adjustment_new (30, 5, 150, 1, 10, 0);
spinbutton_fps_adj = gtk_adjustment_new (config_get_fps(), 5, 150, 1, 10, 0);
spinbutton_fps = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_fps_adj), 1, 0);
gtk_widget_ref (spinbutton_fps);
gtk_object_set_data_full (GTK_OBJECT (window_main), "spinbutton_fps", spinbutton_fps,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (spinbutton_fps);
gtk_table_attach (GTK_TABLE (table_general), spinbutton_fps, 2, 3, 3, 4,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinbutton_fps), GTK_UPDATE_IF_VALID);
//spinbutton_fps_adj = gtk_adjustment_new (30, 5, 150, 1, 10, 0);
spinbutton_fps_adj = gtk_adjustment_new(config_get_fps(), 5, 150, 1, 10, 0);
spinbutton_fps = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_fps_adj), 1, 0);
gtk_widget_ref(spinbutton_fps);
gtk_object_set_data_full(GTK_OBJECT(window_main), "spinbutton_fps", spinbutton_fps,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(spinbutton_fps);
gtk_table_attach(GTK_TABLE(table_general), spinbutton_fps, 2, 3, 3, 4,
(GtkAttachOptions)(0),
(GtkAttachOptions)(0), 0, 0);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spinbutton_fps), GTK_UPDATE_IF_VALID);
hscale_effect = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (100, 50, 400, 0, 0, 0)));
gtk_widget_ref (hscale_effect);
gtk_object_set_data_full (GTK_OBJECT (window_main), "hscale_effect", hscale_effect,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hscale_effect);
gtk_table_attach (GTK_TABLE (table_general), hscale_effect, 1, 3, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscale_effect), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (hscale_effect), 0);
hscale_effect = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(100, 50, 400, 0, 0, 0)));
gtk_widget_ref(hscale_effect);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_effect", hscale_effect,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_effect);
gtk_table_attach(GTK_TABLE(table_general), hscale_effect, 1, 3, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_effect), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_effect), 0);
gtk_tooltips_set_tip (tooltips, hscale_effect,
_("Time to change between an effect and the "
"next one, in milliseconds."), NULL);
gtk_tooltips_set_tip(tooltips, hscale_effect,
_("Time to change between an effect and the "
"next one, in milliseconds."), NULL);
hscale_palette = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (100, 50, 400, 0, 0, 0)));
gtk_widget_ref (hscale_palette);
gtk_object_set_data_full (GTK_OBJECT (window_main), "hscale_palette", hscale_palette,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hscale_palette);
gtk_table_attach (GTK_TABLE (table_general), hscale_palette, 1, 3, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscale_palette), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (hscale_palette), 0);
hscale_palette = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(100, 50, 400, 0, 0, 0)));
gtk_widget_ref(hscale_palette);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_palette", hscale_palette,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_palette);
gtk_table_attach(GTK_TABLE(table_general), hscale_palette, 1, 3, 1, 2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_palette), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_palette), 0);
gtk_tooltips_set_tip (tooltips, hscale_palette,
_("Time to change between a color and the "
"next one, in milliseconds."), NULL);
gtk_tooltips_set_tip(tooltips, hscale_palette,
_("Time to change between a color and the "
"next one, in milliseconds."), NULL);
hscale_scale_factor = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 1, 2, 0, 0, 0)));
gtk_widget_ref (hscale_scale_factor);
gtk_object_set_data_full (GTK_OBJECT (window_main), "hscale_scale_factor", hscale_scale_factor,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hscale_scale_factor);
gtk_table_attach (GTK_TABLE (table_general), hscale_scale_factor, 1, 3, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscale_scale_factor), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (hscale_scale_factor), 0);
hscale_scale_factor = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(1, 1, 2, 0, 0, 0)));
gtk_widget_ref(hscale_scale_factor);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_scale_factor", hscale_scale_factor,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_scale_factor);
gtk_table_attach(GTK_TABLE(table_general), hscale_scale_factor, 1, 3, 2, 3,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_scale_factor), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_scale_factor), 0);
gtk_tooltips_set_tip (tooltips, hscale_scale_factor,
_("Change only if the system doesn't have "
"enough power to show the screen at "
"a reasonably speed/size relation."), NULL);
gtk_tooltips_set_tip(tooltips, hscale_scale_factor,
_("Change only if the system doesn't have "
"enough power to show the screen at "
"a reasonably speed/size relation."), NULL);
hbuttonbox_main = gtk_hbutton_box_new ();
gtk_widget_ref (hbuttonbox_main);
gtk_object_set_data_full (GTK_OBJECT (window_main), "hbuttonbox_main", hbuttonbox_main,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbuttonbox_main);
gtk_box_pack_start (GTK_BOX (vbox_main), hbuttonbox_main, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox_main), 2);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox_main), GTK_BUTTONBOX_END);
hbuttonbox_main = gtk_hbutton_box_new();
gtk_widget_ref(hbuttonbox_main);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hbuttonbox_main", hbuttonbox_main,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hbuttonbox_main);
gtk_box_pack_start(GTK_BOX(vbox_main), hbuttonbox_main, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbuttonbox_main), 2);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox_main), GTK_BUTTONBOX_END);
button_ok = gtk_button_new_with_label (_("Ok"));
gtk_widget_ref (button_ok);
gtk_object_set_data_full (GTK_OBJECT (window_main), "button_ok", button_ok,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_ok);
gtk_container_add (GTK_CONTAINER (hbuttonbox_main), button_ok);
GTK_WIDGET_SET_FLAGS (button_ok, GTK_CAN_DEFAULT);
button_ok = gtk_button_new_with_label(_("Ok"));
gtk_widget_ref(button_ok);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_ok", button_ok,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_ok);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_ok);
GTK_WIDGET_SET_FLAGS(button_ok, GTK_CAN_DEFAULT);
gtk_tooltips_set_tip (tooltips, button_ok,
_("For to toggle to fullscreen mode, select "
"the Infinity plugin window, and press "
"the Tab key. Pressing Tab again will return "
"to window mode."), NULL);
gtk_tooltips_set_tip(tooltips, button_ok,
_("For to toggle to fullscreen mode, select "
"the Infinity plugin window, and press "
"the Tab key. Pressing Tab again will return "
"to window mode."), NULL);
button_cancel = gtk_button_new_with_label (_("Cancel"));
gtk_widget_ref (button_cancel);
gtk_object_set_data_full (GTK_OBJECT (window_main), "button_cancel", button_cancel,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_cancel);
gtk_container_add (GTK_CONTAINER (hbuttonbox_main), button_cancel);
GTK_WIDGET_SET_FLAGS (button_cancel, GTK_CAN_DEFAULT);
button_cancel = gtk_button_new_with_label(_("Cancel"));
gtk_widget_ref(button_cancel);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_cancel", button_cancel,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_cancel);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_cancel);
GTK_WIDGET_SET_FLAGS(button_cancel, GTK_CAN_DEFAULT);
button_apply = gtk_button_new_with_label (_("Apply"));
gtk_widget_ref (button_apply);
gtk_object_set_data_full (GTK_OBJECT (window_main), "button_apply", button_apply,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_apply);
gtk_container_add (GTK_CONTAINER (hbuttonbox_main), button_apply);
GTK_WIDGET_SET_FLAGS (button_apply, GTK_CAN_DEFAULT);
button_apply = gtk_button_new_with_label(_("Apply"));
gtk_widget_ref(button_apply);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_apply", button_apply,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_apply);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_apply);
GTK_WIDGET_SET_FLAGS(button_apply, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button_cancel);
gtk_widget_grab_default(button_cancel);
config_win = g_new0 (ConfigDialog, 1);
config_win = g_new0(ConfigDialog, 1);
config_win->window_main = window_main;
config_win->window_main = window_main;
config_win->hscale_effect = hscale_effect;
config_win->hscale_palette = hscale_palette;
config_win->hscale_scale_factor = hscale_scale_factor;
config_win->spinbutton_fps = spinbutton_fps;
config_win->checkbutton_show_title = checkbutton_show_title;
config_win->hscale_effect = hscale_effect;
config_win->hscale_palette = hscale_palette;
config_win->hscale_scale_factor = hscale_scale_factor;
config_win->spinbutton_fps = spinbutton_fps;
config_win->checkbutton_show_title = checkbutton_show_title;
config_win->button_ok = button_ok;
config_win->button_cancel = button_cancel;
config_win->button_apply = button_apply;
config_win->button_ok = button_ok;
config_win->button_cancel = button_cancel;
config_win->button_apply = button_apply;
gtk_tooltips_enable (tooltips);
gtk_tooltips_enable(tooltips);
return config_win;
return config_win;
}
void config_dialog_destroy (ConfigDialog *dialog)
void config_dialog_destroy(ConfigDialog *dialog)
{
g_return_if_fail (dialog != NULL);
g_return_if_fail(dialog != NULL);
g_free (dialog);
g_free(dialog);
}
void config_dialog_show (ConfigDialog *dialog)
void config_dialog_show(ConfigDialog *dialog)
{
g_return_if_fail (dialog != NULL);
g_return_if_fail(dialog != NULL);
gtk_window_present (GTK_WINDOW(dialog->window_main));
gtk_window_present(GTK_WINDOW(dialog->window_main));
}
void config_dialog_hide (ConfigDialog *dialog)
void config_dialog_hide(ConfigDialog *dialog)
{
g_return_if_fail (dialog != NULL);
g_return_if_fail(dialog != NULL);
gtk_widget_hide (dialog->window_main);
gtk_widget_hide(dialog->window_main);
}

32
src/config-dialog.h
View File

@ -9,28 +9,26 @@
* Here we have all the widgets of config dialog we need to interact to.
*/
typedef struct {
GtkWidget * window_main;
GtkWidget *window_main;
/* General stuff */
GtkWidget *hscale_effect; /**< GtkHScale */
GtkWidget *hscale_palette; /**< GtkHScale */
GtkWidget *hscale_scale_factor; /**< GtkHScale */
GtkWidget *spinbutton_fps; /**< GtkSpinButton */
GtkWidget *checkbutton_show_title; /** GtkCheckButton */
/* Buttons */
GtkWidget *button_ok; /**< GtkButton */
GtkWidget *button_cancel; /**< GtkButton */
GtkWidget *button_apply; /**< GtkButton */
/* General stuff */
GtkWidget * hscale_effect; /**< GtkHScale */
GtkWidget * hscale_palette; /**< GtkHScale */
GtkWidget * hscale_scale_factor; /**< GtkHScale */
GtkWidget * spinbutton_fps; /**< GtkSpinButton */
GtkWidget * checkbutton_show_title; /** GtkCheckButton */
/* Buttons */
GtkWidget * button_ok; /**< GtkButton */
GtkWidget * button_cancel; /**< GtkButton */
GtkWidget * button_apply; /**< GtkButton */
} ConfigDialog;
ConfigDialog* config_dialog_new (void);
void config_dialog_destroy (ConfigDialog *dialog);
ConfigDialog *config_dialog_new(void);
void config_dialog_destroy(ConfigDialog *dialog);
void config_dialog_show (ConfigDialog *dialog);
void config_dialog_hide (ConfigDialog *dialog);
void config_dialog_show(ConfigDialog *dialog);
void config_dialog_hide(ConfigDialog *dialog);
#endif

288
src/cputest.c
View File

@ -6,153 +6,152 @@
/* ebx saving is necessary for PIC. gcc seems unable to see it alone */
#if MMX_DETECTION
#define cpuid(index,eax,ebx,ecx,edx)\
__asm __volatile\
("movl %%ebx, %%esi\n\t"\
"cpuid\n\t"\
"xchgl %%ebx, %%esi"\
: "=a" (eax), "=S" (ebx),\
"=c" (ecx), "=d" (edx)\
: "0" (index));
#define cpuid(index, eax, ebx, ecx, edx) \
__asm __volatile \
("movl %%ebx, %%esi\n\t" \
"cpuid\n\t" \
"xchgl %%ebx, %%esi" \
: "=a" (eax), "=S" (ebx), \
"=c" (ecx), "=d" (edx) \
: "0" (index));
#endif
/* Function to test if multimedia instructions are supported... */
int mm_support (void)
int mm_support(void)
{
#if MMX_DETECTION
int rval;
int eax, ebx, ecx, edx;
__asm__ __volatile__ (
/* See if CPUID instruction is supported ... */
/* ... Get copies of EFLAGS into eax and ecx */
"pushf\n\t"
"popl %0\n\t"
"movl %0, %1\n\t"
/* ... Toggle the ID bit in one copy and store */
/* to the EFLAGS reg */
"xorl $0x200000, %0\n\t"
"push %0\n\t"
"popf\n\t"
/* ... Get the (hopefully modified) EFLAGS */
"pushf\n\t"
"popl %0\n\t"
: "=a" (eax), "=c" (ecx)
:
: "cc"
);
if (eax == ecx)
return 0; /* CPUID not supported */
cpuid(0, eax, ebx, ecx, edx);
int rval;
int eax, ebx, ecx, edx;
if (ebx == 0x756e6547 &&
edx == 0x49656e69 &&
ecx == 0x6c65746e) {
/* intel */
inteltest:
cpuid(1, eax, ebx, ecx, edx);
if ((edx & 0x00800000) == 0)
return 0;
rval = MM_MMX;
if (edx & 0x02000000)
rval |= MM_MMXEXT | MM_SSE;
if (edx & 0x04000000)
rval |= MM_SSE2;
return rval;
} else if (ebx == 0x68747541 &&
edx == 0x69746e65 &&
ecx == 0x444d4163) {
/* AMD */
cpuid(0x80000000, eax, ebx, ecx, edx);
if ((guint32)eax < 0x80000001)
goto inteltest;
cpuid(0x80000001, eax, ebx, ecx, edx);
if ((edx & 0x00800000) == 0)
return 0;
rval = MM_MMX;
if (edx & 0x80000000)
rval |= MM_3DNOW;
if (edx & 0x00400000)
rval |= MM_MMXEXT;
return rval;
} else if (ebx == 0x746e6543 &&
edx == 0x48727561 &&
ecx == 0x736c7561) { /* "CentaurHauls" */
/* VIA C3 */
cpuid(0x80000000, eax, ebx, ecx, edx);
if ((guint32)eax < 0x80000001)
goto inteltest;
cpuid(0x80000001, eax, ebx, ecx, edx);
rval = 0;
if( edx & ( 1 << 31) )
rval |= MM_3DNOW;
if( edx & ( 1 << 23) )
rval |= MM_MMX;
if( edx & ( 1 << 24) )
rval |= MM_MMXEXT;
return rval;
} else if (ebx == 0x69727943 &&
edx == 0x736e4978 &&
ecx == 0x64616574) {
/* Cyrix Section */
/* See if extended CPUID level 80000001 is supported */
/* The value of CPUID/80000001 for the 6x86MX is undefined
according to the Cyrix CPU Detection Guide (Preliminary
Rev. 1.01 table 1), so we'll check the value of eax for
CPUID/0 to see if standard CPUID level 2 is supported.
According to the table, the only CPU which supports level
2 is also the only one which supports extended CPUID levels.
*/
if (eax != 2)
goto inteltest;
cpuid(0x80000001, eax, ebx, ecx, edx);
if ((eax & 0x00800000) == 0)
return 0;
rval = MM_MMX;
if (eax & 0x01000000)
rval |= MM_MMXEXT;
return rval;
} else {
return 0;
}
#else /* not MMX_DETECTION */
return 0;
__asm__ __volatile__ (
/* See if CPUID instruction is supported ... */
/* ... Get copies of EFLAGS into eax and ecx */
"pushf\n\t"
"popl %0\n\t"
"movl %0, %1\n\t"
/* ... Toggle the ID bit in one copy and store */
/* to the EFLAGS reg */
"xorl $0x200000, %0\n\t"
"push %0\n\t"
"popf\n\t"
/* ... Get the (hopefully modified) EFLAGS */
"pushf\n\t"
"popl %0\n\t"
: "=a" (eax), "=c" (ecx)
:
: "cc"
);
if (eax == ecx)
return 0; /* CPUID not supported */
cpuid(0, eax, ebx, ecx, edx);
if (ebx == 0x756e6547 &&
edx == 0x49656e69 &&
ecx == 0x6c65746e) {
/* intel */
inteltest:
cpuid(1, eax, ebx, ecx, edx);
if ((edx & 0x00800000) == 0)
return 0;
rval = MM_MMX;
if (edx & 0x02000000)
rval |= MM_MMXEXT | MM_SSE;
if (edx & 0x04000000)
rval |= MM_SSE2;
return rval;
} else if (ebx == 0x68747541 &&
edx == 0x69746e65 &&
ecx == 0x444d4163) {
/* AMD */
cpuid(0x80000000, eax, ebx, ecx, edx);
if ((guint32)eax < 0x80000001)
goto inteltest;
cpuid(0x80000001, eax, ebx, ecx, edx);
if ((edx & 0x00800000) == 0)
return 0;
rval = MM_MMX;
if (edx & 0x80000000)
rval |= MM_3DNOW;
if (edx & 0x00400000)
rval |= MM_MMXEXT;
return rval;
} else if (ebx == 0x746e6543 &&
edx == 0x48727561 &&
ecx == 0x736c7561) { /* "CentaurHauls" */
/* VIA C3 */
cpuid(0x80000000, eax, ebx, ecx, edx);
if ((guint32)eax < 0x80000001)
goto inteltest;
cpuid(0x80000001, eax, ebx, ecx, edx);
rval = 0;
if (edx & (1 << 31))
rval |= MM_3DNOW;
if (edx & (1 << 23))
rval |= MM_MMX;
if (edx & (1 << 24))
rval |= MM_MMXEXT;
return rval;
} else if (ebx == 0x69727943 &&
edx == 0x736e4978 &&
ecx == 0x64616574) {
/* Cyrix Section */
/* See if extended CPUID level 80000001 is supported */
/* The value of CPUID/80000001 for the 6x86MX is undefined
* according to the Cyrix CPU Detection Guide (Preliminary
* Rev. 1.01 table 1), so we'll check the value of eax for
* CPUID/0 to see if standard CPUID level 2 is supported.
* According to the table, the only CPU which supports level
* 2 is also the only one which supports extended CPUID levels.
*/
if (eax != 2)
goto inteltest;
cpuid(0x80000001, eax, ebx, ecx, edx);
if ((eax & 0x00800000) == 0)
return 0;
rval = MM_MMX;
if (eax & 0x01000000)
rval |= MM_MMXEXT;
return rval;
} else {
return 0;
}
#else /* not MMX_DETECTION */
return 0;
#endif
}
int mm_support_check_and_show ()
int mm_support_check_and_show()
{
int r;
gchar *msg, *tmp;
r = mm_support ();
if (r & 0) {
g_message ("Infinity: There is not MMX support\n");
return r;
}
msg = g_strdup ("Infinity: Looking for Multimedia Extensions Support...");
if (r & MM_MMX) {
tmp = g_strconcat (msg, " MMX", 0);
g_free (msg);
msg = tmp;
}
if (r & MM_3DNOW) {
tmp = g_strconcat (msg, " 3DNOW", 0);
g_free (msg);
msg = tmp;
}
if (r & MM_MMXEXT) {
tmp = g_strconcat (msg, " MMX2", 0);
g_free (msg);
msg = tmp;
}
int r;
gchar *msg, *tmp;
r = mm_support();
if (r & 0) {
g_message("Infinity: There is not MMX support\n");
return r;
}
msg = g_strdup("Infinity: Looking for Multimedia Extensions Support...");
if (r & MM_MMX) {
tmp = g_strconcat(msg, " MMX", 0);
g_free(msg);
msg = tmp;
}
if (r & MM_3DNOW) {
tmp = g_strconcat(msg, " 3DNOW", 0);
g_free(msg);
msg = tmp;
}
if (r & MM_MMXEXT) {
tmp = g_strconcat(msg, " MMX2", 0);
g_free(msg);
msg = tmp;
}
/*
* for now this extensions are not used
* if (r & MM_SSE) {
@ -165,19 +164,18 @@ int mm_support_check_and_show ()
* g_free (msg);
* msg = tmp;
* }
*/
tmp = g_strconcat (msg, " detected", 0);
g_free (msg);
msg = tmp;
g_message (msg);
g_free (msg);
*/
tmp = g_strconcat(msg, " detected", 0);
g_free(msg);
msg = tmp;
g_message(msg);
g_free(msg);
return r;
return r;
}
int mmx_ok (void)
int mmx_ok(void)
{
return ( mm_support() & 0x1 );
return mm_support() & 0x1;
}

42
src/cputest.h
View File

@ -1,36 +1,36 @@
/* cputest.h
Cpu detection code, extracted from mmx.h ((c)1997-99 by H. Dietz
and R. Fisher). Converted to C and improved by Fabrice Bellard
*/
#ifndef _CPUTEST_H_
#define _CPUTEST_H_
*
* Cpu detection code, extracted from mmx.h ((c)1997-99 by H. Dietz
* and R. Fisher). Converted to C and improved by Fabrice Bellard
*/
#ifndef _CPUTEST_H_
#define _CPUTEST_H_
#define MM_MMX 0x0001 /* standard MMX */
#define MM_3DNOW 0x0004 /* AMD 3DNOW */
#define MM_MMXEXT 0x0002 /* SSE integer functions or AMD MMX ext */
#define MM_SSE 0x0008 /* SSE functions */
#define MM_SSE2 0x0010 /* PIV SSE2 functions */
#define MM_MMX 0x0001 /* standard MMX */
#define MM_3DNOW 0x0004 /* AMD 3DNOW */
#define MM_MMXEXT 0x0002 /* SSE integer functions or AMD MMX ext */
#define MM_SSE 0x0008 /* SSE functions */
#define MM_SSE2 0x0010 /* PIV SSE2 functions */
/* should be defined by architectures supporting
one or more MultiMedia extension */
int mm_support (void);
* one or more MultiMedia extension */
int mm_support(void);
/* return the result of mm_support and show the results
to stdout */
int mm_support_check_and_show (void);
* to stdout */
int mm_support_check_and_show(void);
/* Function to test if mmx instructions are supported...
Returns 1 if MMX instructions are supported, 0 otherwise */
int mmx_ok (void);
/* Function to test if mmx instructions are supported...
* Returns 1 if MMX instructions are supported, 0 otherwise */
int mmx_ok(void);
extern unsigned int mm_flags;
/*static inline void emms(void)
{
__asm __volatile ("emms;":::"memory");
}*/
* {
* __asm __volatile ("emms;":::"memory");
* }*/
#endif /* _CPUTEST_H_ */

475
src/display.c
View File

@ -12,7 +12,7 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
*/
#include <math.h>
#include <stdlib.h>
#include <string.h>
@ -23,8 +23,8 @@
#include "infconfig.h"
#include "gettext.h"
#define wrap(a) ( a < 0 ? 0 : ( a > 255 ? 255 : a ))
#define assign_max(p,a) ( *p <= a ? *p = a : 0 )
#define wrap(a) (a < 0 ? 0 : (a > 255 ? 255 : a))
#define assign_max(p, a) (*p <= a ? *p = a : 0)
/*
* SDL_HWSURFACE Surface is in video memory
@ -35,8 +35,8 @@
#define VIDEO_FLAGS ((Uint32)(SDL_HWSURFACE | SDL_HWPALETTE | SDL_DOUBLEBUF | SDL_RESIZABLE))
typedef struct sincos {
gint32 i;
gfloat *f;
gint32 i;
gfloat *f;
} sincos_t;
static gint16 pcm_data[2][512];
@ -55,129 +55,126 @@ static SDL_Surface *screen = NULL;
static SDL_Color color_table[NB_PALETTES][256];
static gint16 current_colors[256];
static byte* surface1;
static byte *surface1;
static void init_sdl (gint32 width, gint32 height, gint32 scale)
static void init_sdl(gint32 width, gint32 height, gint32 scale)
{
if (SDL_Init((Uint32)(SDL_INIT_VIDEO | SDL_INIT_TIMER)) < 0)
g_error (_("Infinity: Couldn't initialize SDL: %s\n"), SDL_GetError());
screen = SDL_SetVideoMode (width * scale, height * scale, 16, VIDEO_FLAGS);
if (screen == NULL)
g_error (_("Infinity: could not init video mode: %s\n"), SDL_GetError());
g_message (_("Infinity: SDL SetVideoMode() Ok"));
(void)SDL_ShowCursor (0);
(void)SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
if (SDL_Init((Uint32)(SDL_INIT_VIDEO | SDL_INIT_TIMER)) < 0)
g_error(_("Infinity: Couldn't initialize SDL: %s\n"), SDL_GetError());
screen = SDL_SetVideoMode(width * scale, height * scale, 16, VIDEO_FLAGS);
if (screen == NULL)
g_error(_("Infinity: could not init video mode: %s\n"), SDL_GetError());
g_message(_("Infinity: SDL SetVideoMode() Ok"));
(void)SDL_ShowCursor(0);
(void)SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
}
static void generate_colors()
{
gint32 i, k;
gfloat colors[NB_PALETTES][2][3] = {{{1.0,1.0,1.0},{1.0,1.0,1.0}},
{{2.0,1.5,0.0},{0.0,0.5,2.0}},
{{0.0,1.0,2.0},{0.0,1.0,0.0}},
{{0.0,2.0,1.0},{0.0,0.0,1.0}},
{{2.0,0.0,0.0},{0.0,1.0,1.0}}};
gint32 i, k;
gfloat colors[NB_PALETTES][2][3] = { { { 1.0, 1.0, 1.0 }, { 1.0, 1.0, 1.0 } },
{ { 2.0, 1.5, 0.0 }, { 0.0, 0.5, 2.0 } },
{ { 0.0, 1.0, 2.0 }, { 0.0, 1.0, 0.0 } },
{ { 0.0, 2.0, 1.0 }, { 0.0, 0.0, 1.0 } },
{ { 2.0, 0.0, 0.0 }, { 0.0, 1.0, 1.0 } } };
for (k = 0; k < NB_PALETTES; k++) {
for (i = 0; i < 128; i++)
{
color_table[k][i].r = (Uint8)(colors[k][0][0]*i);
color_table[k][i].g = (Uint8)(colors[k][0][1]*i);
color_table[k][i].b = (Uint8)(colors[k][0][2]*i);
for (k = 0; k < NB_PALETTES; k++) {
for (i = 0; i < 128; i++) {
color_table[k][i].r = (Uint8)(colors[k][0][0] * i);
color_table[k][i].g = (Uint8)(colors[k][0][1] * i);
color_table[k][i].b = (Uint8)(colors[k][0][2] * i);
color_table[k][i + 128].r = (Uint8)(colors[k][0][0] * 127 + colors[k][1][0] * i);
color_table[k][i + 128].g = (Uint8)(colors[k][0][1] * 127 + colors[k][1][1] * i);
color_table[k][i + 128].b = (Uint8)(colors[k][0][2] * 127 + colors[k][1][2] * i);
}
}
for (i = 0; i < 128; i++)
{
color_table[k][i+128].r = (Uint8)(colors[k][0][0]*127+colors[k][1][0]*i);
color_table[k][i+128].g = (Uint8)(colors[k][0][1]*127+colors[k][1][1]*i);
color_table[k][i+128].b = (Uint8)(colors[k][0][2]*127+colors[k][1][2]*i);
}
}
}
static void display_surface ()
static void display_surface()
{
gint32 i, j;
gint16* pdest;
byte* psrc;
gboolean screen_locked;
gint32 i, j;
gint16 *pdest;
byte *psrc;
gboolean screen_locked;
if (SDL_MUSTLOCK(screen)) {
if (SDL_LockSurface (screen) < 0) {
g_error ("Infinity: Cannot lock screen: %s", SDL_GetError ());
return ;
}
screen_locked = TRUE;
} else
screen_locked = FALSE;
if (scr_par.scale > 1) {
for (i = 0; i < scr_par.height; i++) {
pdest = (gint16*)(screen->pixels + i * screen->pitch * scr_par.scale);
psrc = surface1 + i * scr_par.width;
if (scr_par.scale == 2) {
for (j = 1; j < scr_par.width; j++) {
*(pdest++) = current_colors[*psrc++];
*(pdest) = *(pdest - 1);
pdest++;
}
memcpy (screen->pixels + i * screen->pitch * 2 + screen->pitch,
screen->pixels + i * screen->pitch * 2, screen->pitch);
} /* else {
for (j=1;j<scr_par.width;j++) {
*(pdest++)=current_colors[*psrc++];
*(pdest++)=*(pdest-1);
*(pdest++)=*(pdest-1);
}
memcpy(screen->pixels+i*screen->pitch*3+screen->pitch,
screen->pixels+i*screen->pitch*3,screen->pitch);
memcpy(screen->pixels+i*screen->pitch*3+screen->pitch*2,
screen->pixels+i*screen->pitch*3,screen->pitch);
} */
} /* for */
} else {
psrc = surface1;
for (i = 0; i < scr_par.height; i++) {
pdest = (gint16*)(screen->pixels + i * screen->pitch);
for (j = 0; j < scr_par.width; j++)
*pdest++ = current_colors[*psrc++];
}
}
if (screen_locked)
SDL_UnlockSurface (screen);
else
(void)SDL_Flip (screen);
if (SDL_MUSTLOCK(screen)) {
if (SDL_LockSurface(screen) < 0) {
g_error("Infinity: Cannot lock screen: %s", SDL_GetError());
return;
}
screen_locked = TRUE;
} else {
screen_locked = FALSE;
}
if (scr_par.scale > 1) {
for (i = 0; i < scr_par.height; i++) {
pdest = (gint16 *)(screen->pixels + i * screen->pitch * scr_par.scale);
psrc = surface1 + i * scr_par.width;
if (scr_par.scale == 2) {
for (j = 1; j < scr_par.width; j++) {
*(pdest++) = current_colors[*psrc++];
*(pdest) = *(pdest - 1);
pdest++;
}
memcpy(screen->pixels + i * screen->pitch * 2 + screen->pitch,
screen->pixels + i * screen->pitch * 2, screen->pitch);
} /* else {
* for (j=1;j<scr_par.width;j++) {
*(pdest++)=current_colors[*psrc++];
*(pdest++)=*(pdest-1);
*(pdest++)=*(pdest-1);
* }
* memcpy(screen->pixels+i*screen->pitch*3+screen->pitch,
* screen->pixels+i*screen->pitch*3,screen->pitch);
* memcpy(screen->pixels+i*screen->pitch*3+screen->pitch*2,
* screen->pixels+i*screen->pitch*3,screen->pitch);
* } */
} /* for */
} else {
psrc = surface1;
for (i = 0; i < scr_par.height; i++) {
pdest = (gint16 *)(screen->pixels + i * screen->pitch);
for (j = 0; j < scr_par.width; j++)
*pdest++ = current_colors[*psrc++];
}
}
if (screen_locked)
SDL_UnlockSurface(screen);
else
(void)SDL_Flip(screen);
}
#define plot1(x,y,c)\
#define plot1(x, y, c) \
\
if ((x)>0 && (x)<scr_par.width-3 && (y)>0 && (y)<scr_par.height-3)\
assign_max(&(surface1)[(x)+(y)*scr_par.width],(c))\
if ((x) > 0 && (x) < scr_par.width - 3 && (y) > 0 && (y) < scr_par.height - 3) \
assign_max(&(surface1)[(x) + (y) * scr_par.width], (c)) \
\
#define plot2(x,y,c)\
{\
gint32 ty;\
if ((x)>0 && (gint32)(x)<scr_par.width-3 && (y)>0 && (gint32)(y)<scr_par.height-3) {\
ty = (gint32)(y)*scr_par.width;\
assign_max((&(surface1)[(gint32)(x)+ty]),(c));\
assign_max((&(surface1)[(gint32)(x)+1+ty]),(c));\
assign_max((&(surface1)[(gint32)(x)+ty+scr_par.width]),(c));\
assign_max((&(surface1)[(gint32)(x)+1+ty+scr_par.width]),(c));\
}\
}\
#define plot2(x, y, c) \
{ \
gint32 ty; \
if ((x) > 0 && (gint32)(x) < scr_par.width - 3 && (y) > 0 && (gint32)(y) < scr_par.height - 3) { \
ty = (gint32)(y) * scr_par.width; \
assign_max((&(surface1)[(gint32)(x) + ty]), (c)); \
assign_max((&(surface1)[(gint32)(x) + 1 + ty]), (c)); \
assign_max((&(surface1)[(gint32)(x) + ty + scr_par.width]), (c)); \
assign_max((&(surface1)[(gint32)(x) + 1 + ty + scr_par.width]), (c)); \
} \
} \
#define SWAP(x,y)\
x ^= y;\
y ^= x;\
#define SWAP(x, y) \
x ^= y; \
y ^= x; \
x ^= y;
static void line (gint32 x1, gint32 y1, gint32 x2, gint32 y2, gint32 c)
static void line(gint32 x1, gint32 y1, gint32 x2, gint32 y2, gint32 c)
{
gint32 dx, dy, cxy,dxy;
gint32 dx, dy, cxy, dxy;
/* calculate the distances */
dx = abs (x1 - x2);
dy = abs (y1 - y2);
dx = abs(x1 - x2);
dy = abs(y1 - y2);
cxy = 0;
if (dy > dx) {
/* Follow Y axis */
@ -185,29 +182,29 @@ static void line (gint32 x1, gint32 y1, gint32 x2, gint32 y2, gint32 c)
SWAP(y1, y2);
SWAP(x1, x2);
}
if (x1 > x2)
if (x1 > x2)
dxy = -1;
else
dxy = 1;
for (y1=y1; y1<y2; y1++) {
for (y1 = y1; y1 < y2; y1++) {
cxy += dx;
if (cxy >= dy) {
x1+= dxy;
x1 += dxy;
cxy -= dy;
}
plot1(x1, y1, (byte)c);
}
}
} else {
/* Follow X axis */
if (x1 > x2) {
SWAP(x1, x2);
SWAP(y1, y2);
}
if (y1 > y2)
if (y1 > y2)
dxy = -1;
else
dxy = 1;
for (x1 = x1; x1 < x2; x1++) {
cxy += dy;
if (cxy >= dx) {
@ -215,229 +212,229 @@ static void line (gint32 x1, gint32 y1, gint32 x2, gint32 y2, gint32 c)
cxy -= dx;
}
plot1(x1, y1, (byte)c);
}
}
}
}
/*
* Public functions
*/
void display_init (void)
void display_init(void)
{
scr_par.width = config_get_xres();
scr_par.height = config_get_yres();
scr_par.scale = config_get_sres();
pcm_data_mutex = SDL_CreateMutex ();
compute_init ();
init_sdl (scr_par.width, scr_par.height, scr_par.scale);
generate_colors ();
effects_load_effects ();
vector_field = compute_vector_field_new (scr_par.width, scr_par.height);
compute_generate_vector_field (vector_field);
pcm_data_mutex = SDL_CreateMutex();
compute_init();
init_sdl(scr_par.width, scr_par.height, scr_par.scale);
generate_colors();
effects_load_effects();
vector_field = compute_vector_field_new(scr_par.width, scr_par.height);
compute_generate_vector_field(vector_field);
}
void display_quit (void)
void display_quit(void)
{
compute_vector_field_destroy (vector_field);
compute_vector_field_destroy(vector_field);
compute_quit();
SDL_DestroyMutex (pcm_data_mutex);
SDL_DestroyMutex(pcm_data_mutex);
if (screen != NULL)
SDL_FreeSurface (screen);
SDL_FreeSurface(screen);
screen = NULL;
SDL_Quit ();
SDL_Quit();
}
void display_resize (gint32 width, gint32 height)
void display_resize(gint32 width, gint32 height)
{
scr_par.width = width;
scr_par.height = height;
screen = SDL_SetVideoMode (scr_par.width * scr_par.scale,
scr_par.height * scr_par.scale,
16, VIDEO_FLAGS);
screen = SDL_SetVideoMode(scr_par.width * scr_par.scale,
scr_par.height * scr_par.scale,
16, VIDEO_FLAGS);
if (screen == NULL)
g_error (_("Infinity: Couldn't set %dx%d video mode: %s\n"),
scr_par.width * scr_par.scale, scr_par.height * scr_par.scale,
SDL_GetError());
compute_vector_field_destroy (vector_field);
vector_field = compute_vector_field_new (width, height);
compute_resize (width, height);
compute_generate_vector_field (vector_field);
g_error(_("Infinity: Couldn't set %dx%d video mode: %s\n"),
scr_par.width * scr_par.scale, scr_par.height * scr_par.scale,
SDL_GetError());
compute_vector_field_destroy(vector_field);
vector_field = compute_vector_field_new(width, height);
compute_resize(width, height);
compute_generate_vector_field(vector_field);
}
inline void display_set_pcm_data (const float * data, int channels)
inline void display_set_pcm_data(const float *data, int channels)
{
if (channels != 2) {
g_critical ("Unsupported number of channels (%d)\n", channels);
g_critical("Unsupported number of channels (%d)\n", channels);
return;
}
/* begin CS */
g_return_if_fail (SDL_mutexP (pcm_data_mutex) >= 0);
g_return_if_fail(SDL_mutexP(pcm_data_mutex) >= 0);
// TODO check this out, different types here...
memcpy (pcm_data, data, 2*512*sizeof(gint16));
g_return_if_fail (SDL_mutexV (pcm_data_mutex) >= 0);
memcpy(pcm_data, data, 2 * 512 * sizeof(gint16));
g_return_if_fail(SDL_mutexV(pcm_data_mutex) >= 0);
/* end CS */
}
void change_color (gint32 t2, gint32 t1, gint32 w)
void change_color(gint32 t2, gint32 t1, gint32 w)
{
gint32 i;
gint32 r, g, b;
for (i = 0; i < 255; i++) {
r = ((color_table[t1][i].r*w+color_table[t2][i].r*(256-w))>>11);
g = ((color_table[t1][i].g*w+color_table[t2][i].g*(256-w))>>10);
b = ((color_table[t1][i].b*w+color_table[t2][i].b*(256-w))>>11);
r = ((color_table[t1][i].r * w + color_table[t2][i].r * (256 - w)) >> 11);
g = ((color_table[t1][i].g * w + color_table[t2][i].g * (256 - w)) >> 10);
b = ((color_table[t1][i].b * w + color_table[t2][i].b * (256 - w)) >> 11);
current_colors[i] = (r << 11) + (g << 5) + b;
}
}
inline void display_blur (guint32 vector_index)
inline void display_blur(guint32 vector_index)
{
surface1 = compute_surface (&(vector_field->vector[vector_index]),
vector_field->width, vector_field->height);
surface1 = compute_surface(&(vector_field->vector[vector_index]),
vector_field->width, vector_field->height);
display_surface();
}
#if MMX_DETECTION
inline void display_blur_mmx (guint32 vector_index)
inline void display_blur_mmx(guint32 vector_index)
{
surface1 = compute_surface_mmx (&(vector_field->vector[vector_index]),
vector_field->width, vector_field->height);
surface1 = compute_surface_mmx(&(vector_field->vector[vector_index]),
vector_field->width, vector_field->height);
display_surface();
}
#endif
void spectral (t_effect* current_effect)
void spectral(t_effect *current_effect)
{
gint32 i, halfheight, halfwidth;
gfloat old_y1,old_y2;
gint32 i, halfheight, halfwidth;
gfloat old_y1, old_y2;
gfloat y1, y2;
const gint32 density_lines = 5;
const gint32 step = 4;
const gint32 shift = (current_effect->spectral_shift*scr_par.height)>>8;
const gint32 shift = (current_effect->spectral_shift * scr_par.height) >> 8;
/* begin CS */
g_return_if_fail (SDL_mutexP (pcm_data_mutex) >= 0);
y1 = (gfloat)((((pcm_data[0][0]+pcm_data[1][0])>>9)*current_effect->spectral_amplitude*scr_par.height)>>12);
y2 = (gfloat)((((pcm_data[0][0]+pcm_data[1][0])>>9)*current_effect->spectral_amplitude*scr_par.height)>>12);
g_return_if_fail(SDL_mutexP(pcm_data_mutex) >= 0);
y1 = (gfloat)((((pcm_data[0][0] + pcm_data[1][0]) >> 9) * current_effect->spectral_amplitude * scr_par.height) >> 12);
y2 = (gfloat)((((pcm_data[0][0] + pcm_data[1][0]) >> 9) * current_effect->spectral_amplitude * scr_par.height) >> 12);
if (cosw.i != scr_par.width || sinw.i != scr_par.width) {
g_free (cosw.f);
g_free (sinw.f);
g_free(cosw.f);
g_free(sinw.f);
sinw.f = cosw.f = NULL;
sinw.i = cosw.i = 0;
}
if (cosw.i == 0 || cosw.f == NULL) {
gfloat halfPI = (gfloat)PI/2;
gfloat halfPI = (gfloat)PI / 2;
cosw.i = scr_par.width;
if (cosw.f != NULL)
g_free (cosw.f);
cosw.f = g_malloc (sizeof(gfloat) * scr_par.width);
for (i=0; i<scr_par.width;i+=step)
cosw.f[i] = cos((gfloat)i/scr_par.width*PI+halfPI);
g_free(cosw.f);
cosw.f = g_malloc(sizeof(gfloat) * scr_par.width);
for (i = 0; i < scr_par.width; i += step)
cosw.f[i] = cos((gfloat)i / scr_par.width * PI + halfPI);
}
if (sinw.i == 0 || sinw.f == NULL) {
gfloat halfPI = (gfloat)PI/2;
gfloat halfPI = (gfloat)PI / 2;
sinw.i = scr_par.width;
if (sinw.f != NULL)
g_free (sinw.f);
sinw.f = g_malloc (sizeof(gfloat) * scr_par.width);
for (i=0; i<scr_par.width;i+=step)
sinw.f[i] = sin((gfloat)i/scr_par.width*PI+halfPI);
g_free(sinw.f);
sinw.f = g_malloc(sizeof(gfloat) * scr_par.width);
for (i = 0; i < scr_par.width; i += step)
sinw.f[i] = sin((gfloat)i / scr_par.width * PI + halfPI);
}
if (current_effect->mode_spectre==3) {
if (y1<0.0)
y1=0.0;
if (y2<0.0)
y2=0.0;
if (current_effect->mode_spectre == 3) {
if (y1 < 0.0)
y1 = 0.0;
if (y2 < 0.0)
y2 = 0.0;
}
halfheight = scr_par.height >> 1;
halfwidth = scr_par.width >> 1;
for (i=step;i<scr_par.width;i+=step) {
old_y1=y1;
old_y2=y2;
y1=(gfloat)(((pcm_data[1][(i<<9)/scr_par.width/density_lines]>>8)*
current_effect->spectral_amplitude*scr_par.height)>>12);
y2=(gfloat)(((pcm_data[0][(i<<9)/scr_par.width/density_lines]>>8)*
current_effect->spectral_amplitude*scr_par.height)>>12);
halfwidth = scr_par.width >> 1;
for (i = step; i < scr_par.width; i += step) {
old_y1 = y1;
old_y2 = y2;
y1 = (gfloat)(((pcm_data[1][(i << 9) / scr_par.width / density_lines] >> 8) *
current_effect->spectral_amplitude * scr_par.height) >> 12);
y2 = (gfloat)(((pcm_data[0][(i << 9) / scr_par.width / density_lines] >> 8) *
current_effect->spectral_amplitude * scr_par.height) >> 12);
/* end CS */
switch (current_effect->mode_spectre) {
switch (current_effect->mode_spectre) {
case 0:
line(i-step,halfheight+shift+old_y2,
i,halfheight+shift+y2,
line(i - step, halfheight + shift + old_y2,
i, halfheight + shift + y2,
current_effect->spectral_color);
break;
case 1:
line(i-step,halfheight+shift+old_y1,
i,halfheight+shift+y1,
case 1:
line(i - step, halfheight + shift + old_y1,
i, halfheight + shift + y1,
current_effect->spectral_color);
line(i-step,halfheight-shift+old_y2,
i,halfheight-shift+y2,
line(i - step, halfheight - shift + old_y2,
i, halfheight - shift + y2,
current_effect->spectral_color);
break;
case 2:
line(i-step,halfheight+shift+old_y1,
i,halfheight+shift+y1,
line(i - step, halfheight + shift + old_y1,
i, halfheight + shift + y1,
current_effect->spectral_color);
line(i-step,halfheight-shift+old_y1,
i,halfheight-shift+y1,
line(i - step, halfheight - shift + old_y1,
i, halfheight - shift + y1,
current_effect->spectral_color);
line(halfwidth+shift+old_y2,i-step,
halfwidth+shift+y2,i,
line(halfwidth + shift + old_y2, i - step,
halfwidth + shift + y2, i,
current_effect->spectral_color);
line(halfwidth - shift + old_y2, i - step,
halfwidth - shift + y2, i,
current_effect->spectral_color);
line(halfwidth-shift+old_y2,i-step,
halfwidth-shift+y2,i,
current_effect->spectral_color);
break;
case 3:
if (y1<0.0)
y1=0.0;
if (y2<0.0)
y2=0.0;
if (y1 < 0.0)
y1 = 0.0;
if (y2 < 0.0)
y2 = 0.0;
case 4:
line(halfwidth + cosw.f[i-step] * (shift+old_y1),
halfheight + sinw.f[i-step] * (shift+old_y1),
halfwidth + cosw.f[i] * (shift+y1),
halfheight + sinw.f[i] * (shift+y1),
line(halfwidth + cosw.f[i - step] * (shift + old_y1),
halfheight + sinw.f[i - step] * (shift + old_y1),
halfwidth + cosw.f[i] * (shift + y1),
halfheight + sinw.f[i] * (shift + y1),
current_effect->spectral_color);
line(halfwidth - cosw.f[i - step] * (shift + old_y2),
halfheight + sinw.f[i - step] * (shift + old_y2),
halfwidth - cosw.f[i] * (shift + y2),
halfheight + sinw.f[i] * (shift + y2),
current_effect->spectral_color);
line(halfwidth - cosw.f[i-step] * (shift+old_y2),
halfheight + sinw.f[i-step] * (shift+old_y2),
halfwidth - cosw.f[i] * (shift+y2),
halfheight + sinw.f[i] * (shift+y2),
current_effect->spectral_color);
break;
}
}
g_return_if_fail (SDL_mutexV (pcm_data_mutex) >= 0);
if (current_effect->mode_spectre==3 || current_effect->mode_spectre==4)
line(halfwidth + cosw.f[scr_par.width - step] * (shift+y1),
halfheight + sinw.f[scr_par.width - step] * (shift+y1),
halfwidth - cosw.f[scr_par.width - step] * (shift+y2),
halfheight + sinw.f[scr_par.width - step] * (shift+y2),
g_return_if_fail(SDL_mutexV(pcm_data_mutex) >= 0);
if (current_effect->mode_spectre == 3 || current_effect->mode_spectre == 4) {
line(halfwidth + cosw.f[scr_par.width - step] * (shift + y1),
halfheight + sinw.f[scr_par.width - step] * (shift + y1),
halfwidth - cosw.f[scr_par.width - step] * (shift + y2),
halfheight + sinw.f[scr_par.width - step] * (shift + y2),
current_effect->spectral_color);
}
}
/**
* \todo current_effect->curve_color must be a byte. This is related to
* t_effect typo.
*/
void curve (t_effect* current_effect)
void curve(t_effect *current_effect)
{
gint32 i, j, k;
gfloat v, vr;
gfloat x, y;
gfloat amplitude = (gfloat) current_effect->curve_amplitude / 256;
gfloat amplitude = (gfloat)current_effect->curve_amplitude / 256;
for (j = 0; j < 2; j++) {
v = 80.0;
vr = 0.001;
k = current_effect->x_curve;
for (i = 0;i < 64; i++) {
x = cos((gfloat)(k)/(v+v*j*1.34))*scr_par.height*amplitude;
y = sin((gfloat)(k)/(1.756*(v+v*j*0.93)))*scr_par.height*amplitude;
plot2(x*cos((gfloat)k*vr)+y*sin((gfloat)k*vr)+scr_par.width/2,
x*sin((gfloat)k*vr)-y*cos((gfloat)k*vr)+scr_par.height/2,
for (i = 0; i < 64; i++) {
x = cos((gfloat)(k) / (v + v * j * 1.34)) * scr_par.height * amplitude;
y = sin((gfloat)(k) / (1.756 * (v + v * j * 0.93))) * scr_par.height * amplitude;
plot2(x * cos((gfloat)k * vr) + y * sin((gfloat)k * vr) + scr_par.width / 2,
x * sin((gfloat)k * vr) - y * cos((gfloat)k * vr) + scr_par.height / 2,
(byte)current_effect->curve_color);
k++;
}
@ -445,31 +442,31 @@ void curve (t_effect* current_effect)
current_effect->x_curve = k;
}
void display_toggle_fullscreen (void)
void display_toggle_fullscreen(void)
{
if (SDL_WM_ToggleFullScreen (screen) < 0)
g_warning (_("Cannot toggle to fullscreen mode: %s"), SDL_GetError());
if (SDL_WM_ToggleFullScreen(screen) < 0)
g_warning(_("Cannot toggle to fullscreen mode: %s"), SDL_GetError());
}
void display_save_screen (void)
void display_save_screen(void)
{
gchar name[256];
(void) snprintf (name, 255, "screenshot%i%s", rand () % 1000000, ".bmp");
(void)snprintf(name, 255, "screenshot%i%s", rand() % 1000000, ".bmp");
name[255] = '\0';
if (SDL_SaveBMP (screen, name) < 0)
g_warning (_("Error while saving file %s: %s"), name, SDL_GetError());
if (SDL_SaveBMP(screen, name) < 0)
g_warning(_("Error while saving file %s: %s"), name, SDL_GetError());
else
g_message (_("saved"));
g_message(_("saved"));
}
inline void display_save_effect (t_effect *effect)
inline void display_save_effect(t_effect *effect)
{
effects_save_effect (effect);
effects_save_effect(effect);
}
inline void display_load_random_effect (t_effect *effect)
inline void display_load_random_effect(t_effect *effect)
{
effects_load_random_effect (effect);
effects_load_random_effect(effect);
}

34
src/display.h
View File

@ -19,8 +19,8 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __INFINITY_DISPLAY__
*/
#ifndef __INFINITY_DISPLAY__
#define __INFINITY_DISPLAY__
#include <SDL/SDL.h>
@ -42,7 +42,7 @@
* library, must be called before any SDL operation and
* must not be called when SDL was already started.
*/
void display_init (void);
void display_init(void);
/**
* Closes the display module.
@ -54,10 +54,10 @@ void display_init (void);
* inside this function, because display_set_pcm_data()
* could be bloqued on a mutex, mutex that display_quit()
* will destroy!
*
*
* \see display_init().
*/
void display_quit (void);
void display_quit(void);
/**
* Change the size of the display to the new dimension
@ -67,7 +67,7 @@ void display_quit (void);
* screen is resized (i.e. when is resized the window where
* the screen is embedded in).
*/
void display_resize (gint32 width, gint32 height);
void display_resize(gint32 width, gint32 height);
/**
* Set \a data as the data PCM data of this module.
@ -78,25 +78,25 @@ void display_resize (gint32 width, gint32 height);
*
* \see display_quit().
*/
void display_set_pcm_data (const float * data, int channels);
void display_set_pcm_data(const float *data, int channels);
void display_show (void);
void display_show(void);
void change_color (gint32 old_p, gint32 p, gint32 w);
void display_blur (guint32 vector_index);
void display_blur_mmx (guint32 vector_index);
void spectral (t_effect* current_effect);
void curve (t_effect* current_effect);
void change_color(gint32 old_p, gint32 p, gint32 w);
void display_blur(guint32 vector_index);
void display_blur_mmx(guint32 vector_index);
void spectral(t_effect *current_effect);
void curve(t_effect *current_effect);
/**
* Makes the plugin screen switch to full screen mode.
*
* \see display_init().
*/
void display_toggle_fullscreen (void);
void display_toggle_fullscreen(void);
void display_save_screen (void);
void display_save_effect (t_effect *effect);
void display_load_random_effect (t_effect *effect);
void display_save_screen(void);
void display_save_effect(t_effect *effect);
void display_load_random_effect(t_effect *effect);
#endif /* __INFINITY_DISPLAY__ */

64
src/effects.c
View File

@ -12,25 +12,25 @@ static t_effect effects[100];
static gint32 nb_effects = 0;
static gboolean initialized = FALSE;
void effects_save_effect (t_effect *effect)
void effects_save_effect(t_effect *effect)
{
gchar datafile[256], path[256];
FILE *f;
gint32 i;
g_assert (effect);
g_assert(effect);
f = fopen (EFFECTS_FILE,"a");
if (f == NULL) {
g_warning (_("Cannot open file %s for saving effects\n"),
EFFECTS_FILE);
return ;
return;
}
for (i = 0; i < sizeof(t_effect); i++)
fputc (*((byte*)effect+i), f);
fclose (f);
for (i = 0; i < sizeof(t_effect); i++)
fputc(*((byte *)effect + i), f);
fclose(f);
}
void effects_load_effects (void)
void effects_load_effects(void)
{
gchar path[255];
gchar datafile[255];
@ -42,13 +42,13 @@ void effects_load_effects (void)
if (f == NULL) {
g_warning (_("Cannot open file %s for loading effects\n"),
EFFECTS_FILE);
return ;
return;
}
while (!finished) {
byte* ptr_effect = (byte*)&effects[nb_effects];
for (i=0;i < sizeof(t_effect); i+=4) {
b=fgetc(f);
if (b!=EOF) {
byte *ptr_effect = (byte *)&effects[nb_effects];
for (i = 0; i < sizeof(t_effect); i += 4) {
b = fgetc(f);
if (b != EOF) {
c = fgetc(f);
assert(c != EOF);
d = fgetc(f);
@ -56,39 +56,39 @@ void effects_load_effects (void)
e = fgetc(f);
assert(e != EOF);
#if BYTE_ORDER == BIG_ENDIAN
ptr_effect[i]=(byte)e;
ptr_effect[i+1]=(byte)d;
ptr_effect[i+2]=(byte)c;
ptr_effect[i+3]=(byte)b;
ptr_effect[i] = (byte)e;
ptr_effect[i + 1] = (byte)d;
ptr_effect[i + 2] = (byte)c;
ptr_effect[i + 3] = (byte)b;
#else
ptr_effect[i]=(byte)b;
ptr_effect[i+1]=(byte)c;
ptr_effect[i+2]=(byte)d;
ptr_effect[i+3]=(byte)e;
ptr_effect[i] = (byte)b;
ptr_effect[i + 1] = (byte)c;
ptr_effect[i + 2] = (byte)d;
ptr_effect[i + 3] = (byte)e;
#endif
} else
finished=1;
} else {
finished = 1;
}
}
nb_effects+=1;
nb_effects++;
}
nb_effects -= 1;
fclose (f);
nb_effects--;
fclose(f);
}
void effects_load_random_effect (t_effect *effect)
void effects_load_random_effect(t_effect *effect)
{
gint32 trash;
if (!initialized) {
srand (trash);
srand(trash);
initialized = TRUE;
}
if (nb_effects > 0) {
gint32 num_effect = rand() % nb_effects;
gint32 i;
for (i = 0; i < sizeof(t_effect); i++) {
*((byte*)effect+i) = *((byte*)(&effects[num_effect])+i);
}
for (i = 0; i < sizeof(t_effect); i++)
*((byte *)effect + i) = *((byte *)(&effects[num_effect]) + i);
}
}

30
src/effects.h
View File

@ -19,8 +19,8 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __INFINITY_EFFECTS__
*/
#ifndef __INFINITY_EFFECTS__
#define __INFINITY_EFFECTS__
@ -33,31 +33,31 @@
* \todo document structure fields. Some of them are two big, byte
* would be enough for some of them.
*/
typedef struct {
gint32 num_effect; /**< The number of the effect */
gint32 x_curve;
gint32 curve_color;
gint32 curve_amplitude;
gint32 spectral_amplitude;
gint32 spectral_color;
gint32 mode_spectre;
gint32 spectral_shift;
typedef struct {
gint32 num_effect; /**< The number of the effect */
gint32 x_curve;
gint32 curve_color;
gint32 curve_amplitude;
gint32 spectral_amplitude;
gint32 spectral_color;
gint32 mode_spectre;
gint32 spectral_shift;
} t_effect;
/**
* Saves the given effect pointed by \a effect to disk.
*
* The effect are saved to the file
* The effect are saved to the file
* {prefix}/share/xmms/infinity_states, where {prefix} is
* usually /usr or /usr/local.
*
* @param effect Must be a non NULL reference to a ::t_effect
* object.
*/
void effects_save_effect (t_effect *effect);
void effects_save_effect(t_effect *effect);
void effects_load_effects (void);
void effects_load_random_effect (t_effect *effect);
void effects_load_effects(void);
void effects_load_random_effect(t_effect *effect);
#endif /* __INFINITY_EFFECTS__ */

86
src/gettext.h
View File

@ -1,20 +1,20 @@
/* Convenience header for conditional use of GNU <libintl.h>.
Copyright (C) 1995-1998, 2000-2002 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU Library General Public License as published
by the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
USA. */
* Copyright (C) 1995-1998, 2000-2002 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Library General Public License as published
* by the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
* USA. */
#ifndef _LIBGETTEXT_H
#define _LIBGETTEXT_H 1
@ -26,14 +26,14 @@
# include <libintl.h>
/* Solaris /usr/include/locale.h includes /usr/include/libintl.h, which
chokes if dcgettext is defined as a macro. So include it now, to make
later inclusions of <locale.h> a NOP. We don't include <libintl.h>
as well because people using "gettext.h" will not include <libintl.h>,
and also including <libintl.h> would fail on SunOS 4, whereas <locale.h>
is OK. */
* chokes if dcgettext is defined as a macro. So include it now, to make
* later inclusions of <locale.h> a NOP. We don't include <libintl.h>
* as well because people using "gettext.h" will not include <libintl.h>,
* and also including <libintl.h> would fail on SunOS 4, whereas <locale.h>
* is OK. */
/*#if defined(__sun) || HAVE_LOCALE_H
# include <locale.h>
#endif*/
# include <locale.h>
#endif*/
#if HAVE_LOCALE_H
# include <locale.h>
#endif
@ -41,34 +41,34 @@
#else
/* Disabled NLS.
The casts to 'const char *' serve the purpose of producing warnings
for invalid uses of the value returned from these functions.
On pre-ANSI systems without 'const', the config.h file is supposed to
contain "#define const". */
# define gettext(Msgid) ((const char *) (Msgid))
# define dgettext(Domainname, Msgid) ((const char *) (Msgid))
# define dcgettext(Domainname, Msgid, Category) ((const char *) (Msgid))
* The casts to 'const char *' serve the purpose of producing warnings
* for invalid uses of the value returned from these functions.
* On pre-ANSI systems without 'const', the config.h file is supposed to
* contain "#define const". */
# define gettext(Msgid) ((const char *)(Msgid))
# define dgettext(Domainname, Msgid) ((const char *)(Msgid))
# define dcgettext(Domainname, Msgid, Category) ((const char *)(Msgid))
# define ngettext(Msgid1, Msgid2, N) \
((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
((N) == 1 ? (const char *)(Msgid1) : (const char *)(Msgid2))
# define dngettext(Domainname, Msgid1, Msgid2, N) \
((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
((N) == 1 ? (const char *)(Msgid1) : (const char *)(Msgid2))
# define dcngettext(Domainname, Msgid1, Msgid2, N, Category) \
((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
# define textdomain(Domainname) ((const char *) (Domainname))
# define bindtextdomain(Domainname, Dirname) ((const char *) (Dirname))
# define bind_textdomain_codeset(Domainname, Codeset) ((const char *) (Codeset))
((N) == 1 ? (const char *)(Msgid1) : (const char *)(Msgid2))
# define textdomain(Domainname) ((const char *)(Domainname))
# define bindtextdomain(Domainname, Dirname) ((const char *)(Dirname))
# define bind_textdomain_codeset(Domainname, Codeset) ((const char *)(Codeset))
#endif
/* A pseudo function call that serves as a marker for the automated
extraction of messages, but does not call gettext(). The run-time
translation is done at a different place in the code.
The argument, String, should be a literal string. Concatenated strings
and other string expressions won't work.
The macro's expansion is not parenthesized, so that it is suitable as
initializer for static 'char[]' or 'const char[]' variables. */
* extraction of messages, but does not call gettext(). The run-time
* translation is done at a different place in the code.
* The argument, String, should be a literal string. Concatenated strings
* and other string expressions won't work.
* The macro's expansion is not parenthesized, so that it is suitable as
* initializer for static 'char[]' or 'const char[]' variables. */
#define gettext_noop(String) String
#define _(String) (gettext(String))
#define _(String) (gettext(String))
#endif /* _LIBGETTEXT_H */

558
src/infconfig.c
View File

@ -8,32 +8,32 @@
#include "gettext.h"
#include "config-dialog.h"
//#define DEFAULT_WIDTH 500
#define DEFAULT_WIDTH 512
//#define DEFAULT_HEIGHT 375
#define DEFAULT_HEIGHT 288
#define DEFAULT_TIME_EFFECT 100
#define DEFAULT_TIME_PALETTE 100
#define DEFAULT_SCALE_FACTOR 1
#define DEFAULT_FPS 15
#define DEFAULT_SHOW_TITLE TRUE
//#define DEFAULT_WIDTH 500
#define DEFAULT_WIDTH 512
//#define DEFAULT_HEIGHT 375
#define DEFAULT_HEIGHT 288
#define DEFAULT_TIME_EFFECT 100
#define DEFAULT_TIME_PALETTE 100
#define DEFAULT_SCALE_FACTOR 1
#define DEFAULT_FPS 15
#define DEFAULT_SHOW_TITLE TRUE
#define INFINITY_CONFIG_DIR "/.audacious/infinity"
#define INFINITY_CONFIG_FILE (INFINITY_CONFIG_DIR "/infinity.ini")
#define INFINITY_CONFIG_DIR "/.audacious/infinity"
#define INFINITY_CONFIG_FILE (INFINITY_CONFIG_DIR "/infinity.ini")
typedef struct t_config {
gint32 x, y;
gint32 xres;
gint32 yres;
gint32 sres;
gint32 teff;
gint32 tcol;
gint32 fps;
gboolean show_title;
gint32 x, y;
gint32 xres;
gint32 yres;
gint32 sres;
gint32 teff;
gint32 tcol;
gint32 fps;
gboolean show_title;
} t_config;
static t_config config = {-1, -1, 0, 0, 0, 0, 0, 0, DEFAULT_SHOW_TITLE};
static t_config config = { -1, -1, 0, 0, 0, 0, 0, 0, DEFAULT_SHOW_TITLE };
static ConfigDialog *configure_dialog = NULL;
/*
@ -53,82 +53,80 @@ static t_config temp_config;
/*
* Callbacks for config_plugin_config_window
*/
static void scale_value_changed(GtkWidget *widget, gpointer data)
{
temp_config.sres = ((gint32)(GTK_ADJUSTMENT(widget)->value));
temp_config.sres = ((gint32)(GTK_ADJUSTMENT(widget)->value));
}
static void teff_value_changed(GtkWidget *widget, gpointer data)
{
temp_config.teff = ((gint32)(GTK_ADJUSTMENT(widget)->value));
temp_config.teff = ((gint32)(GTK_ADJUSTMENT(widget)->value));
}
static void tcol_value_changed(GtkWidget *widget, gpointer data)
{
temp_config.tcol = ((gint32)(GTK_ADJUSTMENT(widget)->value));
temp_config.tcol = ((gint32)(GTK_ADJUSTMENT(widget)->value));
}
static void on_fps_changed (GtkWidget *widget, gpointer data)
static void on_fps_changed(GtkWidget *widget, gpointer data)
{
gint32 value;
gint32 value;
value = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(configure_dialog->spinbutton_fps));
temp_config.fps = value;
g_message ("fps changed to %d", value);
value = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(configure_dialog->spinbutton_fps));
temp_config.fps = value;
g_message("fps changed to %d", value);
}
static void on_show_title_toggled (GtkWidget *widget, gpointer data)
static void on_show_title_toggled(GtkWidget *widget, gpointer data)
{
temp_config.show_title = !temp_config.show_title;
temp_config.show_title = !temp_config.show_title;
}
/*static gboolean check_cfg_version (ConfigFile *f)
* {
* gchar *vstr;
*
* if (xmms_cfg_read_string (f, "infinity", "version", &vstr))
* if (!strcmp (vstr, PACKAGE_VERSION))
* return TRUE;
* return FALSE;
*
* return TRUE;
* }*/
static void sync_options()
{
gchar *vstr;
if (xmms_cfg_read_string (f, "infinity", "version", &vstr))
if (!strcmp (vstr, PACKAGE_VERSION))
return TRUE;
return FALSE;
return TRUE;
}*/
static void sync_options ()
{
/*g_message ("Synchronizing options: sres %d, teff %d, tcol %d, fps %d",
temp_config.sres, temp_config.teff, temp_config.tcol, temp_config.fps);*/
config_set_sres (temp_config.sres);
config_set_teff (temp_config.teff);
config_set_tcol (temp_config.tcol);
config_set_fps (temp_config.fps);
config_set_show_title (temp_config.show_title);
/*g_message ("Synchronizing options: sres %d, teff %d, tcol %d, fps %d",
* temp_config.sres, temp_config.teff, temp_config.tcol, temp_config.fps);*/
config_set_sres(temp_config.sres);
config_set_teff(temp_config.teff);
config_set_tcol(temp_config.tcol);
config_set_fps(temp_config.fps);
config_set_show_title(temp_config.show_title);
}
static void apply_clicked (GtkWidget *w, GtkWidget *window)
static void apply_clicked(GtkWidget *w, GtkWidget *window)
{
g_message ("Applying changes ...");
sync_options ();
config_plugin_save_prefs();
g_message("Applying changes ...");
sync_options();
config_plugin_save_prefs();
}
static void ok_clicked (GtkWidget *w, GtkWidget *window)
static void ok_clicked(GtkWidget *w, GtkWidget *window)
{
apply_clicked (w, window);
config_dialog_hide (configure_dialog);
apply_clicked(w, window);
config_dialog_hide(configure_dialog);
}
static void cancel_clicked (GtkWidget *w, GtkWidget *window)
static void cancel_clicked(GtkWidget *w, GtkWidget *window)
{
g_message ("Cancelling changes...");
config_dialog_hide (configure_dialog);
g_message("Cancelling changes...");
config_dialog_hide(configure_dialog);
}
static void on_config_dialog_destroy (GtkWidget *widget, gpointer data)
static void on_config_dialog_destroy(GtkWidget *widget, gpointer data)
{
config_dialog_destroy (configure_dialog);
configure_dialog = NULL;
config_dialog_destroy(configure_dialog);
configure_dialog = NULL;
}
/*
@ -136,63 +134,63 @@ static void on_config_dialog_destroy (GtkWidget *widget, gpointer data)
* saved values. This way after cancel on a configure dialog, if
* we reopen it we get the saved values.
*/
static void set_config_values (ConfigDialog *config_dialog)
static void set_config_values(ConfigDialog *config_dialog)
{
GtkAdjustment *teadj, *tcadj, *scale_adj;
GtkAdjustment *teadj, *tcadj, *scale_adj;
g_return_if_fail (configure_dialog != NULL);
g_return_if_fail(configure_dialog != NULL);
teadj = gtk_range_get_adjustment (GTK_RANGE(config_dialog->hscale_effect));
gtk_adjustment_set_value (teadj, config_get_teff());
teadj = gtk_range_get_adjustment(GTK_RANGE(config_dialog->hscale_effect));
gtk_adjustment_set_value(teadj, config_get_teff());
tcadj = gtk_range_get_adjustment (GTK_RANGE(config_dialog->hscale_palette));
gtk_adjustment_set_value (tcadj, config_get_tcol());
tcadj = gtk_range_get_adjustment(GTK_RANGE(config_dialog->hscale_palette));
gtk_adjustment_set_value(tcadj, config_get_tcol());
scale_adj = gtk_range_get_adjustment (GTK_RANGE(config_dialog->hscale_scale_factor));
gtk_adjustment_set_value (scale_adj, config_get_sres());
scale_adj = gtk_range_get_adjustment(GTK_RANGE(config_dialog->hscale_scale_factor));
gtk_adjustment_set_value(scale_adj, config_get_sres());
gtk_spin_button_set_value (GTK_SPIN_BUTTON(config_dialog->spinbutton_fps), config_get_fps());
gtk_spin_button_set_value(GTK_SPIN_BUTTON(config_dialog->spinbutton_fps), config_get_fps());
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(config_dialog->checkbutton_show_title), config_get_show_title());
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(config_dialog->checkbutton_show_title), config_get_show_title());
/* Memorize current values */
temp_config.sres = config_get_sres();
temp_config.teff = config_get_teff();
temp_config.tcol = config_get_tcol();
temp_config.fps = config_get_fps();
temp_config.show_title = config_get_show_title();
/* Memorize current values */
temp_config.sres = config_get_sres();
temp_config.teff = config_get_teff();
temp_config.tcol = config_get_tcol();
temp_config.fps = config_get_fps();
temp_config.show_title = config_get_show_title();
}
static void connect_callbacks (ConfigDialog *configure_dialog)
static void connect_callbacks(ConfigDialog *configure_dialog)
{
GtkAdjustment *teadj, *tcadj, *scale_adj;
GtkAdjustment *teadj, *tcadj, *scale_adj;
g_return_if_fail (configure_dialog != NULL);
g_return_if_fail(configure_dialog != NULL);
gtk_signal_connect (GTK_OBJECT(configure_dialog->window_main), "destroy",
GTK_SIGNAL_FUNC(on_config_dialog_destroy), NULL);
gtk_signal_connect(GTK_OBJECT(configure_dialog->window_main), "destroy",
GTK_SIGNAL_FUNC(on_config_dialog_destroy), NULL);
teadj = gtk_range_get_adjustment (GTK_RANGE(configure_dialog->hscale_effect));
tcadj = gtk_range_get_adjustment (GTK_RANGE(configure_dialog->hscale_palette));
scale_adj = gtk_range_get_adjustment (GTK_RANGE(configure_dialog->hscale_scale_factor));
teadj = gtk_range_get_adjustment(GTK_RANGE(configure_dialog->hscale_effect));
tcadj = gtk_range_get_adjustment(GTK_RANGE(configure_dialog->hscale_palette));
scale_adj = gtk_range_get_adjustment(GTK_RANGE(configure_dialog->hscale_scale_factor));
gtk_signal_connect (GTK_OBJECT(teadj), "value-changed",
GTK_SIGNAL_FUNC(teff_value_changed), NULL);
gtk_signal_connect (GTK_OBJECT(tcadj), "value-changed",
GTK_SIGNAL_FUNC(tcol_value_changed), NULL);
gtk_signal_connect (GTK_OBJECT(scale_adj), "value-changed",
GTK_SIGNAL_FUNC(scale_value_changed), NULL);
gtk_signal_connect (GTK_OBJECT(configure_dialog->spinbutton_fps), "changed",
GTK_SIGNAL_FUNC(on_fps_changed), NULL);
gtk_signal_connect (GTK_OBJECT(configure_dialog->checkbutton_show_title), "toggled",
GTK_SIGNAL_FUNC(on_show_title_toggled), NULL);
gtk_signal_connect(GTK_OBJECT(teadj), "value-changed",
GTK_SIGNAL_FUNC(teff_value_changed), NULL);
gtk_signal_connect(GTK_OBJECT(tcadj), "value-changed",
GTK_SIGNAL_FUNC(tcol_value_changed), NULL);
gtk_signal_connect(GTK_OBJECT(scale_adj), "value-changed",
GTK_SIGNAL_FUNC(scale_value_changed), NULL);
gtk_signal_connect(GTK_OBJECT(configure_dialog->spinbutton_fps), "changed",
GTK_SIGNAL_FUNC(on_fps_changed), NULL);
gtk_signal_connect(GTK_OBJECT(configure_dialog->checkbutton_show_title), "toggled",
GTK_SIGNAL_FUNC(on_show_title_toggled), NULL);
gtk_signal_connect (GTK_OBJECT(configure_dialog->button_ok), "clicked",
GTK_SIGNAL_FUNC(ok_clicked), NULL);
gtk_signal_connect (GTK_OBJECT(configure_dialog->button_cancel), "clicked",
GTK_SIGNAL_FUNC(cancel_clicked), NULL);
gtk_signal_connect (GTK_OBJECT(configure_dialog->button_apply), "clicked",
GTK_SIGNAL_FUNC(apply_clicked), NULL);
gtk_signal_connect(GTK_OBJECT(configure_dialog->button_ok), "clicked",
GTK_SIGNAL_FUNC(ok_clicked), NULL);
gtk_signal_connect(GTK_OBJECT(configure_dialog->button_cancel), "clicked",
GTK_SIGNAL_FUNC(cancel_clicked), NULL);
gtk_signal_connect(GTK_OBJECT(configure_dialog->button_apply), "clicked",
GTK_SIGNAL_FUNC(apply_clicked), NULL);
}
/*
@ -200,268 +198,256 @@ static void connect_callbacks (ConfigDialog *configure_dialog)
* Public functions
*
*/
void config_plugin_load_prefs (void)
void config_plugin_load_prefs(void)
{
gint value;
//gboolean bvalue;
GKeyFile * kf;
gchar * config_file_path;
gboolean error, must_update, config_file_usable;
gint value;
//gboolean bvalue;
GKeyFile *kf;
gchar *config_file_path;
gboolean error, must_update, config_file_usable;
kf = g_key_file_new();
config_file_path = g_strconcat (g_get_home_dir(), INFINITY_CONFIG_FILE, 0);
config_file_usable = g_key_file_load_from_file (kf, config_file_path, G_KEY_FILE_KEEP_COMMENTS, NULL);
error = must_update = FALSE;
if (config_file_usable) {
if (TRUE) {
//TODO if (check_cfg_version (f)) {
// g_message("version Ok");
if ((value = g_key_file_get_integer (kf, "Preferences", "xres", NULL)) > 0) {
config_set_xres (value);
} else {
error = TRUE;
}
if ((value = g_key_file_get_integer (kf, "Preferences", "yres", NULL)) > 0) {
config_set_yres (value);
} else {
error = TRUE;
}
if ((value = g_key_file_get_integer (kf, "Preferences", "teff", NULL)) > 0) {
config_set_teff (value);
} else {
error = TRUE;
}
if ((value = g_key_file_get_integer (kf, "Preferences", "tcol", NULL)) > 0) {
config_set_tcol (value);
} else {
error = TRUE;
}
if ((value = g_key_file_get_integer (kf, "Preferences", "sres", NULL)) > 0) {
config_set_sres (value);
} else {
error = TRUE;
}
if ((value = g_key_file_get_integer (kf, "Preferences", "fps", NULL)) > 0) {
config_set_fps (value);
} else {
error = TRUE;
}
//config_set_show_title (g_key_file_get_boolean (kf, "Preferences", "show_title", NULL));
kf = g_key_file_new();
config_file_path = g_strconcat(g_get_home_dir(), INFINITY_CONFIG_FILE, 0);
config_file_usable = g_key_file_load_from_file(kf, config_file_path, G_KEY_FILE_KEEP_COMMENTS, NULL);
error = must_update = FALSE;
if (config_file_usable) {
if (TRUE) {
//TODO if (check_cfg_version (f)) {
// g_message("version Ok");
if ((value = g_key_file_get_integer(kf, "Preferences", "xres", NULL)) > 0)
config_set_xres(value);
else
error = TRUE;
if ((value = g_key_file_get_integer(kf, "Preferences", "yres", NULL)) > 0)
config_set_yres(value);
else
error = TRUE;
if ((value = g_key_file_get_integer(kf, "Preferences", "teff", NULL)) > 0)
config_set_teff(value);
else
error = TRUE;
if ((value = g_key_file_get_integer(kf, "Preferences", "tcol", NULL)) > 0)
config_set_tcol(value);
else
error = TRUE;
if ((value = g_key_file_get_integer(kf, "Preferences", "sres", NULL)) > 0)
config_set_sres(value);
else
error = TRUE;
if ((value = g_key_file_get_integer(kf, "Preferences", "fps", NULL)) > 0)
config_set_fps(value);
else
error = TRUE;
//config_set_show_title (g_key_file_get_boolean (kf, "Preferences", "show_title", NULL));
/* FIXME for now these are not used */
//xmms_cfg_read_int (f, "infinity", "xorig", &value);
//config_set_x (value);
//xmms_cfg_read_int (f, "infinity", "yorig", &value);
//config_set_y (value);
} else {
config_set_default_values ();
must_update = TRUE;
}
} else {
config_set_default_values ();
must_update = TRUE;
}
g_free (config_file_path);
g_key_file_free (kf);
/* FIXME for now these are not used */
//xmms_cfg_read_int (f, "infinity", "xorig", &value);
//config_set_x (value);
//xmms_cfg_read_int (f, "infinity", "yorig", &value);
//config_set_y (value);
} else {
config_set_default_values();
must_update = TRUE;
}
} else {
config_set_default_values();
must_update = TRUE;
}
g_free(config_file_path);
g_key_file_free(kf);
if (error || must_update) {
if (error)
g_message ("Fixing errors on Infinity's configure file...");
else
g_message ("Updating Infinity's configure file...");
if (error || must_update) {
if (error)
g_message("Fixing errors on Infinity's configure file...");
else
g_message("Updating Infinity's configure file...");
config_plugin_save_prefs();
}
config_plugin_save_prefs();
}
}
void config_plugin_save_prefs (void)
void config_plugin_save_prefs(void)
{
gchar * config_file_path, * config_dir_path;
GKeyFile * kf;
gboolean ok;
gchar * preferences;
gsize length;
kf = g_key_file_new();
config_dir_path = g_strconcat (g_get_home_dir(), INFINITY_CONFIG_DIR, 0);
config_file_path = g_strconcat (g_get_home_dir(), INFINITY_CONFIG_FILE, 0);
ok = g_key_file_load_from_file (kf, config_file_path, G_KEY_FILE_KEEP_COMMENTS, NULL);
if (!ok) {
g_message (_("Infinity plugin .ini file not found"));
if (!g_file_test (config_dir_path, G_FILE_TEST_EXISTS)) {
g_message (_("Creating Infinity plugin config directory '%s'"), INFINITY_CONFIG_DIR);
if (g_mkdir_with_parents (config_dir_path, S_IRWXU) != 0) {
gchar *config_file_path, *config_dir_path;
GKeyFile *kf;
gboolean ok;
gchar *preferences;
gsize length;
g_warning (_("Cannot save preferences: unable to create directory '%s'"), config_dir_path);
g_free (config_file_path);
g_free (config_dir_path);
g_key_file_free (kf);
return;
}
}
}
if (!config_is_initialized ()) {
config_set_default_values ();
}
//g_key_file_set_value (kf, "Preferences", "version", PACKAGE_VERSION);
g_key_file_set_integer (kf, "Preferences", "xres", config_get_xres());
g_key_file_set_integer (kf, "Preferences", "yres", config_get_yres());
g_key_file_set_integer (kf, "Preferences", "teff", config_get_teff());
g_key_file_set_integer (kf, "Preferences", "tcol", config_get_tcol());
g_key_file_set_integer (kf, "Preferences", "sres", config_get_sres());
g_key_file_set_integer (kf, "Preferences", "fps", config_get_fps());
//g_key_file_set_boolean (kf, "Preferences", "show_title", config_get_show_title());
preferences = g_key_file_to_data (kf, &length, NULL);
ok = g_file_set_contents (config_file_path, preferences, length, NULL);
if (!ok) {
g_warning (_("Error saving preferences"));
}
g_free (preferences);
g_free (config_file_path);
g_free (config_dir_path);
g_key_file_free (kf);
kf = g_key_file_new();
config_dir_path = g_strconcat(g_get_home_dir(), INFINITY_CONFIG_DIR, 0);
config_file_path = g_strconcat(g_get_home_dir(), INFINITY_CONFIG_FILE, 0);
ok = g_key_file_load_from_file(kf, config_file_path, G_KEY_FILE_KEEP_COMMENTS, NULL);
if (!ok) {
g_message(_("Infinity plugin .ini file not found"));
if (!g_file_test(config_dir_path, G_FILE_TEST_EXISTS)) {
g_message(_("Creating Infinity plugin config directory '%s'"), INFINITY_CONFIG_DIR);
if (g_mkdir_with_parents(config_dir_path, S_IRWXU) != 0) {
g_warning(_("Cannot save preferences: unable to create directory '%s'"), config_dir_path);
g_free(config_file_path);
g_free(config_dir_path);
g_key_file_free(kf);
return;
}
}
}
if (!config_is_initialized())
config_set_default_values();
//g_key_file_set_value (kf, "Preferences", "version", PACKAGE_VERSION);
g_key_file_set_integer(kf, "Preferences", "xres", config_get_xres());
g_key_file_set_integer(kf, "Preferences", "yres", config_get_yres());
g_key_file_set_integer(kf, "Preferences", "teff", config_get_teff());
g_key_file_set_integer(kf, "Preferences", "tcol", config_get_tcol());
g_key_file_set_integer(kf, "Preferences", "sres", config_get_sres());
g_key_file_set_integer(kf, "Preferences", "fps", config_get_fps());
//g_key_file_set_boolean (kf, "Preferences", "show_title", config_get_show_title());
preferences = g_key_file_to_data(kf, &length, NULL);
ok = g_file_set_contents(config_file_path, preferences, length, NULL);
if (!ok)
g_warning(_("Error saving preferences"));
g_free(preferences);
g_free(config_file_path);
g_free(config_dir_path);
g_key_file_free(kf);
}
void config_set_default_values (void)
void config_set_default_values(void)
{
config_set_x (20);
config_set_y (10);
config_set_xres (DEFAULT_WIDTH);
config_set_yres (DEFAULT_HEIGHT);
config_set_teff (DEFAULT_TIME_EFFECT);
config_set_tcol (DEFAULT_TIME_PALETTE);
config_set_sres (DEFAULT_SCALE_FACTOR);
config_set_fps (DEFAULT_FPS);
config_set_show_title (DEFAULT_SHOW_TITLE);
config_set_x(20);
config_set_y(10);
config_set_xres(DEFAULT_WIDTH);
config_set_yres(DEFAULT_HEIGHT);
config_set_teff(DEFAULT_TIME_EFFECT);
config_set_tcol(DEFAULT_TIME_PALETTE);
config_set_sres(DEFAULT_SCALE_FACTOR);
config_set_fps(DEFAULT_FPS);
config_set_show_title(DEFAULT_SHOW_TITLE);
}
gboolean config_is_initialized (void)
gboolean config_is_initialized(void)
{
/* FIXME mhm, ugly thing... */
//return ((config.x > -1) && (config.y > -1) &&
return ((config.xres != 0) && (config.yres != 0) &&
(config.sres != 0) && (config.teff != 0) &&
(config.tcol != 0) && (config.fps != 0));
/* FIXME mhm, ugly thing... */
//return ((config.x > -1) && (config.y > -1) &&
return (config.xres != 0) && (config.yres != 0) &&
(config.sres != 0) && (config.teff != 0) &&
(config.tcol != 0) && (config.fps != 0);
}
void config_plugin_config_window (void)
void config_plugin_config_window(void)
{
#if ENABLE_NLS
setlocale (LC_MESSAGES, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
textdomain (GETTEXT_PACKAGE);
setlocale(LC_MESSAGES, "");
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
textdomain(GETTEXT_PACKAGE);
#endif
if (configure_dialog) {
set_config_values (configure_dialog);
config_dialog_show (configure_dialog);
return;
}
if (configure_dialog) {
set_config_values(configure_dialog);
config_dialog_show(configure_dialog);
return;
}
config_plugin_load_prefs ();
if (!config_is_initialized ()) {
config_set_default_values ();
}
config_plugin_load_prefs();
if (!config_is_initialized())
config_set_default_values();
configure_dialog = config_dialog_new ();
configure_dialog = config_dialog_new();
set_config_values (configure_dialog);
set_config_values(configure_dialog);
connect_callbacks (configure_dialog);
connect_callbacks(configure_dialog);
config_dialog_show (configure_dialog);
config_dialog_show(configure_dialog);
}
void config_set_x (gint32 value)
void config_set_x(gint32 value)
{
config.x = value;
config.x = value;
}
void config_set_y (gint32 value)
void config_set_y(gint32 value)
{
config.y = value;
config.y = value;
}
void config_set_xres (gint32 value)
void config_set_xres(gint32 value)
{
config.xres = value;
config.xres = value;
}
void config_set_yres (gint32 value)
void config_set_yres(gint32 value)
{
config.yres = value;
config.yres = value;
}
void config_set_teff (gint32 value)
void config_set_teff(gint32 value)
{
config.teff = value;
config.teff = value;
}
void config_set_tcol (gint32 value)
void config_set_tcol(gint32 value)
{
config.tcol = value;
config.tcol = value;
}
void config_set_sres (gint32 value)
void config_set_sres(gint32 value)
{
config.sres = value;
config.sres = value;
}
void config_set_fps (gint32 value)
void config_set_fps(gint32 value)
{
config.fps = value;
config.fps = value;
}
void config_set_show_title (gboolean value)
void config_set_show_title(gboolean value)
{
config.show_title = value;
config.show_title = value;
}
gint32 config_get_x (void)
gint32 config_get_x(void)
{
return config.x;
return config.x;
}
gint32 config_get_y (void)
gint32 config_get_y(void)
{
return config.y;
return config.y;
}
gint32 config_get_xres (void)
gint32 config_get_xres(void)
{
return config.xres;
return config.xres;
}
gint32 config_get_yres (void)
gint32 config_get_yres(void)
{
return config.yres;
return config.yres;
}
gint32 config_get_teff (void)
gint32 config_get_teff(void)
{
return config.teff;
return config.teff;
}
gint32 config_get_tcol (void)
gint32 config_get_tcol(void)
{
return config.tcol;
return config.tcol;
}
gint32 config_get_sres (void)
gint32 config_get_sres(void)
{
return config.sres;
return config.sres;
}
gint32 config_get_fps (void)
gint32 config_get_fps(void)
{
return config.fps;
return config.fps;
}
gboolean config_get_show_title (void)
gboolean config_get_show_title(void)
{
return config.show_title;
return config.show_title;
}

62
src/infconfig.h
View File

@ -12,8 +12,8 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __INFINITY_CONFIG__
*/
#ifndef __INFINITY_CONFIG__
#define __INFINITY_CONFIG__
@ -30,54 +30,54 @@
* of the config module.
*/
typedef struct _t_screen_parameters {
gint32 x, y;
gint32 width;
gint32 height;
gint32 scale;
gint32 bpp; /**< bytes per pixels. */
gint32 x, y;
gint32 width;
gint32 height;
gint32 scale;
gint32 bpp; /**< bytes per pixels. */
} t_screen_parameters;
/*
* Read user preferences from ~/.xmms/config file
*/
void config_plugin_load_prefs (void);
void config_plugin_load_prefs(void);
void config_plugin_save_prefs (void);
void config_plugin_save_prefs(void);
void config_set_default_values (void);
void config_set_default_values(void);
/*
* \return TRUE if config_plugin_load_prefs() or
* config_set_default_values() has been called.
*/
gboolean config_is_initialized (void);
gboolean config_is_initialized(void);
/*
* Open a window to let the user choose and
* Open a window to let the user choose and
* save your options.
*/
void config_plugin_config_window (void);
void config_plugin_config_window(void);
void config_set_x (gint32 value);
void config_set_y (gint32 value);
void config_set_xres (gint32 value);
void config_set_yres (gint32 value);
void config_set_teff (gint32 value);
void config_set_tcol (gint32 value);
void config_set_sres (gint32 value);
void config_set_fps (gint32 value);
void config_set_show_title (gboolean value);
void config_set_x(gint32 value);
void config_set_y(gint32 value);
void config_set_xres(gint32 value);
void config_set_yres(gint32 value);
void config_set_teff(gint32 value);
void config_set_tcol(gint32 value);
void config_set_sres(gint32 value);
void config_set_fps(gint32 value);
void config_set_show_title(gboolean value);
gint32 config_get_x (void);
gint32 config_get_y (void);
gint32 config_get_xres (void);
gint32 config_get_yres (void);
gint32 config_get_teff (void);
gint32 config_get_tcol (void);
gint32 config_get_sres (void);
gint32 config_get_fps (void);
gboolean config_get_show_title (void);
gint32 config_get_x(void);
gint32 config_get_y(void);
gint32 config_get_xres(void);
gint32 config_get_yres(void);
gint32 config_get_teff(void);
gint32 config_get_tcol(void);
gint32 config_get_sres(void);
gint32 config_get_fps(void);
gboolean config_get_show_title(void);
#endif /* __INFINITY_CONFIG__ */

96
src/main.c
View File

@ -19,7 +19,7 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
*/
#include <string.h>
#include <audacious/plugin.h>
#include <gtk/gtk.h>
@ -34,72 +34,72 @@ static const char infinity_about[] =
"Version " PACKAGE_VERSION "\n\n"
"https://github.com/dprotti/infinity-plugin");
static bool_t plugin_init (void);
static void plugin_close (void);
static void clear (void);
static bool_t plugin_init(void);
static void plugin_close(void);
static void clear(void);
/*
* Registers plugin with Audacious.
*/
AUD_VIS_PLUGIN (
.name = "Infinity",
.init = plugin_init,
.cleanup = plugin_close,
.take_message = NULL,
AUD_VIS_PLUGIN(
.name = "Infinity",
.init = plugin_init,
.cleanup = plugin_close,
.take_message = NULL,
.about = NULL,
.about_text = infinity_about,
.configure = config_plugin_config_window,
//.playback_stop = NULL,
.configure = config_plugin_config_window,
//.playback_stop = NULL,
/* reset internal state and clear display */
.clear = clear,
/* reset internal state and clear display */
.clear = clear,
/* 512 frames of a single-channel PCM signal */
.render_mono_pcm = NULL,
/* 512 frames of a single-channel PCM signal */
.render_mono_pcm = NULL,
/* 512 frames of an interleaved multi-channel PCM signal */
.render_multi_pcm = renderer_render_multi_pcm,
/* 512 frames of an interleaved multi-channel PCM signal */
.render_multi_pcm = renderer_render_multi_pcm,
/* intensity of frequencies 1/512, 2/512, ..., 256/512 of sample rate */
.render_freq = NULL,
/* intensity of frequencies 1/512, 2/512, ..., 256/512 of sample rate */
.render_freq = NULL,
/* GtkWidget * (* get_widget) (void); */
.get_widget = NULL
);
/* GtkWidget * (* get_widget) (void); */
.get_widget = NULL
);
static void clear (void) {
g_message ("TODO implement clear()");
static void clear(void)
{
g_message("TODO implement clear()");
}
static bool_t plugin_init (void)
static bool_t plugin_init(void)
{
#if ENABLE_NLS
(void) setlocale (LC_MESSAGES, "");
(void) bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
(void) textdomain (GETTEXT_PACKAGE);
(void)setlocale(LC_MESSAGES, "");
(void)bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
(void)textdomain(GETTEXT_PACKAGE);
#endif
g_message (_("Infinity commands:\n"
"- Space:\tchange effect.\n"
"- Tab:\t\ttoggle full-screen.\n"
"- Up/Down:\tup/down main volume.\n"
"- Left/Right:\treward/forward actual played song, if any.\n"
"- z:\t\tprevious song.\n"
"- x:\t\tplay.\n"
"- c:\t\tpause.\n"
"- v:\t\tstop.\n"
"- b:\t\tnext song.\n"
"- Enter:\tswitch to interactive mode.\n\t\t(works only if infinity was configured with --enable-debug option)\n"
"- F11:\t\tscreenshot.\n"
"- F12:\t\tchange palette."));
config_plugin_load_prefs ();
renderer_init ();
return TRUE;
g_message(_("Infinity commands:\n"
"- Space:\tchange effect.\n"
"- Tab:\t\ttoggle full-screen.\n"
"- Up/Down:\tup/down main volume.\n"
"- Left/Right:\treward/forward actual played song, if any.\n"
"- z:\t\tprevious song.\n"
"- x:\t\tplay.\n"
"- c:\t\tpause.\n"
"- v:\t\tstop.\n"
"- b:\t\tnext song.\n"
"- Enter:\tswitch to interactive mode.\n\t\t(works only if infinity was configured with --enable-debug option)\n"
"- F11:\t\tscreenshot.\n"
"- F12:\t\tchange palette."));
config_plugin_load_prefs();
renderer_init();
return TRUE;
}
static void plugin_close (void)
static void plugin_close(void)
{
config_plugin_save_prefs ();
renderer_finish ();
config_plugin_save_prefs();
renderer_finish();
}

168
src/main.c.orig
View File

@ -1,168 +0,0 @@
/**
* \file main.c
*
* \brief The main module of Infinity plugin.
*
* The only thing that a XMMS visualization plugin has to do
* (from the point of view of XMMS) is to export a function called
* get_vplugin_info() wich returns a pointer to a VisPlugin structure.
* This struct is defined in xmms/plugin.h. It contains pointers to
* functions which will be called on the ocurrence of certain events.
*/
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <string.h>
#include <xmms/plugin.h>
#include <xmms/configfile.h>
#include <xmms/util.h>
#include <gtk/gtk.h>
#include "config.h"
#include "infconfig.h"
#include "renderer.h"
#include "gettext.h"
VisPlugin *get_vplugin_info(void);
static void plugin_init (void);
static void plugin_close (void);
static void plugin_about (void);
/**
* Structure shared with XMMS in order to register and get information
* about the plugin.
*
* The \a VisPlugin type is defined on <xmms/plugin.h>. XMMS will
* obtain a reference to this structure calling ::get_vplugin_info()
* when started.
*/
static VisPlugin sdlblur_vp = {
NULL, /**< Handle, filled in by xmms */
NULL, /**< Filename, filled in by xmms */
0, /**< XMMS Session ID, filled in by XMMS */
"Infinity " PACKAGE_VERSION, /**< description */
2, /**< Number of PCM channels wanted */
0, /**< Number of freq channels wanted */
plugin_init, /**< Called when plugin is enabled */
plugin_close, /**< Called when plugin is disabled */
plugin_about, /**< Show the about box */
config_plugin_config_window, /**< Show the configure box */
NULL, /**<
void (*disable_plugin)(struct _VisPlugin *)
Called to disable plugin, filled in by XMMS.
Must be called with a pointer to our plugin
struct to disable the plugin */
NULL, /**< Called when playback starts */
NULL, /**< Called when playback stops */
renderer_set_pcm_data, /**< Render the PCM data */
NULL, /**< Render the freq data */
};
static void plugin_init(void)
{
#if ENABLE_NLS
(void) setlocale (LC_MESSAGES, "");
(void) bindtextdomain (PACKAGE, LOCALEDIR);
(void) textdomain (PACKAGE);
#endif
g_message (_("Infinity commands:\n"
"- Space:\tchange effect.\n"
"- Tab:\t\ttoggle full-screen.\n"
"- Up/Down:\tup/down xmms main volume.\n"
"- Left/Right:\treward/forward actual played song, if any.\n"
"- z:\t\tprevious song.\n"
"- x:\t\tplay.\n"
"- c:\t\tpause.\n"
"- v:\t\tstop.\n"
"- b:\t\tnext song.\n"
"- Enter:\tswitch to interactive mode.\n\t\t(works only if infinity was configured with --enable-debug option)\n"
"- F11:\t\tscreenshot.\n"
"- F12:\t\tchange palette."));
config_plugin_load_prefs ();
renderer_set_plugin_info (&sdlblur_vp);
renderer_init ();
}
static void plugin_close (void)
{
config_plugin_save_prefs ();
renderer_finish ();
}
static void dummy (GtkWidget *widget, gpointer data)
{
}
static void plugin_about (void)
{
GtkWidget *window_about;
#if ENABLE_NLS
(void) setlocale (LC_MESSAGES, "");
(void) bindtextdomain (PACKAGE, LOCALEDIR);
(void) textdomain (PACKAGE);
#endif
window_about = xmms_show_message (_("About Infinity"),
_("\n" PACKAGE_STRING "\n"
"\n<http://infinity-plugin.sf.net>\n"
"\nCopyright (C) 2000, Julien Carme.\n"
"Email: <julien.carme@acm.org>\n"
"\n"
"Duilio J. Protti <dprotti@fceia.unr.edu.ar>\n"
"Actual maintainer\n"
"\n"
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 2 of the License, or\n"
"(at your option) any later version.\n"
"\n"
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program; if not, write to the Free Software\n"
"Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307\n"
"USA"),
_("Ok"), FALSE, dummy, NULL);
gtk_widget_show (window_about);
}
/*
*
* Public functions
*
*/
/**
* Function to be exported to XMMS in order to register the plugin.
*/
VisPlugin *get_vplugin_info(void)
{
return &sdlblur_vp;
}

12
src/maintest.c
View File

@ -6,17 +6,17 @@
#include "main.h"
#include "renderer.h"
gint32 playing, finished, reset,closed;
gint32 playing, finished, reset, closed;
gint32 refreshed;
gint16 pcm_data[2][512];
gint16 freq_data[2][256];
gint32 pcm_count=0, freq_count=0;
gint32 pcm_count = 0, freq_count = 0;
gint32 tr;
int main (int argc, char *argv[])
{
finished=FALSE;
closed=FALSE;
int main(int argc, char *argv[])
{
finished = FALSE;
closed = FALSE;
/* mutex=SDL_CreateMutex(); */
/* FIXME check if there is MMX support here */
init_renderer();

584
src/mmx.h
View File

@ -1,166 +1,166 @@
/* mmx.h
MultiMedia eXtensions GCC interface library for IA32.
To use this library, simply include this header file
and compile with GCC. You MUST have inlining enabled
in order for mmx_ok() to work; this can be done by
simply using -O on the GCC command line.
Compiling with -DMMX_TRACE will cause detailed trace
output to be sent to stderr for each mmx operation.
This adds lots of code, and obviously slows execution to
a crawl, but can be very useful for debugging.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR ANY PARTICULAR PURPOSE.
1997-99 by H. Dietz and R. Fisher
Notes:
It appears that the latest gas has the pand problem fixed, therefore
I'll undefine BROKEN_PAND by default.
*/
*
* MultiMedia eXtensions GCC interface library for IA32.
*
* To use this library, simply include this header file
* and compile with GCC. You MUST have inlining enabled
* in order for mmx_ok() to work; this can be done by
* simply using -O on the GCC command line.
*
* Compiling with -DMMX_TRACE will cause detailed trace
* output to be sent to stderr for each mmx operation.
* This adds lots of code, and obviously slows execution to
* a crawl, but can be very useful for debugging.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
* LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR ANY PARTICULAR PURPOSE.
*
* 1997-99 by H. Dietz and R. Fisher
*
* Notes:
* It appears that the latest gas has the pand problem fixed, therefore
* I'll undefine BROKEN_PAND by default.
*/
#ifndef _MMX_H_
#define _MMX_H_
/* Warning: at this writing, the version of GAS packaged
with most Linux distributions does not handle the
parallel AND operation mnemonic correctly. If the
symbol BROKEN_PAND is defined, a slower alternative
coding will be used. If execution of mmxtest results
in an illegal instruction fault, define this symbol.
*/
#undef BROKEN_PAND
* with most Linux distributions does not handle the
* parallel AND operation mnemonic correctly. If the
* symbol BROKEN_PAND is defined, a slower alternative
* coding will be used. If execution of mmxtest results
* in an illegal instruction fault, define this symbol.
*/
#undef BROKEN_PAND
/* The type of an value that fits in an MMX register
(note that long long constant values MUST be suffixed
by LL and unsigned long long values by ULL, lest
they be truncated by the compiler)
*/
typedef union {
gint64 q; /* Quadword (64-bit) value */
guint64 uq; /* Unsigned Quadword */
gint32 d[2]; /* 2 Doubleword (32-bit) values */
guint32 ud[2]; /* 2 Unsigned Doubleword */
gint16 w[4]; /* 4 Word (16-bit) values */
guint16 uw[4]; /* 4 Unsigned Word */
gchar b[8]; /* 8 Byte (8-bit) values */
guchar ub[8]; /* 8 Unsigned Byte */
gfloat s[2]; /* Single-precision (32-bit) value */
} __attribute__ ((aligned (8))) mmx_t; /* On an 8-byte (64-bit) boundary */
* (note that long long constant values MUST be suffixed
* by LL and unsigned long long values by ULL, lest
* they be truncated by the compiler)
*/
typedef union {
gint64 q; /* Quadword (64-bit) value */
guint64 uq; /* Unsigned Quadword */
gint32 d[2]; /* 2 Doubleword (32-bit) values */
guint32 ud[2]; /* 2 Unsigned Doubleword */
gint16 w[4]; /* 4 Word (16-bit) values */
guint16 uw[4]; /* 4 Unsigned Word */
gchar b[8]; /* 8 Byte (8-bit) values */
guchar ub[8]; /* 8 Unsigned Byte */
gfloat s[2]; /* Single-precision (32-bit) value */
} __attribute__ ((aligned(8))) mmx_t; /* On an 8-byte (64-bit) boundary */
/* Helper functions for the instruction macros that follow...
(note that memory-to-register, m2r, instructions are nearly
as efficient as register-to-register, r2r, instructions;
however, memory-to-memory instructions are really simulated
as a convenience, and are only 1/3 as efficient)
*/
#ifdef MMX_TRACE
* (note that memory-to-register, m2r, instructions are nearly
* as efficient as register-to-register, r2r, instructions;
* however, memory-to-memory instructions are really simulated
* as a convenience, and are only 1/3 as efficient)
*/
#ifdef MMX_TRACE
/* Include the stuff for printing a trace to stderr...
*/
*/
#include <stdio.h>
#define mmx_i2r(op, imm, reg) \
#define mmx_i2r(op, imm, reg) \
{ \
mmx_t mmx_trace; \
mmx_trace.uq = (imm); \
printf(#op "_i2r(" #imm "=0x%08x%08x, ", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
__asm__ __volatile__ ("movq %%" #reg ", %0" \
: "=X" (mmx_trace) \
: /* nothing */ ); \
: /* nothing */); \
printf(#reg "=0x%08x%08x) => ", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
__asm__ __volatile__ (#op " %0, %%" #reg \
: /* nothing */ \
: "X" (imm)); \
__asm__ __volatile__ ("movq %%" #reg ", %0" \
: "=X" (mmx_trace) \
: /* nothing */ ); \
: /* nothing */); \
printf(#reg "=0x%08x%08x\n", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
}
#define mmx_m2r(op, mem, reg) \
#define mmx_m2r(op, mem, reg) \
{ \
mmx_t mmx_trace; \
mmx_trace = (mem); \
printf(#op "_m2r(" #mem "=0x%08x%08x, ", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
__asm__ __volatile__ ("movq %%" #reg ", %0" \
: "=X" (mmx_trace) \
: /* nothing */ ); \
: /* nothing */); \
printf(#reg "=0x%08x%08x) => ", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
__asm__ __volatile__ (#op " %0, %%" #reg \
: /* nothing */ \
: "X" (mem)); \
__asm__ __volatile__ ("movq %%" #reg ", %0" \
: "=X" (mmx_trace) \
: /* nothing */ ); \
: /* nothing */); \
printf(#reg "=0x%08x%08x\n", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
}
#define mmx_r2m(op, reg, mem) \
#define mmx_r2m(op, reg, mem) \
{ \
mmx_t mmx_trace; \
__asm__ __volatile__ ("movq %%" #reg ", %0" \
: "=X" (mmx_trace) \
: /* nothing */ ); \
: /* nothing */); \
printf(#op "_r2m(" #reg "=0x%08x%08x, ", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace = (mem); \
printf(#mem "=0x%08x%08x) => ", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
__asm__ __volatile__ (#op " %%" #reg ", %0" \
: "=X" (mem) \
: /* nothing */ ); \
: /* nothing */); \
mmx_trace = (mem); \
printf(#mem "=0x%08x%08x\n", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
}
#define mmx_r2r(op, regs, regd) \
#define mmx_r2r(op, regs, regd) \
{ \
mmx_t mmx_trace; \
__asm__ __volatile__ ("movq %%" #regs ", %0" \
: "=X" (mmx_trace) \
: /* nothing */ ); \
: /* nothing */); \
printf(#op "_r2r(" #regs "=0x%08x%08x, ", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
__asm__ __volatile__ ("movq %%" #regd ", %0" \
: "=X" (mmx_trace) \
: /* nothing */ ); \
: /* nothing */); \
printf(#regd "=0x%08x%08x) => ", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
__asm__ __volatile__ (#op " %" #regs ", %" #regd); \
__asm__ __volatile__ ("movq %%" #regd ", %0" \
: "=X" (mmx_trace) \
: /* nothing */ ); \
: /* nothing */); \
printf(#regd "=0x%08x%08x\n", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
}
#define mmx_m2m(op, mems, memd) \
#define mmx_m2m(op, mems, memd) \
{ \
mmx_t mmx_trace; \
mmx_trace = (mems); \
printf(#op "_m2m(" #mems "=0x%08x%08x, ", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace = (memd); \
printf(#memd "=0x%08x%08x) => ", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
__asm__ __volatile__ ("movq %0, %%mm0\n\t" \
#op " %1, %%mm0\n\t" \
"movq %%mm0, %0" \
@ -168,33 +168,33 @@ typedef union {
: "X" (mems)); \
mmx_trace = (memd); \
printf(#memd "=0x%08x%08x\n", \
mmx_trace.d[1], mmx_trace.d[0]); \
mmx_trace.d[1], mmx_trace.d[0]); \
}
#else
/* These macros are a lot simpler without the tracing...
*/
*/
#define mmx_i2r(op, imm, reg) \
#define mmx_i2r(op, imm, reg) \
__asm__ __volatile__ (#op " %0, %%" #reg \
: /* nothing */ \
: "X" (imm) )
: "X" (imm))
#define mmx_m2r(op, mem, reg) \
#define mmx_m2r(op, mem, reg) \
__asm__ __volatile__ (#op " %0, %%" #reg \
: /* nothing */ \
: "X" (mem))
#define mmx_r2m(op, reg, mem) \
#define mmx_r2m(op, reg, mem) \
__asm__ __volatile__ (#op " %%" #reg ", %0" \
: "=X" (mem) \
: /* nothing */ )
: /* nothing */)
#define mmx_r2r(op, regs, regd) \
#define mmx_r2r(op, regs, regd) \
__asm__ __volatile__ (#op " %" #regs ", %" #regd)
#define mmx_m2m(op, mems, memd) \
#define mmx_m2m(op, mems, memd) \
__asm__ __volatile__ ("movq %0, %%mm0\n\t" \
#op " %1, %%mm0\n\t" \
"movq %%mm0, %0" \
@ -205,13 +205,13 @@ typedef union {
/* 1x64 MOVe Quadword
(this is both a load and a store...
in fact, it is the only way to store)
*/
#define movq_m2r(var, reg) mmx_m2r(movq, var, reg)
#define movq_r2m(reg, var) mmx_r2m(movq, reg, var)
#define movq_r2r(regs, regd) mmx_r2r(movq, regs, regd)
#define movq(vars, vard) \
* (this is both a load and a store...
* in fact, it is the only way to store)
*/
#define movq_m2r(var, reg) mmx_m2r(movq, var, reg)
#define movq_r2m(reg, var) mmx_r2m(movq, reg, var)
#define movq_r2r(regs, regd) mmx_r2r(movq, regs, regd)
#define movq(vars, vard) \
__asm__ __volatile__ ("movq %1, %%mm0\n\t" \
"movq %%mm0, %0" \
: "=X" (vard) \
@ -219,14 +219,14 @@ typedef union {
/* 1x32 MOVe Doubleword
(like movq, this is both load and store...
but is most useful for moving things between
mmx registers and ordinary registers)
*/
#define movd_m2r(var, reg) mmx_m2r(movd, var, reg)
#define movd_r2m(reg, var) mmx_r2m(movd, reg, var)
#define movd_r2r(regs, regd) mmx_r2r(movd, regs, regd)
#define movd(vars, vard) \
* (like movq, this is both load and store...
* but is most useful for moving things between
* mmx registers and ordinary registers)
*/
#define movd_m2r(var, reg) mmx_m2r(movd, var, reg)
#define movd_r2m(reg, var) mmx_r2m(movd, reg, var)
#define movd_r2r(regs, regd) mmx_r2r(movd, regs, regd)
#define movd(vars, vard) \
__asm__ __volatile__ ("movd %1, %%mm0\n\t" \
"movd %%mm0, %0" \
: "=X" (vard) \
@ -234,294 +234,294 @@ typedef union {
/* 2x32, 4x16, and 8x8 Parallel ADDs
*/
#define paddd_m2r(var, reg) mmx_m2r(paddd, var, reg)
#define paddd_r2r(regs, regd) mmx_r2r(paddd, regs, regd)
#define paddd(vars, vard) mmx_m2m(paddd, vars, vard)
*/
#define paddd_m2r(var, reg) mmx_m2r(paddd, var, reg)
#define paddd_r2r(regs, regd) mmx_r2r(paddd, regs, regd)
#define paddd(vars, vard) mmx_m2m(paddd, vars, vard)
#define paddw_m2r(var, reg) mmx_m2r(paddw, var, reg)
#define paddw_r2r(regs, regd) mmx_r2r(paddw, regs, regd)
#define paddw(vars, vard) mmx_m2m(paddw, vars, vard)
#define paddw_m2r(var, reg) mmx_m2r(paddw, var, reg)
#define paddw_r2r(regs, regd) mmx_r2r(paddw, regs, regd)
#define paddw(vars, vard) mmx_m2m(paddw, vars, vard)
#define paddb_m2r(var, reg) mmx_m2r(paddb, var, reg)
#define paddb_r2r(regs, regd) mmx_r2r(paddb, regs, regd)
#define paddb(vars, vard) mmx_m2m(paddb, vars, vard)
#define paddb_m2r(var, reg) mmx_m2r(paddb, var, reg)
#define paddb_r2r(regs, regd) mmx_r2r(paddb, regs, regd)
#define paddb(vars, vard) mmx_m2m(paddb, vars, vard)
/* 4x16 and 8x8 Parallel ADDs using Saturation arithmetic
*/
#define paddsw_m2r(var, reg) mmx_m2r(paddsw, var, reg)
#define paddsw_r2r(regs, regd) mmx_r2r(paddsw, regs, regd)
#define paddsw(vars, vard) mmx_m2m(paddsw, vars, vard)
*/
#define paddsw_m2r(var, reg) mmx_m2r(paddsw, var, reg)
#define paddsw_r2r(regs, regd) mmx_r2r(paddsw, regs, regd)
#define paddsw(vars, vard) mmx_m2m(paddsw, vars, vard)
#define paddsb_m2r(var, reg) mmx_m2r(paddsb, var, reg)
#define paddsb_r2r(regs, regd) mmx_r2r(paddsb, regs, regd)
#define paddsb(vars, vard) mmx_m2m(paddsb, vars, vard)
#define paddsb_m2r(var, reg) mmx_m2r(paddsb, var, reg)
#define paddsb_r2r(regs, regd) mmx_r2r(paddsb, regs, regd)
#define paddsb(vars, vard) mmx_m2m(paddsb, vars, vard)
/* 4x16 and 8x8 Parallel ADDs using Unsigned Saturation arithmetic
*/
#define paddusw_m2r(var, reg) mmx_m2r(paddusw, var, reg)
#define paddusw_r2r(regs, regd) mmx_r2r(paddusw, regs, regd)
#define paddusw(vars, vard) mmx_m2m(paddusw, vars, vard)
*/
#define paddusw_m2r(var, reg) mmx_m2r(paddusw, var, reg)
#define paddusw_r2r(regs, regd) mmx_r2r(paddusw, regs, regd)
#define paddusw(vars, vard) mmx_m2m(paddusw, vars, vard)
#define paddusb_m2r(var, reg) mmx_m2r(paddusb, var, reg)
#define paddusb_r2r(regs, regd) mmx_r2r(paddusb, regs, regd)
#define paddusb(vars, vard) mmx_m2m(paddusb, vars, vard)
#define paddusb_m2r(var, reg) mmx_m2r(paddusb, var, reg)
#define paddusb_r2r(regs, regd) mmx_r2r(paddusb, regs, regd)
#define paddusb(vars, vard) mmx_m2m(paddusb, vars, vard)
/* 2x32, 4x16, and 8x8 Parallel SUBs
*/
#define psubd_m2r(var, reg) mmx_m2r(psubd, var, reg)
#define psubd_r2r(regs, regd) mmx_r2r(psubd, regs, regd)
#define psubd(vars, vard) mmx_m2m(psubd, vars, vard)
*/
#define psubd_m2r(var, reg) mmx_m2r(psubd, var, reg)
#define psubd_r2r(regs, regd) mmx_r2r(psubd, regs, regd)
#define psubd(vars, vard) mmx_m2m(psubd, vars, vard)
#define psubw_m2r(var, reg) mmx_m2r(psubw, var, reg)
#define psubw_r2r(regs, regd) mmx_r2r(psubw, regs, regd)
#define psubw(vars, vard) mmx_m2m(psubw, vars, vard)
#define psubw_m2r(var, reg) mmx_m2r(psubw, var, reg)
#define psubw_r2r(regs, regd) mmx_r2r(psubw, regs, regd)
#define psubw(vars, vard) mmx_m2m(psubw, vars, vard)
#define psubb_m2r(var, reg) mmx_m2r(psubb, var, reg)
#define psubb_r2r(regs, regd) mmx_r2r(psubb, regs, regd)
#define psubb(vars, vard) mmx_m2m(psubb, vars, vard)
#define psubb_m2r(var, reg) mmx_m2r(psubb, var, reg)
#define psubb_r2r(regs, regd) mmx_r2r(psubb, regs, regd)
#define psubb(vars, vard) mmx_m2m(psubb, vars, vard)
/* 4x16 and 8x8 Parallel SUBs using Saturation arithmetic
*/
#define psubsw_m2r(var, reg) mmx_m2r(psubsw, var, reg)
#define psubsw_r2r(regs, regd) mmx_r2r(psubsw, regs, regd)
#define psubsw(vars, vard) mmx_m2m(psubsw, vars, vard)
*/
#define psubsw_m2r(var, reg) mmx_m2r(psubsw, var, reg)
#define psubsw_r2r(regs, regd) mmx_r2r(psubsw, regs, regd)
#define psubsw(vars, vard) mmx_m2m(psubsw, vars, vard)
#define psubsb_m2r(var, reg) mmx_m2r(psubsb, var, reg)
#define psubsb_r2r(regs, regd) mmx_r2r(psubsb, regs, regd)
#define psubsb(vars, vard) mmx_m2m(psubsb, vars, vard)
#define psubsb_m2r(var, reg) mmx_m2r(psubsb, var, reg)
#define psubsb_r2r(regs, regd) mmx_r2r(psubsb, regs, regd)
#define psubsb(vars, vard) mmx_m2m(psubsb, vars, vard)
/* 4x16 and 8x8 Parallel SUBs using Unsigned Saturation arithmetic
*/
#define psubusw_m2r(var, reg) mmx_m2r(psubusw, var, reg)
#define psubusw_r2r(regs, regd) mmx_r2r(psubusw, regs, regd)
#define psubusw(vars, vard) mmx_m2m(psubusw, vars, vard)
*/
#define psubusw_m2r(var, reg) mmx_m2r(psubusw, var, reg)
#define psubusw_r2r(regs, regd) mmx_r2r(psubusw, regs, regd)
#define psubusw(vars, vard) mmx_m2m(psubusw, vars, vard)
#define psubusb_m2r(var, reg) mmx_m2r(psubusb, var, reg)
#define psubusb_r2r(regs, regd) mmx_r2r(psubusb, regs, regd)
#define psubusb(vars, vard) mmx_m2m(psubusb, vars, vard)
#define psubusb_m2r(var, reg) mmx_m2r(psubusb, var, reg)
#define psubusb_r2r(regs, regd) mmx_r2r(psubusb, regs, regd)
#define psubusb(vars, vard) mmx_m2m(psubusb, vars, vard)
/* 4x16 Parallel MULs giving Low 4x16 portions of results
*/
#define pmullw_m2r(var, reg) mmx_m2r(pmullw, var, reg)
#define pmullw_r2r(regs, regd) mmx_r2r(pmullw, regs, regd)
#define pmullw(vars, vard) mmx_m2m(pmullw, vars, vard)
*/
#define pmullw_m2r(var, reg) mmx_m2r(pmullw, var, reg)
#define pmullw_r2r(regs, regd) mmx_r2r(pmullw, regs, regd)
#define pmullw(vars, vard) mmx_m2m(pmullw, vars, vard)
/* 4x16 Parallel MULs giving High 4x16 portions of results
*/
#define pmulhw_m2r(var, reg) mmx_m2r(pmulhw, var, reg)
#define pmulhw_r2r(regs, regd) mmx_r2r(pmulhw, regs, regd)
#define pmulhw(vars, vard) mmx_m2m(pmulhw, vars, vard)
*/
#define pmulhw_m2r(var, reg) mmx_m2r(pmulhw, var, reg)
#define pmulhw_r2r(regs, regd) mmx_r2r(pmulhw, regs, regd)
#define pmulhw(vars, vard) mmx_m2m(pmulhw, vars, vard)
/* 4x16->2x32 Parallel Mul-ADD
(muls like pmullw, then adds adjacent 16-bit fields
in the multiply result to make the final 2x32 result)
*/
#define pmaddwd_m2r(var, reg) mmx_m2r(pmaddwd, var, reg)
#define pmaddwd_r2r(regs, regd) mmx_r2r(pmaddwd, regs, regd)
#define pmaddwd(vars, vard) mmx_m2m(pmaddwd, vars, vard)
* (muls like pmullw, then adds adjacent 16-bit fields
* in the multiply result to make the final 2x32 result)
*/
#define pmaddwd_m2r(var, reg) mmx_m2r(pmaddwd, var, reg)
#define pmaddwd_r2r(regs, regd) mmx_r2r(pmaddwd, regs, regd)
#define pmaddwd(vars, vard) mmx_m2m(pmaddwd, vars, vard)
/* 1x64 bitwise AND
*/
#ifdef BROKEN_PAND
#define pand_m2r(var, reg) \
*/
#ifdef BROKEN_PAND
#define pand_m2r(var, reg) \
{ \
mmx_m2r(pandn, (mmx_t) -1LL, reg); \
mmx_m2r(pandn, (mmx_t)-1LL, reg); \
mmx_m2r(pandn, var, reg); \
}
#define pand_r2r(regs, regd) \
#define pand_r2r(regs, regd) \
{ \
mmx_m2r(pandn, (mmx_t) -1LL, regd); \
mmx_m2r(pandn, (mmx_t)-1LL, regd); \
mmx_r2r(pandn, regs, regd) \
}
#define pand(vars, vard) \
#define pand(vars, vard) \
{ \
movq_m2r(vard, mm0); \
mmx_m2r(pandn, (mmx_t) -1LL, mm0); \
mmx_m2r(pandn, (mmx_t)-1LL, mm0); \
mmx_m2r(pandn, vars, mm0); \
movq_r2m(mm0, vard); \
}
#else
#define pand_m2r(var, reg) mmx_m2r(pand, var, reg)
#define pand_r2r(regs, regd) mmx_r2r(pand, regs, regd)
#define pand(vars, vard) mmx_m2m(pand, vars, vard)
#define pand_m2r(var, reg) mmx_m2r(pand, var, reg)
#define pand_r2r(regs, regd) mmx_r2r(pand, regs, regd)
#define pand(vars, vard) mmx_m2m(pand, vars, vard)
#endif
/* 1x64 bitwise AND with Not the destination
*/
#define pandn_m2r(var, reg) mmx_m2r(pandn, var, reg)
#define pandn_r2r(regs, regd) mmx_r2r(pandn, regs, regd)
#define pandn(vars, vard) mmx_m2m(pandn, vars, vard)
*/
#define pandn_m2r(var, reg) mmx_m2r(pandn, var, reg)
#define pandn_r2r(regs, regd) mmx_r2r(pandn, regs, regd)
#define pandn(vars, vard) mmx_m2m(pandn, vars, vard)
/* 1x64 bitwise OR
*/
#define por_m2r(var, reg) mmx_m2r(por, var, reg)
#define por_r2r(regs, regd) mmx_r2r(por, regs, regd)
#define por(vars, vard) mmx_m2m(por, vars, vard)
*/
#define por_m2r(var, reg) mmx_m2r(por, var, reg)
#define por_r2r(regs, regd) mmx_r2r(por, regs, regd)
#define por(vars, vard) mmx_m2m(por, vars, vard)
/* 1x64 bitwise eXclusive OR
*/
#define pxor_m2r(var, reg) mmx_m2r(pxor, var, reg)
#define pxor_r2r(regs, regd) mmx_r2r(pxor, regs, regd)
#define pxor(vars, vard) mmx_m2m(pxor, vars, vard)
*/
#define pxor_m2r(var, reg) mmx_m2r(pxor, var, reg)
#define pxor_r2r(regs, regd) mmx_r2r(pxor, regs, regd)
#define pxor(vars, vard) mmx_m2m(pxor, vars, vard)
/* 2x32, 4x16, and 8x8 Parallel CoMPare for EQuality
(resulting fields are either 0 or -1)
*/
#define pcmpeqd_m2r(var, reg) mmx_m2r(pcmpeqd, var, reg)
#define pcmpeqd_r2r(regs, regd) mmx_r2r(pcmpeqd, regs, regd)
#define pcmpeqd(vars, vard) mmx_m2m(pcmpeqd, vars, vard)
* (resulting fields are either 0 or -1)
*/
#define pcmpeqd_m2r(var, reg) mmx_m2r(pcmpeqd, var, reg)
#define pcmpeqd_r2r(regs, regd) mmx_r2r(pcmpeqd, regs, regd)
#define pcmpeqd(vars, vard) mmx_m2m(pcmpeqd, vars, vard)
#define pcmpeqw_m2r(var, reg) mmx_m2r(pcmpeqw, var, reg)
#define pcmpeqw_r2r(regs, regd) mmx_r2r(pcmpeqw, regs, regd)
#define pcmpeqw(vars, vard) mmx_m2m(pcmpeqw, vars, vard)
#define pcmpeqw_m2r(var, reg) mmx_m2r(pcmpeqw, var, reg)
#define pcmpeqw_r2r(regs, regd) mmx_r2r(pcmpeqw, regs, regd)
#define pcmpeqw(vars, vard) mmx_m2m(pcmpeqw, vars, vard)
#define pcmpeqb_m2r(var, reg) mmx_m2r(pcmpeqb, var, reg)
#define pcmpeqb_r2r(regs, regd) mmx_r2r(pcmpeqb, regs, regd)
#define pcmpeqb(vars, vard) mmx_m2m(pcmpeqb, vars, vard)
#define pcmpeqb_m2r(var, reg) mmx_m2r(pcmpeqb, var, reg)
#define pcmpeqb_r2r(regs, regd) mmx_r2r(pcmpeqb, regs, regd)
#define pcmpeqb(vars, vard) mmx_m2m(pcmpeqb, vars, vard)
/* 2x32, 4x16, and 8x8 Parallel CoMPare for Greater Than
(resulting fields are either 0 or -1)
*/
#define pcmpgtd_m2r(var, reg) mmx_m2r(pcmpgtd, var, reg)
#define pcmpgtd_r2r(regs, regd) mmx_r2r(pcmpgtd, regs, regd)
#define pcmpgtd(vars, vard) mmx_m2m(pcmpgtd, vars, vard)
* (resulting fields are either 0 or -1)
*/
#define pcmpgtd_m2r(var, reg) mmx_m2r(pcmpgtd, var, reg)
#define pcmpgtd_r2r(regs, regd) mmx_r2r(pcmpgtd, regs, regd)
#define pcmpgtd(vars, vard) mmx_m2m(pcmpgtd, vars, vard)
#define pcmpgtw_m2r(var, reg) mmx_m2r(pcmpgtw, var, reg)
#define pcmpgtw_r2r(regs, regd) mmx_r2r(pcmpgtw, regs, regd)
#define pcmpgtw(vars, vard) mmx_m2m(pcmpgtw, vars, vard)
#define pcmpgtw_m2r(var, reg) mmx_m2r(pcmpgtw, var, reg)
#define pcmpgtw_r2r(regs, regd) mmx_r2r(pcmpgtw, regs, regd)
#define pcmpgtw(vars, vard) mmx_m2m(pcmpgtw, vars, vard)
#define pcmpgtb_m2r(var, reg) mmx_m2r(pcmpgtb, var, reg)
#define pcmpgtb_r2r(regs, regd) mmx_r2r(pcmpgtb, regs, regd)
#define pcmpgtb(vars, vard) mmx_m2m(pcmpgtb, vars, vard)
#define pcmpgtb_m2r(var, reg) mmx_m2r(pcmpgtb, var, reg)
#define pcmpgtb_r2r(regs, regd) mmx_r2r(pcmpgtb, regs, regd)
#define pcmpgtb(vars, vard) mmx_m2m(pcmpgtb, vars, vard)
/* 1x64, 2x32, and 4x16 Parallel Shift Left Logical
*/
#define psllq_i2r(imm, reg) mmx_i2r(psllq, imm, reg)
#define psllq_m2r(var, reg) mmx_m2r(psllq, var, reg)
#define psllq_r2r(regs, regd) mmx_r2r(psllq, regs, regd)
#define psllq(vars, vard) mmx_m2m(psllq, vars, vard)
*/
#define psllq_i2r(imm, reg) mmx_i2r(psllq, imm, reg)
#define psllq_m2r(var, reg) mmx_m2r(psllq, var, reg)
#define psllq_r2r(regs, regd) mmx_r2r(psllq, regs, regd)
#define psllq(vars, vard) mmx_m2m(psllq, vars, vard)
#define pslld_i2r(imm, reg) mmx_i2r(pslld, imm, reg)
#define pslld_m2r(var, reg) mmx_m2r(pslld, var, reg)
#define pslld_r2r(regs, regd) mmx_r2r(pslld, regs, regd)
#define pslld(vars, vard) mmx_m2m(pslld, vars, vard)
#define pslld_i2r(imm, reg) mmx_i2r(pslld, imm, reg)
#define pslld_m2r(var, reg) mmx_m2r(pslld, var, reg)
#define pslld_r2r(regs, regd) mmx_r2r(pslld, regs, regd)
#define pslld(vars, vard) mmx_m2m(pslld, vars, vard)
#define psllw_i2r(imm, reg) mmx_i2r(psllw, imm, reg)
#define psllw_m2r(var, reg) mmx_m2r(psllw, var, reg)
#define psllw_r2r(regs, regd) mmx_r2r(psllw, regs, regd)
#define psllw(vars, vard) mmx_m2m(psllw, vars, vard)
#define psllw_i2r(imm, reg) mmx_i2r(psllw, imm, reg)
#define psllw_m2r(var, reg) mmx_m2r(psllw, var, reg)
#define psllw_r2r(regs, regd) mmx_r2r(psllw, regs, regd)
#define psllw(vars, vard) mmx_m2m(psllw, vars, vard)
/* 1x64, 2x32, and 4x16 Parallel Shift Right Logical
*/
#define psrlq_i2r(imm, reg) mmx_i2r(psrlq, imm, reg)
#define psrlq_m2r(var, reg) mmx_m2r(psrlq, var, reg)
#define psrlq_r2r(regs, regd) mmx_r2r(psrlq, regs, regd)
#define psrlq(vars, vard) mmx_m2m(psrlq, vars, vard)
*/
#define psrlq_i2r(imm, reg) mmx_i2r(psrlq, imm, reg)
#define psrlq_m2r(var, reg) mmx_m2r(psrlq, var, reg)
#define psrlq_r2r(regs, regd) mmx_r2r(psrlq, regs, regd)
#define psrlq(vars, vard) mmx_m2m(psrlq, vars, vard)
#define psrld_i2r(imm, reg) mmx_i2r(psrld, imm, reg)
#define psrld_m2r(var, reg) mmx_m2r(psrld, var, reg)
#define psrld_r2r(regs, regd) mmx_r2r(psrld, regs, regd)
#define psrld(vars, vard) mmx_m2m(psrld, vars, vard)
#define psrld_i2r(imm, reg) mmx_i2r(psrld, imm, reg)
#define psrld_m2r(var, reg) mmx_m2r(psrld, var, reg)
#define psrld_r2r(regs, regd) mmx_r2r(psrld, regs, regd)
#define psrld(vars, vard) mmx_m2m(psrld, vars, vard)
#define psrlw_i2r(imm, reg) mmx_i2r(psrlw, imm, reg)
#define psrlw_m2r(var, reg) mmx_m2r(psrlw, var, reg)
#define psrlw_r2r(regs, regd) mmx_r2r(psrlw, regs, regd)
#define psrlw(vars, vard) mmx_m2m(psrlw, vars, vard)
#define psrlw_i2r(imm, reg) mmx_i2r(psrlw, imm, reg)
#define psrlw_m2r(var, reg) mmx_m2r(psrlw, var, reg)
#define psrlw_r2r(regs, regd) mmx_r2r(psrlw, regs, regd)
#define psrlw(vars, vard) mmx_m2m(psrlw, vars, vard)
/* 2x32 and 4x16 Parallel Shift Right Arithmetic
*/
#define psrad_i2r(imm, reg) mmx_i2r(psrad, imm, reg)
#define psrad_m2r(var, reg) mmx_m2r(psrad, var, reg)
#define psrad_r2r(regs, regd) mmx_r2r(psrad, regs, regd)
#define psrad(vars, vard) mmx_m2m(psrad, vars, vard)
*/
#define psrad_i2r(imm, reg) mmx_i2r(psrad, imm, reg)
#define psrad_m2r(var, reg) mmx_m2r(psrad, var, reg)
#define psrad_r2r(regs, regd) mmx_r2r(psrad, regs, regd)
#define psrad(vars, vard) mmx_m2m(psrad, vars, vard)
#define psraw_i2r(imm, reg) mmx_i2r(psraw, imm, reg)
#define psraw_m2r(var, reg) mmx_m2r(psraw, var, reg)
#define psraw_r2r(regs, regd) mmx_r2r(psraw, regs, regd)
#define psraw(vars, vard) mmx_m2m(psraw, vars, vard)
#define psraw_i2r(imm, reg) mmx_i2r(psraw, imm, reg)
#define psraw_m2r(var, reg) mmx_m2r(psraw, var, reg)
#define psraw_r2r(regs, regd) mmx_r2r(psraw, regs, regd)
#define psraw(vars, vard) mmx_m2m(psraw, vars, vard)
/* 2x32->4x16 and 4x16->8x8 PACK and Signed Saturate
(packs source and dest fields into dest in that order)
*/
#define packssdw_m2r(var, reg) mmx_m2r(packssdw, var, reg)
#define packssdw_r2r(regs, regd) mmx_r2r(packssdw, regs, regd)
#define packssdw(vars, vard) mmx_m2m(packssdw, vars, vard)
* (packs source and dest fields into dest in that order)
*/
#define packssdw_m2r(var, reg) mmx_m2r(packssdw, var, reg)
#define packssdw_r2r(regs, regd) mmx_r2r(packssdw, regs, regd)
#define packssdw(vars, vard) mmx_m2m(packssdw, vars, vard)
#define packsswb_m2r(var, reg) mmx_m2r(packsswb, var, reg)
#define packsswb_r2r(regs, regd) mmx_r2r(packsswb, regs, regd)
#define packsswb(vars, vard) mmx_m2m(packsswb, vars, vard)
#define packsswb_m2r(var, reg) mmx_m2r(packsswb, var, reg)
#define packsswb_r2r(regs, regd) mmx_r2r(packsswb, regs, regd)
#define packsswb(vars, vard) mmx_m2m(packsswb, vars, vard)
/* 4x16->8x8 PACK and Unsigned Saturate
(packs source and dest fields into dest in that order)
*/
#define packuswb_m2r(var, reg) mmx_m2r(packuswb, var, reg)
#define packuswb_r2r(regs, regd) mmx_r2r(packuswb, regs, regd)
#define packuswb(vars, vard) mmx_m2m(packuswb, vars, vard)
* (packs source and dest fields into dest in that order)
*/
#define packuswb_m2r(var, reg) mmx_m2r(packuswb, var, reg)
#define packuswb_r2r(regs, regd) mmx_r2r(packuswb, regs, regd)
#define packuswb(vars, vard) mmx_m2m(packuswb, vars, vard)
/* 2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK Low
(interleaves low half of dest with low half of source
as padding in each result field)
*/
#define punpckldq_m2r(var, reg) mmx_m2r(punpckldq, var, reg)
#define punpckldq_r2r(regs, regd) mmx_r2r(punpckldq, regs, regd)
#define punpckldq(vars, vard) mmx_m2m(punpckldq, vars, vard)
* (interleaves low half of dest with low half of source
* as padding in each result field)
*/
#define punpckldq_m2r(var, reg) mmx_m2r(punpckldq, var, reg)
#define punpckldq_r2r(regs, regd) mmx_r2r(punpckldq, regs, regd)
#define punpckldq(vars, vard) mmx_m2m(punpckldq, vars, vard)
#define punpcklwd_m2r(var, reg) mmx_m2r(punpcklwd, var, reg)
#define punpcklwd_r2r(regs, regd) mmx_r2r(punpcklwd, regs, regd)
#define punpcklwd(vars, vard) mmx_m2m(punpcklwd, vars, vard)
#define punpcklwd_m2r(var, reg) mmx_m2r(punpcklwd, var, reg)
#define punpcklwd_r2r(regs, regd) mmx_r2r(punpcklwd, regs, regd)
#define punpcklwd(vars, vard) mmx_m2m(punpcklwd, vars, vard)
#define punpcklbw_m2r(var, reg) mmx_m2r(punpcklbw, var, reg)
#define punpcklbw_r2r(regs, regd) mmx_r2r(punpcklbw, regs, regd)
#define punpcklbw(vars, vard) mmx_m2m(punpcklbw, vars, vard)
#define punpcklbw_m2r(var, reg) mmx_m2r(punpcklbw, var, reg)
#define punpcklbw_r2r(regs, regd) mmx_r2r(punpcklbw, regs, regd)
#define punpcklbw(vars, vard) mmx_m2m(punpcklbw, vars, vard)
/* 2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK High
(interleaves high half of dest with high half of source
as padding in each result field)
*/
#define punpckhdq_m2r(var, reg) mmx_m2r(punpckhdq, var, reg)
#define punpckhdq_r2r(regs, regd) mmx_r2r(punpckhdq, regs, regd)
#define punpckhdq(vars, vard) mmx_m2m(punpckhdq, vars, vard)
* (interleaves high half of dest with high half of source
* as padding in each result field)
*/
#define punpckhdq_m2r(var, reg) mmx_m2r(punpckhdq, var, reg)
#define punpckhdq_r2r(regs, regd) mmx_r2r(punpckhdq, regs, regd)
#define punpckhdq(vars, vard) mmx_m2m(punpckhdq, vars, vard)
#define punpckhwd_m2r(var, reg) mmx_m2r(punpckhwd, var, reg)
#define punpckhwd_r2r(regs, regd) mmx_r2r(punpckhwd, regs, regd)
#define punpckhwd(vars, vard) mmx_m2m(punpckhwd, vars, vard)
#define punpckhwd_m2r(var, reg) mmx_m2r(punpckhwd, var, reg)
#define punpckhwd_r2r(regs, regd) mmx_r2r(punpckhwd, regs, regd)
#define punpckhwd(vars, vard) mmx_m2m(punpckhwd, vars, vard)
#define punpckhbw_m2r(var, reg) mmx_m2r(punpckhbw, var, reg)
#define punpckhbw_r2r(regs, regd) mmx_r2r(punpckhbw, regs, regd)
#define punpckhbw(vars, vard) mmx_m2m(punpckhbw, vars, vard)
#define punpckhbw_m2r(var, reg) mmx_m2r(punpckhbw, var, reg)
#define punpckhbw_r2r(regs, regd) mmx_r2r(punpckhbw, regs, regd)
#define punpckhbw(vars, vard) mmx_m2m(punpckhbw, vars, vard)
/* Empty MMx State
(used to clean-up when going from mmx to float use
of the registers that are shared by both; note that
there is no float-to-mmx operation needed, because
only the float tag word info is corruptible)
*/
#ifdef MMX_TRACE
* (used to clean-up when going from mmx to float use
* of the registers that are shared by both; note that
* there is no float-to-mmx operation needed, because
* only the float tag word info is corruptible)
*/
#ifdef MMX_TRACE
#define emms() \
#define emms() \
{ \
printf("emms()\n"); \
__asm__ __volatile__ ("emms"); \
@ -529,7 +529,7 @@ typedef union {
#else
#define emms() __asm__ __volatile__ ("emms")
#define emms() __asm__ __volatile__ ("emms")
#endif

376
src/renderer.c
View File

@ -12,7 +12,7 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
*/
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
@ -42,13 +42,13 @@
#include "cputest.h"
#endif
#define wrap(a) ( a < 0 ? 0 : ( a > 255 ? 255 : a ))
#define next_effect() (t_last_effect += 1)
#define next_color() (t_last_color += 1)
#define wrap(a) (a < 0 ? 0 : (a > 255 ? 255 : a))
#define next_effect() (t_last_effect++)
#define next_color() (t_last_color++)
typedef struct t_general_parameters {
gint32 t_between_effects;
gint32 t_between_colors;
gint32 t_between_effects;
gint32 t_between_colors;
} t_general_parameters;
typedef gint32 t_color;
@ -75,32 +75,31 @@ static GTimer *title_timer;
static SDL_Thread *thread;
static DBusGConnection * connection = NULL;
static DBusGProxy * dbus_proxy = NULL;
static DBusGConnection *connection = NULL;
static DBusGProxy *dbus_proxy = NULL;
static gint32 event_filter (const SDL_Event *event);
static void check_events ();
static int renderer (void *);
static gint32 event_filter(const SDL_Event *event);
static void check_events();
static int renderer(void *);
#if MMX_DETECTION
static int renderer_mmx (void *);
static int renderer_mmx(void *);
#endif
static void set_title (void);
static void set_title(void);
/*
* Public functions
*/
void renderer_init (void)
void renderer_init(void)
{
GError * error = NULL;
GError *error = NULL;
gint32 try;
if (initializing) {
g_warning (_("We are already initializing"));
g_warning(_("We are already initializing"));
try = 0;
while (initializing) {
g_usleep (1000000);
(void) sleep (1);
g_usleep(1000000);
(void)sleep(1);
if (try++ > 10)
return;
}
@ -109,67 +108,67 @@ void renderer_init (void)
scr_par.width = config_get_xres();
scr_par.height = config_get_yres();
scr_par.scale = config_get_sres();
gen_par.t_between_effects = config_get_teff();
gen_par.t_between_colors = config_get_tcol();
old_color = 0;
color = 0;
finished = FALSE;
must_resize = FALSE;
resizing = FALSE;
resizing_mutex = SDL_CreateMutex ();
resizing_mutex = SDL_CreateMutex();
mode_interactif = FALSE;
visible = TRUE;
quiting = FALSE;
first_xevent = TRUE;
display_init ();
current_title = g_strdup ("Infinity");
display_init();
current_title = g_strdup("Infinity");
set_title();
title_timer = g_timer_new ();
g_timer_start (title_timer);
display_load_random_effect (&current_effect);
connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
dbus_proxy = dbus_g_proxy_new_for_name (connection, AUDACIOUS_DBUS_SERVICE,
AUDACIOUS_DBUS_PATH,
AUDACIOUS_DBUS_INTERFACE);
title_timer = g_timer_new();
g_timer_start(title_timer);
display_load_random_effect(&current_effect);
connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
dbus_proxy = dbus_g_proxy_new_for_name(connection, AUDACIOUS_DBUS_SERVICE,
AUDACIOUS_DBUS_PATH,
AUDACIOUS_DBUS_INTERFACE);
(void)SDL_EventState((Uint8)SDL_ALLEVENTS, SDL_IGNORE);
(void)SDL_EventState((Uint8)SDL_VIDEORESIZE, SDL_ENABLE);
(void)SDL_EventState((Uint8)SDL_ACTIVEEVENT, SDL_ENABLE);
(void)SDL_EventState((Uint8)SDL_KEYDOWN, SDL_ENABLE);
(void)SDL_EventState((Uint8)SDL_QUIT, SDL_ENABLE);
SDL_SetEventFilter(event_filter);
(void) SDL_EventState ((Uint8) SDL_ALLEVENTS, SDL_IGNORE);
(void) SDL_EventState ((Uint8) SDL_VIDEORESIZE, SDL_ENABLE);
(void) SDL_EventState ((Uint8) SDL_ACTIVEEVENT, SDL_ENABLE);
(void) SDL_EventState ((Uint8) SDL_KEYDOWN, SDL_ENABLE);
(void) SDL_EventState ((Uint8) SDL_QUIT, SDL_ENABLE);
SDL_SetEventFilter (event_filter);
#if MMX_DETECTION
if (mm_support_check_and_show () != 0)
thread = SDL_CreateThread (renderer_mmx,NULL);
if (mm_support_check_and_show() != 0)
thread = SDL_CreateThread(renderer_mmx, NULL);
else
#endif
thread = SDL_CreateThread (renderer,NULL);
thread = SDL_CreateThread(renderer, NULL);
}
void renderer_finish (void)
void renderer_finish(void)
{
gint32 try;
if (initializing) {
g_warning (_("The plugin have not yet initialized"));
g_warning(_("The plugin have not yet initialized"));
try = 0;
while (initializing) {
g_usleep (1000000);
g_usleep(1000000);
if (try++ > 10)
return;
}
}
quiting = TRUE;
finished = TRUE;
SDL_WaitThread (thread, NULL);
SDL_DestroyMutex (resizing_mutex);
SDL_WaitThread(thread, NULL);
SDL_DestroyMutex(resizing_mutex);
/*
* Take some time to let it know renderer_render_multi_pcm()
* that must not call display_set_pcm_data().
@ -180,41 +179,40 @@ void renderer_finish (void)
*
* See display.h::display_set_pcm_data()
*/
g_usleep (10000*SDL_TIMESLICE);
display_quit ();
g_timer_destroy (title_timer);
g_object_unref (dbus_proxy);
g_message ("Infinity: Closing...");
g_usleep(10000 * SDL_TIMESLICE);
display_quit();
g_timer_destroy(title_timer);
g_object_unref(dbus_proxy);
g_message("Infinity: Closing...");
}
void renderer_render_multi_pcm (const float * data, int channels)
void renderer_render_multi_pcm(const float *data, int channels)
{
if (!initializing && !quiting)
display_set_pcm_data (data, channels);
display_set_pcm_data(data, channels);
}
/*
* Private functions
*/
static gint32 event_filter (const SDL_Event *event)
static gint32 event_filter(const SDL_Event *event)
{
if (!event) {
g_warning ("Infinity: SDL_Event is NULL");
g_warning("Infinity: SDL_Event is NULL");
return 0;
}
switch (event->type) {
case SDL_VIDEORESIZE:
g_return_val_if_fail (SDL_LockMutex (resizing_mutex) >= 0, 0);
g_return_val_if_fail(SDL_LockMutex(resizing_mutex) >= 0, 0);
if (resizing) {
g_return_val_if_fail (SDL_UnlockMutex (resizing_mutex) >= 0, 0);
g_return_val_if_fail(SDL_UnlockMutex(resizing_mutex) >= 0, 0);
/*
* VIDEORESIZE event dropped from event queue
*/
return 0;
} else {
g_return_val_if_fail (SDL_UnlockMutex (resizing_mutex) >= 0, 0);
g_return_val_if_fail(SDL_UnlockMutex(resizing_mutex) >= 0, 0);
return 1;
}
g_assert_not_reached();
@ -240,92 +238,91 @@ static gint32 event_filter (const SDL_Event *event)
return 1;
}
static gint disable_func (gpointer data)
static gint disable_func(gpointer data)
{
renderer_finish();
return FALSE;
}
static void check_events ()
static void check_events()
{
SDL_Event event;
gint volume;
/*XEvent *xevent;
XWindowChanges changes;
XWindowAttributes attr;
XSetWindowAttributes s_attr;*/
* XWindowChanges changes;
* XWindowAttributes attr;
* XSetWindowAttributes s_attr;*/
if (config_get_show_title()) {
if (g_timer_elapsed (title_timer, NULL) > 1.0) {
if (aud_drct_get_playing () && aud_drct_get_ready ()) {
if (g_timer_elapsed(title_timer, NULL) > 1.0) {
if (aud_drct_get_playing() && aud_drct_get_ready()) {
if (current_title)
g_free (current_title);
current_title = g_strdup (aud_playlist_entry_get_title(aud_playlist_get_playing (), aud_playlist_get_position(aud_playlist_get_playing ()), FALSE));
g_free(current_title);
current_title = g_strdup(aud_playlist_entry_get_title(aud_playlist_get_playing(), aud_playlist_get_position(aud_playlist_get_playing()), FALSE));
set_title();
} else {
if (current_title)
g_free(current_title);
current_title = g_strdup("Infinity");
set_title();
}
else {
if (current_title)
g_free (current_title);
current_title = g_strdup ("Infinity");
set_title();
}
g_timer_reset (title_timer);
g_timer_reset(title_timer);
}
}
while (SDL_PollEvent (&event)) {
while (SDL_PollEvent(&event)) {
switch (event.type) {
/*case SDL_SYSWMEVENT:
g_message ("Infinity: SDL_SYSWMEVENT");
if (event.syswm.msg != NULL) {
if (event.syswm.msg->subsystem == SDL_SYSWM_X11) {
xevent = &(event.syswm.msg->event.xevent);
if (xevent == NULL)
continue;
if (first_xevent) {
changes.x = config_get_x();
changes.y = config_get_y();
XConfigureWindow (xevent->xany.display,
xevent->xany.window,
CWX | CWY, &changes);
first_xevent = FALSE;
g_message ("Infinity: window moved to (%d,%d)",
changes.x, changes.y);
} else {
XGetWindowAttributes (xevent->xany.display,
xevent->xany.window,
&attr);
g_message ("Infinity: GetWindowAttributes (%d,%d)",
attr.x, attr.y);
}
}
}
break;*/
/*case SDL_SYSWMEVENT:
* g_message ("Infinity: SDL_SYSWMEVENT");
* if (event.syswm.msg != NULL) {
* if (event.syswm.msg->subsystem == SDL_SYSWM_X11) {
* xevent = &(event.syswm.msg->event.xevent);
* if (xevent == NULL)
* continue;
* if (first_xevent) {
* changes.x = config_get_x();
* changes.y = config_get_y();
* XConfigureWindow (xevent->xany.display,
* xevent->xany.window,
* CWX | CWY, &changes);
* first_xevent = FALSE;
* g_message ("Infinity: window moved to (%d,%d)",
* changes.x, changes.y);
* } else {
* XGetWindowAttributes (xevent->xany.display,
* xevent->xany.window,
* &attr);
* g_message ("Infinity: GetWindowAttributes (%d,%d)",
* attr.x, attr.y);
* }
* }
* }
* break;*/
case SDL_QUIT:
GDK_THREADS_ENTER ();
(void) gtk_idle_add (disable_func, NULL);
GDK_THREADS_LEAVE ();
break;
GDK_THREADS_ENTER();
(void)gtk_idle_add(disable_func, NULL);
GDK_THREADS_LEAVE();
break;
case SDL_VIDEORESIZE:
g_return_if_fail (SDL_LockMutex (resizing_mutex) >= 0);
g_return_if_fail(SDL_LockMutex(resizing_mutex) >= 0);
resizing = TRUE;
g_return_if_fail (SDL_UnlockMutex (resizing_mutex) >= 0);
g_return_if_fail(SDL_UnlockMutex(resizing_mutex) >= 0);
scr_par.width = event.resize.w;
scr_par.height = event.resize.h;
g_message ("Infinity: Screen resized to %dx%d pixels^2",
scr_par.width, scr_par.height);
g_message("Infinity: Screen resized to %dx%d pixels^2",
scr_par.width, scr_par.height);
must_resize = TRUE;
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
case SDLK_RIGHT:
if (aud_drct_get_playing () && aud_drct_get_ready ())
aud_drct_seek (aud_drct_get_time () + 5000);
if (aud_drct_get_playing() && aud_drct_get_ready())
aud_drct_seek(aud_drct_get_time() + 5000);
break;
case SDLK_LEFT:
if (aud_drct_get_playing () && aud_drct_get_ready ())
aud_drct_seek (aud_drct_get_time () - 5000);
if (aud_drct_get_playing() && aud_drct_get_ready())
aud_drct_seek(aud_drct_get_time() - 5000);
break;
case SDLK_UP:
aud_drct_get_volume_main(&volume);
@ -338,7 +335,7 @@ static void check_events ()
aud_drct_set_volume_main(volume - 5);
break;
case SDLK_TAB:
display_toggle_fullscreen ();
display_toggle_fullscreen();
break;
case SDLK_z:
aud_drct_pl_prev();
@ -356,17 +353,17 @@ static void check_events ()
aud_drct_pl_next();
break;
case SDLK_F11:
display_save_screen ();
display_save_screen();
break;
case SDLK_F12:
if (t_last_color>32) {
if (t_last_color > 32) {
t_last_color = 0;
old_color = color;
color = (color + 1) % NB_PALETTES;
color = ++color % NB_PALETTES;
}
break;
case SDLK_SPACE:
display_load_random_effect (&current_effect);
display_load_random_effect(&current_effect);
t_last_effect = 0;
break;
#ifdef INFINITY_DEBUG
@ -386,21 +383,21 @@ static void check_events ()
if (mode_interactif) {
gint32 i;
gint32 sx, sy;
byte* keystate;
byte *keystate;
keystate = SDL_GetKeyState(NULL);
SDL_GetMouseState (&sx, &sy);
SDL_GetMouseState(&sx, &sy);
current_effect.spectral_shift = sx;
if ( keystate[SDLK_a])
current_effect.curve_color = wrap (current_effect.curve_color - 32);
if ( keystate[SDLK_z])
current_effect.curve_color = wrap (current_effect.curve_color + 32);
if ( keystate[SDLK_q])
current_effect.spectral_color = wrap (current_effect.spectral_color - 32);
if ( keystate[SDLK_s])
current_effect.spectral_color = wrap (current_effect.spectral_color + 32);
if (keystate[SDLK_a])
current_effect.curve_color = wrap(current_effect.curve_color - 32);
if (keystate[SDLK_z])
current_effect.curve_color = wrap(current_effect.curve_color + 32);
if (keystate[SDLK_q])
current_effect.spectral_color = wrap(current_effect.spectral_color - 32);
if (keystate[SDLK_s])
current_effect.spectral_color = wrap(current_effect.spectral_color + 32);
for (i = 0; i < 10; i++)
if ( keystate[SDLK_F1 + i])
if (keystate[SDLK_F1 + i])
current_effect.num_effect = i % NB_FCT;
if (keystate[SDLK_d])
current_effect.spectral_amplitude = (current_effect.spectral_amplitude - 1);
@ -410,15 +407,15 @@ static void check_events ()
current_effect.curve_amplitude = (current_effect.curve_amplitude - 1);
if (keystate[SDLK_r])
current_effect.curve_amplitude = (current_effect.curve_amplitude + 1);
if ( keystate[SDLK_m])
display_save_effect (&current_effect);
if ( keystate[SDLK_w])
if (keystate[SDLK_m])
display_save_effect(&current_effect);
if (keystate[SDLK_w])
current_effect.mode_spectre = (current_effect.mode_spectre + 1) % 5;
}
#endif /* INFINITY_DEBUG */
#endif /* INFINITY_DEBUG */
}
static int renderer (void *arg)
static int renderer(void *arg)
{
gint32 render_time, now;
gint32 frame_length;
@ -428,45 +425,44 @@ static int renderer (void *arg)
/* We suppose here that config module have been initialized */
fps = config_get_fps();
frame_length = (gint32)((1.0 / config_get_fps()) * 1000);
g_message ("Infinity[%d]: setting maximum rate at ~%d frames/second", __LINE__, fps);
g_message("Infinity[%d]: setting maximum rate at ~%d frames/second", __LINE__, fps);
initializing = FALSE;
for (;;) { /* ever... */
for (;; ) { /* ever... */
if (!visible) {
check_events ();
check_events();
if (finished)
break;
g_usleep (3000*frame_length);
g_usleep(3000 * frame_length);
continue;
}
check_events();
if (finished)
break;
if (must_resize) {
display_resize (scr_par.width, scr_par.height);
config_set_xres (scr_par.width);
config_set_yres (scr_par.height);
display_resize(scr_par.width, scr_par.height);
config_set_xres(scr_par.width);
config_set_yres(scr_par.height);
must_resize = FALSE;
g_return_val_if_fail (SDL_LockMutex (resizing_mutex) >= 0, -1);
g_return_val_if_fail(SDL_LockMutex(resizing_mutex) >= 0, -1);
resizing = FALSE;
g_return_val_if_fail (SDL_UnlockMutex (resizing_mutex) >= 0, -1);
g_return_val_if_fail(SDL_UnlockMutex(resizing_mutex) >= 0, -1);
}
render_time = (gint32) SDL_GetTicks ();
display_blur (scr_par.width*scr_par.height*current_effect.num_effect);
spectral (&current_effect);
curve (&current_effect);
if (t_last_color <= 32) {
change_color (old_color, color, t_last_color*8);
}
next_color ();
next_effect ();
render_time = (gint32)SDL_GetTicks();
display_blur(scr_par.width * scr_par.height * current_effect.num_effect);
spectral(&current_effect);
curve(&current_effect);
if (t_last_color <= 32)
change_color(old_color, color, t_last_color * 8);
next_color();
next_effect();
if (t_last_effect % gen_par.t_between_effects == 0) {
#ifdef INFINITY_DEBUG
if (!mode_interactif) {
display_load_random_effect (&current_effect);
display_load_random_effect(&current_effect);
t_last_effect = 0;
}
#else
display_load_random_effect (&current_effect);
display_load_random_effect(&current_effect);
t_last_effect = 0;
#endif
}
@ -488,19 +484,19 @@ static int renderer (void *arg)
if (new_fps != fps) {
fps = new_fps;
frame_length = (gint32)(((1.0 / fps) * 1000));
g_message ("Infinity[%d]: setting maximum rate at ~%d frames/second", __LINE__, fps);
g_message("Infinity[%d]: setting maximum rate at ~%d frames/second", __LINE__, fps);
}
now = (gint32) SDL_GetTicks ();
now = (gint32)SDL_GetTicks();
if ((idle_time = (now - render_time)) < frame_length)
g_usleep (idle_time*900);
g_usleep(idle_time * 900);
}
return 0;
}
#if MMX_DETECTION
static int renderer_mmx (void *arg)
static int renderer_mmx(void *arg)
{
gint32 render_time, now;
gint32 frame_length;
@ -510,45 +506,44 @@ static int renderer_mmx (void *arg)
/* We suppose here that config module have been initialized */
fps = config_get_fps();
frame_length = ((1.0 / fps) * 1000);
g_message ("Infinity[%d]: setting maximum rate at ~%d frames/second", __LINE__, fps);
g_message("Infinity[%d]: setting maximum rate at ~%d frames/second", __LINE__, fps);
initializing = FALSE;
for (;;) { /* ever... */
for (;; ) { /* ever... */
if (!visible) {
check_events ();
check_events();
if (finished)
break;
g_usleep (3000*frame_length);
g_usleep(3000 * frame_length);
continue;
}
check_events ();
check_events();
if (finished)
break;
if (must_resize) {
display_resize (scr_par.width, scr_par.height);
config_set_xres (scr_par.width);
config_set_yres (scr_par.height);
display_resize(scr_par.width, scr_par.height);
config_set_xres(scr_par.width);
config_set_yres(scr_par.height);
must_resize = FALSE;
g_return_val_if_fail (SDL_LockMutex (resizing_mutex) >= 0, -1);
g_return_val_if_fail(SDL_LockMutex(resizing_mutex) >= 0, -1);
resizing = FALSE;
g_return_val_if_fail (SDL_UnlockMutex (resizing_mutex) >= 0, -1);
g_return_val_if_fail(SDL_UnlockMutex(resizing_mutex) >= 0, -1);
}
render_time = SDL_GetTicks ();
display_blur_mmx (scr_par.width * scr_par.height * current_effect.num_effect);
spectral (&current_effect);
curve (&current_effect);
if (t_last_color <= 32) {
change_color (old_color, color, t_last_color*8);
}
next_color ();
next_effect ();
render_time = SDL_GetTicks();
display_blur_mmx(scr_par.width * scr_par.height * current_effect.num_effect);
spectral(&current_effect);
curve(&current_effect);
if (t_last_color <= 32)
change_color(old_color, color, t_last_color * 8);
next_color();
next_effect();
if (t_last_effect % gen_par.t_between_effects == 0) {
#ifdef INFINITY_DEBUG
if (!mode_interactif) {
display_load_random_effect (&current_effect);
display_load_random_effect(&current_effect);
t_last_effect = 0;
}
#else
display_load_random_effect (&current_effect);
display_load_random_effect(&current_effect);
t_last_effect = 0;
#endif
}
@ -570,20 +565,19 @@ static int renderer_mmx (void *arg)
if (new_fps != fps) {
fps = new_fps;
frame_length = ((1.0 / fps) * 1000);
g_message ("Infinity[%d]: setting maximum rate at ~%d frames/second", __LINE__, fps);
g_message("Infinity[%d]: setting maximum rate at ~%d frames/second", __LINE__, fps);
}
now = SDL_GetTicks ();
now = SDL_GetTicks();
if ((idle_time = (now - render_time)) < frame_length)
g_usleep (idle_time*900);
g_usleep(idle_time * 900);
}
return 0;
}
#endif /* MMX_DETECTION */
static void set_title (void)
static void set_title(void)
{
SDL_WM_SetCaption (current_title, "Infinity");
SDL_WM_SetCaption(current_title, "Infinity");
}

10
src/renderer.h
View File

@ -19,8 +19,8 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __INFINITY_RENDERER__
*/
#ifndef __INFINITY_RENDERER__
#define __INFINITY_RENDERER__
#include <glib.h>
@ -31,18 +31,18 @@
* Reads configuration parameters and launchs a thread where most of the
* plugin job gets done.
*/
void renderer_init (void);
void renderer_init(void);
/**
* Closes rendering process.
*/
void renderer_finish (void);
void renderer_finish(void);
/**
* Copies PCM data from Audacity.
*
* Called periodically by Audacity with actual PCM data.
*/
void renderer_render_multi_pcm (const float * data, int channels);
void renderer_render_multi_pcm(const float *data, int channels);
#endif /* __INFINITY_RENDERER__ */

396
src/spectrum.c
View File

@ -1,396 +0,0 @@
#include <math.h>
#include <xmms/plugin.h>
/*#include "libxmms/util.h"*/
#include <SDL/SDL.h>
#define wrap(a) ( a < 0 ? 0 : ( a > 255 ? 255 : a ))
#define PI 3.14159
#define WIDTH 400
#define HEIGHT 300
#define INTERPOLATION 0 //0 or 1 to double resolution.
#define NB_FCT 6
#define NB_PALETTES 5
#include "affiche.h"
#define PERIODE_COLORS 64
#define PERIODE_EFFECTS 128
#define VIDEO_FLAGS (SDL_HWSURFACE|SDL_HWPALETTE)
#define BASS_EXT_MEMORY 100
typedef guchar byte;
static void sanalyzer_init(void);
static void sanalyzer_cleanup(void);
static void sanalyzer_playback_start(void);
static void sanalyzer_playback_stop(void);
static void sanalyzer_render_pcm(gint16 data[2][512]);
static void sanalyzer_render_freq(gint16 data[2][256]);
/*
typedef struct coord {
int x,y;
} coord;
typedef struct complex {
float x,y;
} complex;
typedef struct interpol {
coord c; //coordinates of the top left pixel.
int w1,w2,w3,w4;
} interpol;
typedef struct effect {
int addr_effect;
int f1,f2,f3;
int x_curve;
int p_speed,p_rotation;
int color,old_color;
int curve_color;
int spectral_color;
int mode_spectre;
int spectral_shift;
int flash;
} effect;
*/
struct bass_info {
//int mem[SIZE_BASS_MEM];
gint32 max_recent;
gint32 max_old;
gint32 time_last_max;
gint32 min_recent;
gint32 min_old;
gint32 time_last_min;
gint32 activated;
} bass_info;
interpol vector_field[NB_FCT][WIDTH*HEIGHT];
effect current_effect;
gint32 t=0;
VisPlugin sanalyzer_vp =
{
NULL,
NULL,
0,
"Simple spectrum analyzer",
1,
1,
sanalyzer_init,
sanalyzer_cleanup,
NULL,
NULL,
NULL,
sanalyzer_playback_start,
sanalyzer_playback_stop,
sanalyzer_render_pcm,
sanalyzer_render_freq
};
VisPlugin *get_vplugin_info(void)
{
return &sanalyzer_vp;
}
complex fct(complex a,gint32 n,gint32 p1,gint32 p2) //p1 et p2:0-4
{
complex b,b1,b2;
gfloat fact;
gfloat an;
gfloat circle_size;
gfloat speed;
gfloat co,si;
a.x-=WIDTH/2;
a.y-=HEIGHT/2;
switch (n) {
case 0:
an=0.025*(p1-2)+0.002;
co=cos(an);
si=sin(an);
circle_size=HEIGHT*0.25;
speed=2000+p2*500;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
fact=-(sqrt(b.x*b.x+b.y*b.y)-circle_size)/speed+1;
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
case 1:
an=0.015*(p1-2)+0.002;
co=cos(an);
si=sin(an);
circle_size=HEIGHT*0.45;
speed=4000+p2*1000;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
fact=(sqrt(b.x*b.x+b.y*b.y)-circle_size)/speed+1;
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
case 2:
an=0.002;
co=cos(an);
si=sin(an);
circle_size=HEIGHT*0.25;
speed=400+p2*100;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
fact=-(sqrt(b.x*b.x+b.y*b.y)-circle_size)/speed+1;
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
case 3:
an=(sin(sqrt(a.x*a.x+a.y*a.y)/20)/20)+0.002;
co=cos(an);
si=sin(an);
circle_size=HEIGHT*0.25;
speed=4000;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
fact=-(sqrt(b.x*b.x+b.y*b.y)-circle_size)/speed+1;
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
case 4:
an=0.002;
co=cos(an);
si=sin(an);
circle_size=HEIGHT*0.25;
speed=sin(sqrt(a.x*a.x+a.y*a.y)/5)*3000+4000;
b.x=(co*a.x-si*a.y);
b.y=(si*a.x+co*a.y);
fact=-(sqrt(b.x*b.x+b.y*b.y)-circle_size)/speed+1;
b.x=(b.x*fact);
b.y=(b.y*fact);
break;
case 5:
b.x=a.x*1.0;
b.y=a.y*1.0;
}
b.x+=WIDTH/2;
b.y+=HEIGHT/2;
if (b.x<0)
b.x=0;
if (b.y<0)
b.y=0;
if (b.x>WIDTH-1)
b.x=WIDTH-1;
if (b.y>HEIGHT-1)
b.y=HEIGHT-1;
return b;
}
void generate_sector(gint32 g,gint32 f,gint32 p1,gint32 p2,gint32 debut,gint32 step)
{
coord c;
complex a;
gfloat fpy;
gint32 rw,lw,add;
gint32 fin=debut+step;
gint32 prop_transmitted=249;
gint32 i,j;
if (fin>HEIGHT)
fin=HEIGHT;
for (c.y=debut;c.y<fin;c.y++)
for (c.x=0;c.x<WIDTH;c.x++) {
a.x=(gfloat)c.x;
a.y=(gfloat)c.y;
a=fct(a,f,p1,p2);
add=c.x+c.y*WIDTH;
vector_field[g][add].c.x=(gint32)(a.x);
vector_field[g][add].c.y=(gint32)(a.y);
fpy=a.y-floor(a.y);
rw=(gint32)((a.x-floor(a.x))*prop_transmitted);
lw=prop_transmitted-rw;
vector_field[g][add].w4=(gint32)(fpy*rw);
vector_field[g][add].w2=rw-vector_field[g][add].w4;
vector_field[g][add].w3=(gint32)(fpy*lw);
vector_field[g][add].w1=lw-vector_field[g][add].w3;
}
}
void generate_vector_field()
{
gint32 f;
gint32 i,p1,p2;
for (f=0;f<NB_FCT;f++) {
p1=2;
p2=2;
for (i=0;i<HEIGHT;i+=10)
generate_sector(f,f,p1,p2,i,10);
}
}
static void sanalyzer_init(void)
{
generate_vector_field();
generate_colors();
}
static void sanalyzer_cleanup(void)
{
SDL_Quit();
}
static void sanalyzer_playback_start(void)
{
init_sdl();
generate_vector_field();
}
static void sanalyzer_playback_stop(void)
{
SDL_Quit();
}
void sanalyzer_render_freq(gint16 data[2][256])
{
gint32 bass=0;
gint32 i;
gint32 step=10;
for (i=0;i<step;i++)
bass+=(data[0][i]>>4)+(data[1][i]>>4);
bass=bass/step/2;
if (bass>bass_info.max_recent)
bass_info.max_recent=bass;
if (bass<bass_info.min_recent)
bass_info.min_recent=bass;
if (t-bass_info.time_last_max>BASS_EXT_MEMORY) {
bass_info.max_old=bass_info.max_recent;
bass_info.max_recent=0;
bass_info.time_last_max=t;
}
if (t-bass_info.time_last_min>BASS_EXT_MEMORY) {
bass_info.min_old=bass_info.min_recent;
bass_info.min_recent=0;
bass_info.time_last_min=t;
}
if (bass>(bass_info.max_old*6+bass_info.min_old*4)/10 && bass_info.activated==0) {
if (current_effect.flash)
flash(255,t);
bass_info.activated=1;
}
if (bass<(bass_info.max_old*4+bass_info.min_old*6)/10 && bass_info.activated==1)
bass_info.activated=0;
}
void sanalyzer_render_pcm(gint16 data[2][512])
{
SDL_Event event;
Uint8 *keystate;
gint32 son=0;
gint32 trace=0;
gfloat x,y,v,vr;
gint32 i;
gint32 t_last_palette=0;
while ( SDL_PollEvent(&event) ) {
if ( event.type == SDL_QUIT )
SDL_Quit();
if (event.type == SDL_KEYDOWN) {
gchar *st;
st=SDL_GetKeyName(event.key.keysym.sym);
if (!strcmp(st,"a"))
current_effect.curve_color=wrap(current_effect.curve_color-32);
if (!strcmp(st,"z"))
current_effect.curve_color=wrap(current_effect.curve_color+32);
if (!strcmp(st,"q"))
current_effect.spectral_color=wrap(current_effect.spectral_color-32);
if (!strcmp(st,"s"))
current_effect.spectral_color=wrap(current_effect.spectral_color+32);
if (!strcmp(st,"w"))
current_effect.mode_spectre=(current_effect.mode_spectre+1)%5;
if (!strcmp(st,"x"))
current_effect.flash=(current_effect.flash+1)%2;
}
}
keystate = SDL_GetKeyState(NULL);
if ( keystate[SDLK_ESCAPE] )
ToggleFullScreen();
for (i=0;i<10;i++)
if ( keystate[SDLK_F1+i])
current_effect.addr_effect=i%NB_FCT;
if (keystate[SDLK_F11]) {
current_effect.color=(current_effect.color-1)%NB_PALETTES;
t_last_palette=0;
}
if (keystate[SDLK_F12]) {
current_effect.color=(current_effect.color+1)%NB_PALETTES;
t_last_palette=0;
}
if (keystate[SDLK_e]) {
current_effect.spectral_shift=(current_effect.spectral_shift-10)%HEIGHT;
}
if (keystate[SDLK_r]) {
current_effect.spectral_shift=(current_effect.spectral_shift+10)%HEIGHT;
}
if (t_last_palette<8)
change_color(current_effect.color,(current_effect.color+1)%NB_PALETTES,(t_last_palette+1)*32);
/*
if (t%PERIODE_EFFECTS==0) {
// while (current_effect.f1==current_effect.f2) {
// current_effect.f2=current_effect.f1;
//current_effect.f1=rand()%NB_TYPE_FCT;
//}
//current_effect.p_rotation=2;
//current_effect.p_speed=rand()%5;
current_effect.addr_effect=(current_effect.addr_effect+1)%NB_FCT;
}*/
/*
generate_sector(1-current_effect.addr_effect,current_effect.f1,
current_effect.p_rotation,current_effect.p_speed,
(t%PERIODE_EFFECTS)*(HEIGHT/PERIODE_EFFECTS+1),
(HEIGHT/PERIODE_EFFECTS+1));
*/
affiche(current_effect.addr_effect,vector_field);
spectral(data,current_effect);
curve(&current_effect);
t+=1;
t_last_palette+=1;
}

4
src/types.h
View File

@ -18,8 +18,8 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __INFINITY_TYPES__
*/
#ifndef __INFINITY_TYPES__
#define __INFINITY_TYPES__
#include <SDL/SDL.h>