static void ClearSurface(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
if (sys->p_window->b_opaque)
{
/* Clear the surface to black with OpenGL ES 2 */
char *modlist = var_InheritString(sys->embed, "gles2");
vlc_gl_t *gl = vlc_gl_Create(vd->cfg, VLC_OPENGL_ES2, modlist);
free(modlist);
if (gl == NULL)
return;
if (vlc_gl_MakeCurrent(gl))
goto end;
vlc_gl_Resize(gl, 1, 1);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
vlc_gl_Swap(gl);
vlc_gl_ReleaseCurrent(gl);
end:
vlc_gl_Release(gl);
}
else
{
android_window *p_window = sys->p_window;
ANativeWindow_Buffer buf;
if (sys->anw->setBuffersGeometry(p_window->p_surface, 1, 1,
WINDOW_FORMAT_RGB_565) == 0
&& sys->anw->winLock(p_window->p_surface, &buf, NULL) == 0)
{
uint16_t *p_bit = buf.bits;
p_bit[0] = 0x0000;
sys->anw->unlockAndPost(p_window->p_surface);
}
}
}
/**
* ProjectM update thread which do the rendering
* @param p_this: the p_thread object
*/
static void *Thread( void *p_data )
{
filter_t *p_filter = (filter_t*)p_data;
filter_sys_t *p_sys = p_filter->p_sys;
video_format_t fmt;
vlc_gl_t *gl;
unsigned int i_last_width = 0;
unsigned int i_last_height = 0;
locale_t loc;
locale_t oldloc;
projectM *p_projectm;
#ifndef HAVE_PROJECTM2
char *psz_config;
#else
char *psz_preset_path;
char *psz_title_font;
char *psz_menu_font;
projectM::Settings settings;
#endif
vlc_savecancel();
/* Create the openGL provider */
p_sys->p_vout =
(vout_thread_t *)vlc_object_create( p_filter, sizeof(vout_thread_t) );
if( !p_sys->p_vout )
goto error;
/* */
video_format_Init( &fmt, 0 );
video_format_Setup( &fmt, VLC_CODEC_RGB32,
p_sys->i_width, p_sys->i_height, 0, 1 );
fmt.i_sar_num = 1;
fmt.i_sar_den = 1;
vout_display_state_t state;
memset( &state, 0, sizeof(state) );
state.cfg.display.sar.num = 1;
state.cfg.display.sar.den = 1;
state.cfg.is_display_filled = true;
state.cfg.zoom.num = 1;
state.cfg.zoom.den = 1;
state.sar.num = 1;
state.sar.den = 1;
p_sys->p_vd = vout_NewDisplay( p_sys->p_vout, &fmt, &state, "opengl",
300000, 1000000 );
if( !p_sys->p_vd )
{
vlc_object_release( p_sys->p_vout );
goto error;
}
var_Create( p_sys->p_vout, "fullscreen", VLC_VAR_BOOL );
var_AddCallback( p_sys->p_vout, "fullscreen", VoutCallback, p_sys->p_vd );
gl = vout_GetDisplayOpengl( p_sys->p_vd );
if( !gl )
{
vout_DeleteDisplay( p_sys->p_vd, NULL );
vlc_object_release( p_sys->p_vout );
goto error;
}
/* Work-around the projectM locale bug */
loc = newlocale (LC_NUMERIC_MASK, "C", NULL);
oldloc = uselocale (loc);
/* Create the projectM object */
#ifndef HAVE_PROJECTM2
psz_config = var_InheritString( p_filter, "projectm-config" );
p_projectm = new projectM( psz_config );
free( psz_config );
#else
psz_preset_path = var_InheritString( p_filter, "projectm-preset-path" );
#ifdef WIN32
if ( psz_preset_path == NULL )
{
char *psz_data_path = config_GetDataDir( p_filter );
asprintf( &psz_preset_path, "%s" DIR_SEP "visualization", psz_data_path );
free( psz_data_path );
}
#endif
psz_title_font = var_InheritString( p_filter, "projectm-title-font" );
psz_menu_font = var_InheritString( p_filter, "projectm-menu-font" );
settings.meshX = var_InheritInteger( p_filter, "projectm-meshx" );
settings.meshY = var_InheritInteger( p_filter, "projectm-meshy" );
settings.fps = 35;
settings.textureSize = var_InheritInteger( p_filter, "projectm-texture-size" );
settings.windowWidth = p_sys->i_width;
settings.windowHeight = p_sys->i_height;
settings.presetURL = psz_preset_path;
settings.titleFontURL = psz_title_font;
settings.menuFontURL = psz_menu_font;
settings.smoothPresetDuration = 5;
settings.presetDuration = 30;
settings.beatSensitivity = 10;
settings.aspectCorrection = 1;
settings.easterEgg = 1;
settings.shuffleEnabled = 1;
p_projectm = new projectM( settings );
free( psz_menu_font );
free( psz_title_font );
free( psz_preset_path );
#endif /* HAVE_PROJECTM2 */
p_sys->i_buffer_size = p_projectm->pcm()->maxsamples;
p_sys->p_buffer = (float*)calloc( p_sys->i_buffer_size,
sizeof( float ) );
vlc_sem_post( &p_sys->ready );
/* Choose a preset randomly or projectM will always show the first one */
if ( p_projectm->getPlaylistSize() > 0 )
p_projectm->selectPreset( (unsigned)vlc_mrand48() % p_projectm->getPlaylistSize() );
/* */
for( ;; )
{
const mtime_t i_deadline = mdate() + CLOCK_FREQ / 50; /* 50 fps max */
/* Manage the events */
vout_ManageDisplay( p_sys->p_vd, true );
if( p_sys->p_vd->cfg->display.width != i_last_width ||
p_sys->p_vd->cfg->display.height != i_last_height )
{
/* FIXME it is not perfect as we will have black bands */
vout_display_place_t place;
vout_display_PlacePicture( &place, &p_sys->p_vd->source, p_sys->p_vd->cfg, false );
p_projectm->projectM_resetGL( place.width, place.height );
i_last_width = p_sys->p_vd->cfg->display.width;
i_last_height = p_sys->p_vd->cfg->display.height;
}
/* Render the image and swap the buffers */
vlc_mutex_lock( &p_sys->lock );
if( p_sys->i_nb_samples > 0 )
{
p_projectm->pcm()->addPCMfloat( p_sys->p_buffer,
p_sys->i_nb_samples );
p_sys->i_nb_samples = 0;
}
if( p_sys->b_quit )
{
vlc_mutex_unlock( &p_sys->lock );
delete p_projectm;
vout_DeleteDisplay( p_sys->p_vd, NULL );
vlc_object_release( p_sys->p_vout );
if (loc != (locale_t)0)
{
uselocale (oldloc);
freelocale (loc);
}
return NULL;
}
vlc_mutex_unlock( &p_sys->lock );
p_projectm->renderFrame();
/* */
mwait( i_deadline );
if( !vlc_gl_Lock(gl) )
{
vlc_gl_Swap( gl );
vlc_gl_Unlock( gl );
}
}
abort();
error:
p_sys->b_error = true;
vlc_sem_post( &p_sys->ready );
return NULL;
}
/**
* Update thread which do the rendering
* @param p_this: the p_thread object
*/
static void *Thread( void *p_data )
{
filter_t *p_filter = (filter_t*)p_data;
filter_sys_t *p_sys = p_filter->p_sys;
video_format_t fmt;
vlc_gl_t *gl;
unsigned int i_last_width = 0;
unsigned int i_last_height = 0;
/* Create the openGL provider */
p_sys->p_vout =
(vout_thread_t *)vlc_object_create(p_filter, sizeof(vout_thread_t));
if (!p_sys->p_vout)
goto error;
/* Configure the video format for the opengl provider. */
video_format_Init(&fmt, 0);
video_format_Setup(&fmt, VLC_CODEC_RGB32,
p_sys->i_width, p_sys->i_height, 0, 1 );
fmt.i_sar_num = 1;
fmt.i_sar_den = 1;
/* Init vout state. */
vout_display_state_t state;
memset(&state, 0, sizeof(state));
state.cfg.display.sar.num = 1;
state.cfg.display.sar.den = 1;
state.cfg.is_display_filled = true;
state.cfg.zoom.num = 1;
state.cfg.zoom.den = 1;
state.sar.num = 1;
state.sar.den = 1;
p_sys->p_vd = vout_NewDisplay(p_sys->p_vout, &fmt, &state,
"opengl", 1000000, 1000000);
if (!p_sys->p_vd)
{
vlc_object_release(p_sys->p_vout);
goto error;
}
gl = vout_GetDisplayOpengl(p_sys->p_vd);
if (!gl)
{
vout_DeleteDisplay(p_sys->p_vd, NULL);
vlc_object_release(p_sys->p_vout);
goto error;
}
vlc_sem_post(&p_sys->ready);
initOpenGLScene();
float height[NB_BANDS] = {0};
while (1)
{
block_t *block = block_FifoGet(p_sys->fifo);
int canc = vlc_savecancel();
/* Manage the events */
vout_ManageDisplay(p_sys->p_vd, true);
if (p_sys->p_vd->cfg->display.width != i_last_width ||
p_sys->p_vd->cfg->display.height != i_last_height)
{
/* FIXME it is not perfect as we will have black bands */
vout_display_place_t place;
vout_display_PlacePicture(&place, &p_sys->p_vd->source,
p_sys->p_vd->cfg, false);
i_last_width = p_sys->p_vd->cfg->display.width;
i_last_height = p_sys->p_vd->cfg->display.height;
}
/* Horizontal scale for 20-band equalizer */
const unsigned xscale[] = {0,1,2,3,4,5,6,7,8,11,15,20,27,
36,47,62,82,107,141,184,255};
fft_state *p_state; /* internal FFT data */
unsigned i, j;
float p_output[FFT_BUFFER_SIZE]; /* Raw FFT Result */
int16_t p_buffer1[FFT_BUFFER_SIZE]; /* Buffer on which we perform
the FFT (first channel) */
int16_t p_dest[FFT_BUFFER_SIZE]; /* Adapted FFT result */
float *p_buffl = (float*)block->p_buffer; /* Original buffer */
int16_t *p_buffs; /* int16_t converted buffer */
int16_t *p_s16_buff; /* int16_t converted buffer */
/* Allocate the buffer only if the number of samples change */
if (block->i_nb_samples != p_sys->i_prev_nb_samples)
{
free(p_sys->p_prev_s16_buff);
p_sys->p_prev_s16_buff = malloc(block->i_nb_samples *
p_sys->i_channels *
sizeof(int16_t));
if (!p_sys->p_prev_s16_buff)
goto release;
p_sys->i_prev_nb_samples = block->i_nb_samples;
}
p_buffs = p_s16_buff = p_sys->p_prev_s16_buff;
/* Convert the buffer to int16_t
Pasted from float32tos16.c */
for (i = block->i_nb_samples * p_sys->i_channels; i--;)
{
union {float f; int32_t i;} u;
u.f = *p_buffl + 384.0;
if (u.i > 0x43c07fff)
*p_buffs = 32767;
else if (u.i < 0x43bf8000)
*p_buffs = -32768;
else
*p_buffs = u.i - 0x43c00000;
p_buffl++; p_buffs++;
}
p_state = visual_fft_init();
if (!p_state)
{
msg_Err(p_filter,"unable to initialize FFT transform");
goto release;
}
p_buffs = p_s16_buff;
for (i = 0 ; i < FFT_BUFFER_SIZE; i++)
{
p_output[i] = 0;
p_buffer1[i] = *p_buffs;
p_buffs += p_sys->i_channels;
if (p_buffs >= &p_s16_buff[block->i_nb_samples * p_sys->i_channels])
p_buffs = p_s16_buff;
}
fft_perform (p_buffer1, p_output, p_state);
for (i = 0; i< FFT_BUFFER_SIZE; ++i)
p_dest[i] = p_output[i] * (2 ^ 16)
/ ((FFT_BUFFER_SIZE / 2 * 32768) ^ 2);
for (i = 0 ; i < NB_BANDS; i++)
{
/* Decrease the previous size of the bar. */
height[i] -= BAR_DECREMENT;
if (height[i] < 0)
height[i] = 0;
int y = 0;
/* We search the maximum on one scale
to determine the current size of the bar. */
for (j = xscale[i]; j < xscale[i + 1]; j++)
{
if (p_dest[j] > y)
y = p_dest[j];
}
/* Calculate the height of the bar */
float new_height = y != 0 ? log(y) * 0.4 : 0;
height[i] = new_height > height[i]
? new_height : height[i];
}
/* Determine the camera rotation angle. */
p_sys->f_rotationAngle += p_sys->f_rotationIncrement;
if (p_sys->f_rotationAngle <= -ROTATION_MAX)
p_sys->f_rotationIncrement = ROTATION_INCREMENT;
else if (p_sys->f_rotationAngle >= ROTATION_MAX)
p_sys->f_rotationIncrement = -ROTATION_INCREMENT;
/* Render the frame. */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(p_sys->f_rotationAngle, 0, 1, 0);
drawBars(height);
glPopMatrix();
/* Wait to swapp the frame on time. */
mwait(block->i_pts + (block->i_length / 2));
if (!vlc_gl_Lock(gl))
{
vlc_gl_Swap(gl);
vlc_gl_Unlock(gl);
}
release:
block_Release(block);
vlc_restorecancel(canc);
}
assert(0);
error:
p_sys->b_error = true;
vlc_sem_post(&p_sys->ready);
return NULL;
}
/**
* ProjectM update thread which do the rendering
* @param p_this: the p_thread object
*/
static void *Thread( void *p_data )
{
filter_t *p_filter = (filter_t*)p_data;
filter_sys_t *p_sys = p_filter->p_sys;
vlc_gl_t *gl = p_sys->gl;
locale_t loc;
locale_t oldloc;
projectM *p_projectm;
#ifndef HAVE_PROJECTM2
char *psz_config;
#else
char *psz_preset_path;
char *psz_title_font;
char *psz_menu_font;
projectM::Settings settings;
#endif
vlc_gl_MakeCurrent( gl );
/* Work-around the projectM locale bug */
loc = newlocale (LC_NUMERIC_MASK, "C", NULL);
oldloc = uselocale (loc);
/* Create the projectM object */
#ifndef HAVE_PROJECTM2
psz_config = var_InheritString( p_filter, "projectm-config" );
p_projectm = new projectM( psz_config );
free( psz_config );
#else
psz_preset_path = var_InheritString( p_filter, "projectm-preset-path" );
#ifdef _WIN32
if ( psz_preset_path == NULL )
{
char *psz_data_path = config_GetDataDir();
asprintf( &psz_preset_path, "%s" DIR_SEP "visualization", psz_data_path );
free( psz_data_path );
}
#endif
psz_title_font = var_InheritString( p_filter, "projectm-title-font" );
psz_menu_font = var_InheritString( p_filter, "projectm-menu-font" );
settings.meshX = var_InheritInteger( p_filter, "projectm-meshx" );
settings.meshY = var_InheritInteger( p_filter, "projectm-meshy" );
settings.fps = 35;
settings.textureSize = var_InheritInteger( p_filter, "projectm-texture-size" );
settings.windowWidth = var_InheritInteger( p_filter, "projectm-width" );
settings.windowHeight = var_CreateGetInteger( p_filter, "projectm-height" );
settings.presetURL = psz_preset_path;
settings.titleFontURL = psz_title_font;
settings.menuFontURL = psz_menu_font;
settings.smoothPresetDuration = 5;
settings.presetDuration = 30;
settings.beatSensitivity = 10;
settings.aspectCorrection = 1;
settings.easterEgg = 1;
settings.shuffleEnabled = 1;
settings.softCutRatingsEnabled= false;
p_projectm = new projectM( settings );
free( psz_menu_font );
free( psz_title_font );
free( psz_preset_path );
#endif /* HAVE_PROJECTM2 */
p_sys->i_buffer_size = p_projectm->pcm()->maxsamples;
p_sys->p_buffer = (float*)calloc( p_sys->i_buffer_size,
sizeof( float ) );
/* Choose a preset randomly or projectM will always show the first one */
if ( p_projectm->getPlaylistSize() > 0 )
p_projectm->selectPreset( (unsigned)vlc_mrand48() % p_projectm->getPlaylistSize() );
/* */
for( ;; )
{
const mtime_t i_deadline = mdate() + CLOCK_FREQ / 50; /* 50 fps max */
/* Manage the events */
unsigned width, height;
bool quit;
if( vlc_gl_surface_CheckSize( gl, &width, &height ) )
p_projectm->projectM_resetGL( width, height );
/* Render the image and swap the buffers */
vlc_mutex_lock( &p_sys->lock );
if( p_sys->i_nb_samples > 0 )
{
p_projectm->pcm()->addPCMfloat( p_sys->p_buffer,
p_sys->i_nb_samples );
p_sys->i_nb_samples = 0;
}
quit = p_sys->b_quit;
vlc_mutex_unlock( &p_sys->lock );
if( quit )
break;
p_projectm->renderFrame();
/* */
mwait( i_deadline );
if( !vlc_gl_Lock(gl) )
{
vlc_gl_Swap( gl );
vlc_gl_Unlock( gl );
}
}
delete p_projectm;
if (loc != (locale_t)0)
{
uselocale (oldloc);
freelocale (loc);
}
vlc_gl_ReleaseCurrent( gl );
return NULL;
}
/**
* VSXu update thread which do the rendering
* @param p_this: the p_thread object
*/
static void *Thread( void *p_data )
{
filter_t *p_filter = (filter_t*)p_data;
filter_sys_t *p_sys = p_filter->p_sys;
vlc_gl_t *gl = p_sys->gl;
// our abstract manager holder
vsx_manager_abs* manager = 0;
// temp audio buffer for sending to vsxu through manager
float f_sample_buf[512];
// vsxu logo intro
vsx_logo_intro* intro = 0;
bool first = true;
bool run = true;
// tell main thread we are ready
vlc_gl_MakeCurrent( gl );
while ( run )
{
/* Manage the events */
unsigned width, height;
if( vlc_gl_surface_CheckSize( p_sys->gl, &width, &height ) )
{
/* ??? */
}
// look for control commands from outside the thread
vlc_mutex_lock( &p_sys->lock );
if( p_sys->b_quit )
{
run = false;
}
vlc_mutex_unlock( &p_sys->lock );
if (first)
{
// only run this once
first = false;
// create a new manager
manager = manager_factory();
// init manager with the shared path and sound input type.
manager->init( 0, "media_player" );
// only show logo once
// keep track of iterations
static int i_iterations = 0;
if ( i_iterations++ < 1 )
{
intro = new vsx_logo_intro();
intro->set_destroy_textures( false );
}
}
// lock cyclic buffer mutex and copy floats
vlc_mutex_lock( &p_sys->cyclic_block_mutex );
block_holder* bh = p_sys->vsxu_cyclic_buffer->consume();
memcpy( &f_sample_buf[0], (void*)(&bh->data[0]), sizeof(float) * 512 );
vlc_mutex_unlock( &p_sys->cyclic_block_mutex );
// send sound pointer to vsxu
manager->set_sound_wave( &f_sample_buf[0] );
// render vsxu engine
if (manager) manager->render();
// render intro
if (intro) intro->draw();
// swap buffers etc.
if( !vlc_gl_Lock(gl) )
{
vlc_gl_Swap( gl );
vlc_gl_Unlock( gl );
}
}
// stop vsxu nicely (unloads textures and frees memory)
if (manager) manager->stop();
// call manager factory to destruct our manager object
if (manager) manager_destroy( manager );
// delete the intro (if ever allocated)
if (intro) delete intro;
vlc_gl_ReleaseCurrent( gl );
// clean up the cyclic buffer
vlc_mutex_lock( &p_sys->cyclic_block_mutex );
p_sys->vsxu_cyclic_buffer->reset();
vlc_mutex_unlock( &p_sys->cyclic_block_mutex );
// die
return NULL;
}
/**
* VSXu update thread which do the rendering
* @param p_this: the p_thread object
*/
static void *Thread( void *p_data )
{
filter_t *p_filter = (filter_t*)p_data;
filter_sys_t *p_sys = p_filter->p_sys;
// our abstract manager holder
vsx_manager_abs* manager = 0;
// temp audio buffer for sending to vsxu through manager
float f_sample_buf[512];
// vsxu logo intro
vsx_logo_intro* intro = 0;
vout_display_t *p_vd;
video_format_t fmt;
vlc_gl_t *gl;
unsigned int i_last_width = 0;
unsigned int i_last_height = 0;
bool first = true;
bool run = true;
/* Create the openGL provider */
vout_thread_t *p_vout;
p_vout = (vout_thread_t *)vlc_object_create( p_filter, sizeof(vout_thread_t) );
if( !p_vout )
goto error;
video_format_Init( &fmt, 0 );
video_format_Setup( &fmt, VLC_CODEC_RGB32,
p_sys->i_width, p_sys->i_height, 0, 1 );
fmt.i_sar_num = 1;
fmt.i_sar_den = 1;
vout_display_state_t state;
memset( &state, 0, sizeof(state) );
state.cfg.display.sar.num = 1;
state.cfg.display.sar.den = 1;
state.cfg.is_display_filled = true;
state.cfg.zoom.num = 1;
state.cfg.zoom.den = 1;
state.sar.num = 1;
state.sar.den = 1;
p_vd = vout_NewDisplay( p_vout, &fmt, &state, "opengl", 300000, 1000000 );
if( !p_vd )
{
vlc_object_release( p_vout );
goto error;
}
var_Create( p_vout, "fullscreen", VLC_VAR_BOOL );
var_AddCallback( p_vout, "fullscreen", VoutCallback, p_vd );
gl = vout_GetDisplayOpengl( p_vd );
if( !gl )
{
var_DelCallback( p_vout, "fullscreen", VoutCallback, p_vd );
vout_DeleteDisplay( p_vd, NULL );
vlc_object_release( p_vout );
goto error;
}
// tell main thread we are ready
vlc_sem_post( &p_sys->ready );
while ( run )
{
/* Manage the events */
vout_ManageDisplay( p_vd, true );
if( p_vd->cfg->display.width != i_last_width ||
p_vd->cfg->display.height != i_last_height )
{
/* FIXME it is not perfect as we will have black bands */
vout_display_place_t place;
vout_display_PlacePicture( &place, &p_vd->source, p_vd->cfg, false );
i_last_width = p_vd->cfg->display.width;
i_last_height = p_vd->cfg->display.height;
}
// look for control commands from outside the thread
vlc_mutex_lock( &p_sys->lock );
if( p_sys->b_quit )
{
run = false;
}
vlc_mutex_unlock( &p_sys->lock );
if (first)
{
// only run this once
first = false;
// create a new manager
manager = manager_factory();
// init manager with the shared path and sound input type.
manager->init( 0, "media_player" );
// only show logo once
// keep track of iterations
static int i_iterations = 0;
if ( i_iterations++ < 1 )
{
intro = new vsx_logo_intro();
intro->set_destroy_textures( false );
}
}
// lock cyclic buffer mutex and copy floats
vlc_mutex_lock( &p_sys->cyclic_block_mutex );
block_holder* bh = p_sys->vsxu_cyclic_buffer->consume();
memcpy( &f_sample_buf[0], (void*)(&bh->data[0]), sizeof(float) * 512 );
vlc_mutex_unlock( &p_sys->cyclic_block_mutex );
// send sound pointer to vsxu
manager->set_sound_wave( &f_sample_buf[0] );
// render vsxu engine
if (manager) manager->render();
// render intro
if (intro) intro->draw();
// swap buffers etc.
if( !vlc_gl_Lock(gl) )
{
vlc_gl_Swap( gl );
vlc_gl_Unlock( gl );
}
}
// stop vsxu nicely (unloads textures and frees memory)
if (manager) manager->stop();
// call manager factory to destruct our manager object
if (manager) manager_destroy( manager );
// delete the intro (if ever allocated)
if (intro) delete intro;
var_DelCallback( p_vout, "fullscreen", VoutCallback, p_vd );
// clean out vlc opengl stuff
vout_DeleteDisplay( p_vd, NULL );
vlc_object_release( p_vout );
// clean up the cyclic buffer
vlc_mutex_lock( &p_sys->cyclic_block_mutex );
p_sys->vsxu_cyclic_buffer->reset();
vlc_mutex_unlock( &p_sys->cyclic_block_mutex );
// die
return NULL;
error:
p_sys->b_error = true;
vlc_sem_post( &p_sys->ready );
return NULL;
}