opengl.c

uclinux 下的vlc播放器源代码

#else
    /* Update the texture */
    glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0,
                     p_vout->fmt_out.i_width,
                     p_vout->fmt_out.i_height,
                     VLCGL_FORMAT, VLCGL_TYPE, p_sys->pp_buffer[0] );
#endif

    if( p_sys->p_vout->pf_unlock )
    {
        p_sys->p_vout->pf_unlock( p_sys->p_vout );
    }
}


#ifdef OPENGL_MORE_EFFECT
/*****************************************************************************
 *   Transform: Calculate the distorted grid coordinates
 *****************************************************************************/
void Transform(float p, int distortion, float width, float height,int i, int j, int i_visible_width, int i_visible_height, double *ix,double *iy)
{
   double x,y,xnew,ynew;
   double r,theta,rnew,thetanew;

   x = (double)i * (width / ((double)i_visible_width));
   y = (double)j * (height / ((double)i_visible_height));

   x = (2.0 * (double)x / width) - 1;
   y = (2.0 * (double)y / height) - 1;
   xnew = x;
   ynew = y;
   r = sqrt(x*x+y*y);
   theta = atan2(y,x);

   switch (distortion) 
   {
/* GRID2D TRANSFORMATION */
	   case SINEXY:
		  xnew = sin(PID2*x);
		  ynew = sin(PID2*y);
		  break;
	   case SINER:
		  rnew = sin(PID2*r);
		  thetanew = theta;
		  xnew = rnew * cos(thetanew);
		  ynew = rnew * sin(thetanew);
		  break;
	   case SQUAREXY:
		  xnew = x*x*SIGN(x);
		  ynew = y*y*SIGN(y);
		  break;
	   case SQUARER:
		  rnew = r*r;
		  thetanew = theta;
		  xnew = rnew * cos(thetanew);
		  ynew = rnew * sin(thetanew);
		  break;
	   case ASINXY:
		  xnew = asin(x) / PID2;
		  ynew = asin(y) / PID2;
		  break;
	   case ASINR:
		  rnew = asin(r) / PID2;
		  thetanew = theta;
		  xnew = rnew * cos(thetanew);
		  ynew = rnew * sin(thetanew);
		  break;
/* OTHER WAY: 3D MODEL */
	   default:
		  xnew = x;
		  ynew = y;
   }

   *ix = width * (xnew + 1) / (2.0);
   *iy = height * (ynew + 1) / (2.0);
}


/*****************************************************************************
 *   Z_Compute: Calculate the Z-coordinate
 *****************************************************************************/
float Z_Compute(float p, int distortion, float x, float y)
{
  float f_z = 0.0;
  double d_p = p / 100.0;

  switch (distortion) 
   {
/* 3D MODEL */
	   case CYLINDER:
		  if (d_p > 0) 
			f_z = (1 - d_p * d_p) / (2 * d_p) - sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x));
		  else
			f_z = (1 - d_p * d_p) / (2 * d_p) + d_p + sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x));
		  break;
	   case TORUS:
		  if (d_p > 0) 
		    f_z =  (1 - d_p * d_p) / (d_p) - sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x)) - sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - y * y));
		  else
			f_z =  (1 - d_p * d_p) / (d_p) + 2 * d_p + sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x)) + sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - y * y));
		  break;
	   case SPHERE:
		  if (d_p > 0) 
   		    f_z = (1 - d_p * d_p) / (2 * d_p) - sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x - y * y));
		  else
			f_z = (1 - d_p * d_p) / (2 * d_p) + d_p + sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x - y * y));
		  break;
/* OTHER WAY: GRID2D TRANSFORMATION */
	   case SINEXY:;
	   case SINER:
	   case SQUAREXY:
	   case SQUARER:;
	   case ASINXY:
	   case ASINR:
		  f_z = 0.0;
		  break;
	   default:
		   f_z = 0.0;
   }
  return f_z;
}
#endif


/*****************************************************************************
 * DisplayVideo: displays previously rendered output
 *****************************************************************************/
static void DisplayVideo( vout_thread_t *p_vout, picture_t *p_pic )
{
    vout_sys_t *p_sys = p_vout->p_sys;
    float f_width, f_height, f_x, f_y;

    if( p_sys->p_vout->pf_lock &&
        p_sys->p_vout->pf_lock( p_sys->p_vout ) )
    {
        msg_Warn( p_vout, "could not lock OpenGL provider" );
        return;
    }

    /* glTexCoord works differently with GL_TEXTURE_2D and
       GL_TEXTURE_RECTANGLE_EXT */
#ifdef __APPLE__
    f_x = (float)p_vout->fmt_out.i_x_offset;
    f_y = (float)p_vout->fmt_out.i_y_offset;
    f_width = (float)p_vout->fmt_out.i_x_offset +
              (float)p_vout->fmt_out.i_visible_width;
    f_height = (float)p_vout->fmt_out.i_y_offset +
               (float)p_vout->fmt_out.i_visible_height;
#else
    f_x = (float)p_vout->fmt_out.i_x_offset / p_sys->i_tex_width;
    f_y = (float)p_vout->fmt_out.i_y_offset / p_sys->i_tex_height;
    f_width = ( (float)p_vout->fmt_out.i_x_offset +
                p_vout->fmt_out.i_visible_width ) / p_sys->i_tex_width;
    f_height = ( (float)p_vout->fmt_out.i_y_offset +
                 p_vout->fmt_out.i_visible_height ) / p_sys->i_tex_height;
#endif

    /* Why drawing here and not in Render()? Because this way, the
       OpenGL providers can call pf_display to force redraw. Currently,
       the OS X provider uses it to get a smooth window resizing */

    glClear( GL_COLOR_BUFFER_BIT );

    if( p_sys->i_effect == OPENGL_EFFECT_NONE )
    {
        glEnable( VLCGL_TARGET );
        glBegin( GL_POLYGON );
        glTexCoord2f( f_x, f_y ); glVertex2f( -1.0, 1.0 );
        glTexCoord2f( f_width, f_y ); glVertex2f( 1.0, 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex2f( 1.0, -1.0 );
        glTexCoord2f( f_x, f_height ); glVertex2f( -1.0, -1.0 );
        glEnd();
    }
    else
#ifdef OPENGL_MORE_EFFECT
		if ((p_sys->i_effect > OPENGL_EFFECT_TRANSPARENT_CUBE) || 
			((p_sys->i_effect == OPENGL_EFFECT_NONE)))
		{
		   unsigned int i_i, i_j;
		   unsigned int i_accuracy  = config_GetInt( p_vout, "opengl-accuracy");
		   unsigned int i_n = pow(2, i_accuracy);	
		   unsigned int i_n_x = (p_vout->fmt_out.i_visible_width / (i_n * 2));
		   unsigned int i_n_y = (p_vout->fmt_out.i_visible_height / i_n);
		   double d_x, d_y;
		   int i_distortion = p_sys->i_effect;
		   float f_p = p_sys->f_radius; 
                
		   glEnable( VLCGL_TARGET );
		   glBegin(GL_QUADS);								   
		   for (i_i = 0; i_i < p_vout->fmt_out.i_visible_width; i_i += i_n_x) 
		   {
			  if ( i_i == i_n_x * i_n / 2) i_n_x += p_vout->fmt_out.i_visible_width % i_n;
			  if ((i_i == (p_vout->fmt_out.i_visible_width / i_n) * i_n / 2 + i_n_x) &&
				  (p_vout->fmt_out.i_visible_width / i_n != i_n_x))
					i_n_x -= p_vout->fmt_out.i_visible_width % i_n; 
	
			  int i_m;
			  int i_index_max = 0;
					
			  for (i_j = 0; i_j < p_vout->fmt_out.i_visible_height; i_j += i_n_y) 
			  {
				if ( i_j == i_n_y * i_n / 2) i_n_y += p_vout->fmt_out.i_visible_height % i_n;
				if ((i_j == (p_vout->fmt_out.i_visible_height / i_n) * i_n / 2 + i_n_y) &&
					(p_vout->fmt_out.i_visible_height / i_n != i_n_y))
						i_n_y -= p_vout->fmt_out.i_visible_height % i_n;

				for (i_m = i_index_max; i_m < i_index_max + 4; i_m++)
				{
					int i_k = ((i_m % 4) == 1) || ((i_m % 4) == 2);
					int i_l = ((i_m % 4) == 2) || ((i_m % 4) == 3);

					Transform(f_p, i_distortion, f_width, f_height, i_i + i_k * i_n_x, i_j + i_l * i_n_y, p_vout->fmt_out.i_visible_width, p_vout->fmt_out.i_visible_height, &d_x, &d_y);								
					glTexCoord2f(f_x + d_x, f_y + d_y);
					d_x =  - 1.0 + 2.0 * ((double)(i_k * i_n_x + i_i) / (double)p_vout->fmt_out.i_visible_width);
					d_y =    1.0 - 2.0 * (((double)i_l * i_n_y + i_j) / (double)p_vout->fmt_out.i_visible_height);
					glVertex3f((float)d_x, (float)d_y, Z_Compute(f_p, i_distortion, (float)d_x, (float)d_y));	
				}
			  }
		   } 
		   glEnd();
		}
		else
#endif
	{
        glRotatef( 0.5 * p_sys->f_speed , 0.3, 0.5, 0.7 );

        glEnable( VLCGL_TARGET );
        glBegin( GL_QUADS );

        /* Front */
        glTexCoord2f( f_x, f_y ); glVertex3f( - 1.0, 1.0, 1.0 );
        glTexCoord2f( f_x, f_height ); glVertex3f( - 1.0, - 1.0, 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, - 1.0, 1.0 );
        glTexCoord2f( f_width, f_y ); glVertex3f( 1.0, 1.0, 1.0 );

        /* Left */
        glTexCoord2f( f_x, f_y ); glVertex3f( - 1.0, 1.0, - 1.0 );
        glTexCoord2f( f_x, f_height ); glVertex3f( - 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( - 1.0, - 1.0, 1.0 );
        glTexCoord2f( f_width, f_y ); glVertex3f( - 1.0, 1.0, 1.0 );

        /* Back */
        glTexCoord2f( f_x, f_y ); glVertex3f( 1.0, 1.0, - 1.0 );
        glTexCoord2f( f_x, f_height ); glVertex3f( 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( - 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, f_y ); glVertex3f( - 1.0, 1.0, - 1.0 );

        /* Right */
        glTexCoord2f( f_x, f_y ); glVertex3f( 1.0, 1.0, 1.0 );
        glTexCoord2f( f_x, f_height ); glVertex3f( 1.0, - 1.0, 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, f_y ); glVertex3f( 1.0, 1.0, - 1.0 );

        /* Top */
        glTexCoord2f( f_x, f_y ); glVertex3f( - 1.0, 1.0, - 1.0 );
        glTexCoord2f( f_x, f_height ); glVertex3f( - 1.0, 1.0, 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, 1.0, 1.0 );
        glTexCoord2f( f_width, f_y ); glVertex3f( 1.0, 1.0, - 1.0 );

        /* Bottom */
        glTexCoord2f( f_x, f_y ); glVertex3f( - 1.0, - 1.0, 1.0 );
        glTexCoord2f( f_x, f_height ); glVertex3f( - 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, f_y ); glVertex3f( 1.0, - 1.0, 1.0 );
        glEnd();
    }

    glDisable( VLCGL_TARGET );

    p_sys->p_vout->pf_swap( p_sys->p_vout );

    if( p_sys->p_vout->pf_unlock )
    {
        p_sys->p_vout->pf_unlock( p_sys->p_vout );
    }
}

int GetAlignedSize( int i_size )
{
    /* Return the nearest power of 2 */
    int i_result = 1;
    while( i_result < i_size )
    {
        i_result *= 2;
    }
    return i_result;
}

/*****************************************************************************
 * Control: control facility for the vout
 *****************************************************************************/
static int Control( vout_thread_t *p_vout, int i_query, va_list args )
{
    vout_sys_t *p_sys = p_vout->p_sys;

    switch( i_query )
    {
    case VOUT_SNAPSHOT:
        return vout_vaControlDefault( p_vout, i_query, args );

    default:
        if( p_sys->p_vout->pf_control )
            return p_sys->p_vout->pf_control( p_sys->p_vout, i_query, args );
        else
            return vout_vaControlDefault( p_vout, i_query, args );
    }
}

static int InitTextures( vout_thread_t *p_vout )
{
    vout_sys_t *p_sys = p_vout->p_sys;
    int i_index;

    glDeleteTextures( 2, p_sys->p_textures );
    glGenTextures( 2, p_sys->p_textures );

    for( i_index = 0; i_index < 2; i_index++ )
    {
        glBindTexture( VLCGL_TARGET, p_sys->p_textures[i_index] );

        /* Set the texture parameters */
        glTexParameterf( VLCGL_TARGET, GL_TEXTURE_PRIORITY, 1.0 );

        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );

        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_MIN_FILTER, GL_LINEAR );

        glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );

#ifdef __APPLE__
        /* Tell the driver not to make a copy of the texture but to use
           our buffer */
        glEnable( GL_UNPACK_CLIENT_STORAGE_APPLE );
        glPixelStorei( GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE );

#if 0
        /* Use VRAM texturing */
        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_STORAGE_HINT_APPLE,
                         GL_STORAGE_CACHED_APPLE );
#else
        /* Use AGP texturing */
        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_STORAGE_HINT_APPLE,
                         GL_STORAGE_SHARED_APPLE );
#endif
#endif

        /* Call glTexImage2D only once, and use glTexSubImage2D later */
        glTexImage2D( VLCGL_TARGET, 0, 3, p_sys->i_tex_width,
                      p_sys->i_tex_height, 0, VLCGL_FORMAT, VLCGL_TYPE,
                      p_sys->pp_buffer[i_index] );
    }

    return 0;
}

/*****************************************************************************
 * SendEvents: forward mouse and keyboard events to the parent p_vout
 *****************************************************************************/
static int SendEvents( vlc_object_t *p_this, char const *psz_var,
                       vlc_value_t oldval, vlc_value_t newval, void *_p_vout )
{
    return var_Set( (vlc_object_t *)_p_vout, psz_var, newval );
}