main.c

video linux conference

        for(y=0;y<gy;y++)
        {
            x_mesh[x][y]=origx[x][y];
            y_mesh[x][y]=origy[x][y];
            rad_mesh[x][y]=origrad[x][y];
            theta_mesh[x][y]=origtheta[x][y];
        }
    }
}



void draw_custom_waves()
{
    int x;

    custom_wave_t *wavecode;
    glPointSize(texsize/512);
    //printf("%d\n",wavecode);
    //  more=isMoreCustomWave();
    // printf("not inner loop\n");
    while ((wavecode = nextCustomWave()) != NULL)
    {
        //printf("begin inner loop\n");
        if(wavecode->enabled==1)
        {
            // nextCustomWave();

            //glPushMatrix();

            //if(wavecode->bUseDots==1) glEnable(GL_LINE_STIPPLE);
            if (wavecode->bAdditive==0)  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            else    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
            if (wavecode->bDrawThick==1)  glLineWidth(2*texsize/512);

            //  xx= ((pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale)*2;
            //yy=pcmdataL[x]*80*fWaveScale,-1;
            //glVertex3f( (wave_x*texsize)+(xx+yy)*cos(45), (wave_y*texsize)+(-yy+xx)*cos(45),-1);
            // printf("samples: %d\n", wavecode->samples);

            getPCM(wavecode->value1,wavecode->samples,0,wavecode->bSpectrum,wavecode->smoothing,0);
            getPCM(wavecode->value2,wavecode->samples,1,wavecode->bSpectrum,wavecode->smoothing,0);
            // printf("%f\n",pcmL[0]);
            for(x=0;x<wavecode->samples;x++)
            {wavecode->value1[x]=wavecode->value1[x]*wavecode->scaling;}

            for(x=0;x<wavecode->samples;x++)
            {wavecode->value2[x]=wavecode->value2[x]*wavecode->scaling;}

            for(x=0;x<wavecode->samples;x++)
            {wavecode->sample_mesh[x]=((double)x)/((double)(wavecode->samples-1));}

            // printf("mid inner loop\n");
            evalPerPointEqns();
            /*
               if(!isPerPointEquation("x"))
               {for(x=0;x<wavecode->samples;x++)
               {cw_x[x]=0;} }

               if(!isPerPointEquation(Y_POINT_OP))
               {for(x=0;x<wavecode->samples;x++)
               {cw_y[x]=0;}}

               if(!isPerPointEquation(R_POINT_OP))
               {for(x=0;x<wavecode->samples;x++)
               {cw_r[x]=wavecode->r;}}
               if(!isPerPointEquation(G_POINT_OP))
               {for(x=0;x<wavecode->samples;x++)
               {cw_g[x]=wavecode->g;}}
               if(!isPerPointEquation(B_POINT_OP))
               {for(x=0;x<wavecode->samples;x++)
               {cw_b[x]=wavecode->b;}}
               if(!isPerPointEquation(A_POINT_OP))
               {for(x=0;x<wavecode->samples;x++)
               {cw_a[x]=wavecode->a;}}
             */
            //put drawing code here
            if (wavecode->bUseDots==1)   glBegin(GL_POINTS);
            else   glBegin(GL_LINE_STRIP);

            for(x=0;x<wavecode->samples;x++)
            {
                //          printf("x:%f y:%f a:%f g:%f %f\n", wavecode->x_mesh[x], wavecode->y_mesh[x], wavecode->a_mesh[x], wavecode->g_mesh[x], wavecode->sample_mesh[x]);
                glColor4f(wavecode->r_mesh[x],wavecode->g_mesh[x],wavecode->b_mesh[x],wavecode->a_mesh[x]);
                glVertex3f(wavecode->x_mesh[x]*texsize,-(wavecode->y_mesh[x]-1)*texsize,-1);
            }
            glEnd();
            glPointSize(texsize/512);
            glLineWidth(texsize/512);
            glDisable(GL_LINE_STIPPLE);
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            //  glPopMatrix();

        }

    }
}



void draw_shapes()
{
    int i;

    double theta;
    double rad2;

    double pi = 3.14159265;
    double start,inc,xval,yval;
    custom_shape_t *shapecode;

    while ((shapecode = nextCustomShape()) != NULL)
    {
        if(shapecode->enabled==1)
        {
            // printf("drawing shape %f\n",shapecode->ang);
            shapecode->y=-((shapecode->y)-1);
            rad2=.5;
            shapecode->rad=shapecode->rad*(texsize*.707*.707*.707*1.04);
            //Additive Drawing or Overwrite
            if (shapecode->additive==0)  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            else    glBlendFunc(GL_SRC_ALPHA, GL_ONE);

            glMatrixMode(GL_MODELVIEW);
            glPushMatrix();
            if(correction)
            {
                glTranslatef(texsize*.5,texsize*.5, 0);
                glScalef(1.0,vw/(double)vh,1.0);
                glTranslatef((-texsize*.5) ,(-texsize*.5),0);
            }

            start=.78539+shapecode->ang;
            inc=(pi*2)/(double)shapecode->sides;
            xval=shapecode->x*texsize;
            yval=shapecode->y*texsize;

            if (shapecode->textured)
            {
                glMatrixMode(GL_TEXTURE);
                glPushMatrix();
                glLoadIdentity();

                glTranslatef(.5,.5, 0);
                if (correction) glScalef(1,vw/(double)vh,1);

                glRotatef((shapecode->tex_ang*360/6.280), 0, 0, 1);

                glScalef(1/(shapecode->tex_zoom),1/(shapecode->tex_zoom),1);

                // glScalef(1,vh/(double)vw,1);
                glTranslatef((-.5) ,(-.5),0);
                // glScalef(1,vw/(double)vh,1);
                glEnable(GL_TEXTURE_2D);


                glBegin(GL_TRIANGLE_FAN);

                glColor4f(shapecode->r,shapecode->g,shapecode->b,shapecode->a);
                theta=start;
                glTexCoord2f(.5,.5);
                glVertex3f(xval,yval,-1);
                glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);

                for ( i=0;i<shapecode->sides+1;i++)
                {

                    theta+=inc;
                    //  glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);
                    glTexCoord2f(rad2*cos(theta)+.5 ,rad2*sin(theta)+.5 );
                    glVertex3f(shapecode->rad*cos(theta)+xval,shapecode->rad*sin(theta)+yval,-1);
                }
                glEnd();




                glDisable(GL_TEXTURE_2D);
                glPopMatrix();
                glMatrixMode(GL_MODELVIEW);
            }
            else
            {//Untextured (use color values)
                //printf("untextured %f %f %f @:%f,%f %f %f\n",shapecode->a2,shapecode->a,shapecode->border_a, shapecode->x,shapecode->y,shapecode->rad,shapecode->ang);
                //draw first n-1 triangular pieces
                glBegin(GL_TRIANGLE_FAN);

                glColor4f(shapecode->r,shapecode->g,shapecode->b,shapecode->a);
                theta=start;
                // glTexCoord2f(.5,.5);
                glVertex3f(xval,yval,-1);
                glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);

                for ( i=0;i<shapecode->sides+1;i++)
                {

                    theta+=inc;
                    //  glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);
                    //  glTexCoord2f(rad2*cos(theta)+.5 ,rad2*sin(theta)+.5 );
                    glVertex3f(shapecode->rad*cos(theta)+xval,shapecode->rad*sin(theta)+yval,-1);
                }
                glEnd();


            }
            if (bWaveThick==1)  glLineWidth(2*texsize/512);
            glBegin(GL_LINE_LOOP);
            glColor4f(shapecode->border_r,shapecode->border_g,shapecode->border_b,shapecode->border_a);
            for ( i=0;i<shapecode->sides;i++)
            {
                theta+=inc;
                glVertex3f(shapecode->rad*cos(theta)+xval,shapecode->rad*sin(theta)+yval,-1);
            }
            glEnd();
            if (bWaveThick==1)  glLineWidth(texsize/512);

            glPopMatrix();
        }
    }

}


void draw_waveform()
{

    int x;

    double r,theta;

    double offset,scale,dy2_adj;

    double co;

    double wave_x_temp=0;
    double wave_y_temp=0;

    modulate_opacity_by_volume();
    maximize_colors();

    if(bWaveDots==1) glEnable(GL_LINE_STIPPLE);

    offset=(wave_x-.5)*texsize;
    scale=texsize/505.0;

    //Thick wave drawing
    if (bWaveThick==1)  glLineWidth(2*texsize/512);

    //Additive wave drawing (vice overwrite)
    if (bAdditiveWaves==0)  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    else    glBlendFunc(GL_SRC_ALPHA, GL_ONE);

    switch(nWaveMode)
    {
        case 8://monitor

            glPushMatrix();

            glTranslatef(texsize*.5,texsize*.5, 0);
            glRotated(-wave_mystery*90,0,0,1);

            glTranslatef(-texsize*.5,-texsize*.825, 0);

            /*
               for (x=0;x<16;x++)
               {
               glBegin(GL_LINE_STRIP);
               glColor4f(1.0-(x/15.0),.5,x/15.0,1.0);
               glVertex3f((totalframes%256)*2*scale, -beat_val[x]*fWaveScale+texsize*wave_y,-1);
               glColor4f(.5,.5,.5,1.0);
               glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
               glColor4f(1.0,1.0,0,1.0);
            //glVertex3f((totalframes%256)*scale*2, beat_val_att[x]*fWaveScale+texsize*wave_y,-1);
            glEnd();

            glTranslatef(0,texsize*(1/36.0), 0);
            }
             */

            glTranslatef(0,texsize*(1/18.0), 0);


            glBegin(GL_LINE_STRIP);
            glColor4f(1.0,1.0,0.5,1.0);
            glVertex3f((totalframes%256)*2*scale, treb_att*5*fWaveScale+texsize*wave_y,-1);
            glColor4f(.2,.2,.2,1.0);
            glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
            glColor4f(1.0,1.0,0,1.0);
            glVertex3f((totalframes%256)*scale*2, treb*-5*fWaveScale+texsize*wave_y,-1);
            glEnd();

            glTranslatef(0,texsize*.075, 0);
            glBegin(GL_LINE_STRIP);
            glColor4f(0,1.0,0.0,1.0);
            glVertex3f((totalframes%256)*2*scale, mid_att*5*fWaveScale+texsize*wave_y,-1);
            glColor4f(.2,.2,.2,1.0);
            glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
            glColor4f(.5,1.0,.5,1.0);
            glVertex3f((totalframes%256)*scale*2, mid*-5*fWaveScale+texsize*wave_y,-1);
            glEnd();


            glTranslatef(0,texsize*.075, 0);
            glBegin(GL_LINE_STRIP);
            glColor4f(1.0,0,0,1.0);
            glVertex3f((totalframes%256)*2*scale, bass_att*5*fWaveScale+texsize*wave_y,-1);
            glColor4f(.2,.2,.2,1.0);
            glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
            glColor4f(1.0,.5,.5,1.0);
            glVertex3f((totalframes%256)*scale*2, bass*-5*fWaveScale+texsize*wave_y,-1);
            glEnd();


            glPopMatrix();
            break;

        case 0://circular waveforms
            //  double co;
            glPushMatrix();

            glTranslatef(texsize*.5,texsize*.5, 0);
            glScalef(1.0,vw/(double)vh,1.0);
            glTranslatef((-texsize*.5) ,(-texsize*.5),0);

            wave_y=-1*(wave_y-1.0);

            glBegin(GL_LINE_STRIP);

            for ( x=0;x<numsamples;x++)
            {
                co= -(abs(x-((numsamples*.5)-1))/numsamples)+1;
                // printf("%d %f\n",x,co);
                theta=x*(6.28/numsamples);
                r= ((1+2*wave_mystery)*(texsize/5.0)+
                    ( co*pcmdataL[x]+ (1-co)*pcmdataL[-(x-(numsamples-1))])
                    *25*fWaveScale);

                glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
            }

            r= ( (1+2*wave_mystery)*(texsize/5.0)+
                 (0.5*pcmdataL[0]+ 0.5*pcmdataL[numsamples-1])
                 *20*fWaveScale);

            glVertex3f(r*cos(0)+(wave_x*texsize),r*sin(0)+(wave_y*texsize),-1);

            glEnd();
            /*
               glBegin(GL_LINE_LOOP);

               for ( x=0;x<(512/pcmbreak);x++)
               {
               theta=(blockstart+x)*((6.28*pcmbreak)/512.0);
               r= ((1+2*wave_mystery)*(texsize/5.0)+fdata_buffer[fbuffer][0][blockstart+x]*.0025*fWaveScale);

               glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
               }
               glEnd();
             */
            glPopMatrix();

            break;

        case 1://circularly moving waveform
            //  double co;
            glPushMatrix();

            glTranslatef(texsize*.5,texsize*.5, 0);
            glScalef(1.0,vw/(double)vh,1.0);
            glTranslatef((-texsize*.5) ,(-texsize*.5),0);

            wave_y=-1*(wave_y-1.0);

            glBegin(GL_LINE_STRIP);
            //theta=(frame%512)*(6.28/512.0);

            for ( x=1;x<512;x++)
            {
                co= -(abs(x-255)/512.0)+1;
                // printf("%d %f\n",x,co);
                theta=((frame%256)*(2*6.28/512.0))+pcmdataL[x]*.2*fWaveScale;
                r= ((1+2*wave_mystery)*(texsize/5.0)+
                    (pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale);

                glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
            }

            glEnd();

            glPopMatrix();

            break;

        case 2://EXPERIMENTAL
            wave_y=-1*(wave_y-1.0);
            glPushMatrix();
            glBegin(GL_LINE_STRIP);
            double xx,yy;
            // double xr= (wave_x*texsize), yr=(wave_y*texsize);
            xx=0;
            for ( x=1;x<512;x++)
            {
                //xx = ((pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale)*2;
                xx += (pcmdataL[x]*fWaveScale);
                yy= pcmdataL[x]*80*fWaveScale;
                //  glVertex3f( (wave_x*texsize)+(xx+yy)*2, (wave_y*texsize)+(xx-yy)*2,-1);
                glVertex3f( (wave_x*texsize)+(xx)*2, (wave_y*texsize)+(yy)*2,-1);


                //   xr+=fdata_buffer[fbuffer][0][x] *.0005* fWaveScale;
                //yr=(fdata_buffer[fbuffer][0][x]-fdata_buffer[fbuffer][0][x-1])*.05*fWaveScale+(wave_y*texsize);
                //glVertex3f(xr,yr,-1);

            }
            glEnd();
            glPopMatrix();
            break;

        case 3://EXPERIMENTAL
            glPushMatrix();
            wave_y=-1*(wave_y-1.0);
            glBegin(GL_LINE_STRIP);


            for ( x=1;x<512;x++)
            {
                xx= ((pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale)*2;
                yy=pcmdataL[x]*80*fWaveScale,-1;
                glVertex3f( (wave_x*texsize)+(xx+yy)*cos(45), (wave_y*texsize)+(-yy+xx)*cos(45),-1);
            }
            glEnd();
            glPopMatrix();
            break;

        case 4://single x-axis derivative waveform
            glPushMatrix();
            wave_y=-1*(wave_y-1.0);
            glTranslatef(texsize*.5,texsize*.5, 0);
            glRotated(-wave_mystery*90,0,0,1);
            glTranslatef(-texsize*.5,-texsize*.5, 0);
            wave_x=(wave_x*.75)+.125;      wave_x=-(wave_x-1);
            glBegin(GL_LINE_STRIP);

            double dy_adj;
            for ( x=1;x<512;x++)
            {
                dy_adj=  pcmdataL[x]*20*fWaveScale-pcmdataL[x-1]*20*fWaveScale;
                glVertex3f((x*scale)+dy_adj, pcmdataL[x]*20*fWaveScale+texsize*wave_x,-1);
            }
            glEnd();
            glPopMatrix();
            break;

        case 5://EXPERIMENTAL
            glPushMatrix();


            wave_y=-1*(wave_y-1.0);
            wave_x_temp=(wave_x*.75)+.125;
            wave_x_temp=-(wave_x_temp-1);
            glBegin(GL_LINE_STRIP);

            for ( x=1;x<(512);x++)
            {
                dy2_adj=  (pcmdataL[x]-pcmdataL[x-1])*20*fWaveScale;
                glVertex3f((wave_x_temp*texsize)+dy2_adj*2, pcmdataL[x]*20*fWaveScale+texsize*wave_y,-1);
            }
            glEnd();
            glPopMatrix();
            break;

        case 6://single waveform




            glTranslatef(0,0, -1);

            //glMatrixMode(GL_MODELVIEW);
            glPushMatrix();
            //            glLoadIdentity();

            glTranslatef(texsize*.5,texsize*.5, 0);
            glRotated(-wave_mystery*90,0,0,1);

            wave_x_temp=-2*0.4142*(abs(abs(wave_mystery)-.5)-.5);
            glScalef(1.0+wave_x_temp,1.0,1.0);
            glTranslatef(-texsize*.5,-texsize*.5, 0);
            wave_x_temp=-1*(wave_x-1.0);

            glBegin(GL_LINE_STRIP);
            //      wave_x_temp=(wave_x*.75)+.125;
            //      wave_x_temp=-(wave_x_temp-1);
            for ( x=0;x<numsamples;x++)
            {

                //glVertex3f(x*scale, fdata_buffer[fbuffer][0][blockstart+x]*.0012*fWaveScale+texsize*wave_x_temp,-1);
                glVertex3f(x*texsize/(double)numsamples, pcmdataR[x]*20*fWaveScale+texsize*wave_x_temp,-1);

                //glVertex3f(x*scale, texsize*wave_y_temp,-1);
            }
            //      printf("%f %f\n",texsize*wave_y_temp,wave_y_temp);
            glEnd();
            glPopMatrix();
            break;

        case 7://dual waveforms

            glPushMatrix();

            glTranslatef(texsize*.5,texsize*.5, 0);
            glRotated(-wave_mystery*90,0,0,1);

            wave_x_temp=-2*0.4142*(abs(abs(wave_mystery)-.5)-.5);
            glScalef(1.0+wave_x_temp,1.0,1.0);
            glTranslatef(-texsize*.5,-texsize*.5, 0);

            wave_y_temp=-1*(wave_x-1);

            glBegin(GL_LINE_STRIP);

            for ( x=0;x<numsamples;x++)
            {

                glVertex3f((x*texsize)/(double)numsamples, pcmdataL[x]*20*fWaveScale+texsize*(wave_y_temp+(wave_y*wave_y*.5)),-1);
            }
            glEnd();