/* Callback for sent frames */ ssize_t vlc_https_send(struct vlc_tls *tls, const void *buf, size_t len) { const uint8_t *p = buf; assert(tls == NULL); if (expect_hello) { assert(len >= 24); assert(!memcmp(p, "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", 24)); expect_hello = false; vlc_sem_post(&rx); if (len == 24) return send_failure ? -1 : (ssize_t)len; p += 24; len -= 24; } assert(len == 9 + 1); assert(p[9] == counter); counter++; vlc_sem_post(&rx); return send_failure ? -1 : (ssize_t)len; }
void playlist_preparser_Delete( playlist_preparser_t *p_preparser ) { vlc_mutex_lock( &p_preparser->lock ); /* Remove pending item to speed up preparser thread exit */ while( p_preparser->i_waiting > 0 ) { preparser_entry_t *p_entry = p_preparser->pp_waiting[0]; vlc_gc_decref( p_entry->p_item ); free( p_entry ); REMOVE_ELEM( p_preparser->pp_waiting, p_preparser->i_waiting, 0 ); } vlc_sem_post( &p_preparser->item_done ); while( p_preparser->b_live ) vlc_cond_wait( &p_preparser->wait, &p_preparser->lock ); vlc_mutex_unlock( &p_preparser->lock ); /* Destroy the item preparser */ vlc_sem_destroy( &p_preparser->item_done ); vlc_cond_destroy( &p_preparser->wait ); vlc_mutex_destroy( &p_preparser->lock ); if( p_preparser->p_fetcher != NULL ) playlist_fetcher_Delete( p_preparser->p_fetcher ); free( p_preparser ); }
static void finished_event(const libvlc_event_t *p_ev, void *p_data) { (void) p_ev; vlc_sem_t *p_sem = p_data; vlc_sem_post(p_sem); }
static void vlc_vidsplit_Close(vout_display_t *vd) { vout_display_sys_t *sys = vd->sys; int n = sys->splitter.i_output; for (int i = 0; i < n; i++) { struct vlc_vidsplit_part *part = &sys->parts[i]; vout_display_t *display; vlc_sem_wait(&part->lock); display = part->display; part->display = NULL; vlc_sem_post(&part->lock); if (display != NULL) vout_display_Delete(display); vout_window_Disable(part->window); vout_window_Delete(part->window); vlc_sem_destroy(&part->lock); } module_unneed(&sys->splitter, sys->splitter.p_module); video_format_Clean(&sys->splitter.fmt); vlc_mutex_destroy(&sys->lock); vlc_object_release(&sys->splitter); }
static void output_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer) { filter_t *filter = (filter_t *)port->userdata; filter_sys_t *sys = filter->p_sys; picture_t *picture; if (buffer->cmd == 0) { if (buffer->length > 0) { atomic_store(&sys->started, true); mmal_queue_put(sys->filtered_pictures, buffer); picture = (picture_t *)buffer->user_data; } else { picture = (picture_t *)buffer->user_data; picture_Release(picture); } atomic_fetch_sub(&sys->output_in_transit, 1); vlc_sem_post(&sys->sem); } else if (buffer->cmd == MMAL_EVENT_FORMAT_CHANGED) { msg_Warn(filter, "MMAL_EVENT_FORMAT_CHANGED seen but not handled"); mmal_buffer_header_release(buffer); } else { mmal_buffer_header_release(buffer); } }
static picture_t *deinterlace(filter_t *filter, picture_t *picture) { filter_sys_t *sys = filter->p_sys; MMAL_BUFFER_HEADER_T *buffer; picture_t *out_picture = NULL; picture_t *ret = NULL; MMAL_STATUS_T status; unsigned i = 0; fill_output_port(filter); buffer = picture->p_sys->buffer; buffer->user_data = picture; buffer->pts = picture->date; buffer->cmd = 0; if (!picture->p_sys->displayed) { status = mmal_port_send_buffer(sys->input, buffer); if (status != MMAL_SUCCESS) { msg_Err(filter, "Failed to send buffer to input port (status=%"PRIx32" %s)", status, mmal_status_to_string(status)); picture_Release(picture); } else { picture->p_sys->displayed = true; atomic_fetch_add(&sys->input_in_transit, 1); vlc_sem_post(&sys->sem); } } else { picture_Release(picture); } /* * Send output buffers */ while(atomic_load(&sys->started) && i < 2) { if (buffer = mmal_queue_timedwait(sys->filtered_pictures, 2000)) { i++; if (!out_picture) { out_picture = (picture_t *)buffer->user_data; ret = out_picture; } else { out_picture->p_next = (picture_t *)buffer->user_data; out_picture = out_picture->p_next; } out_picture->date = buffer->pts; } else { msg_Dbg(filter, "Failed waiting for filtered picture"); break; } } if (out_picture) out_picture->p_next = NULL; return ret; }
static int Send( sout_stream_t *p_stream, sout_stream_id_t *id, block_t *p_buffer ) { VLC_UNUSED(id); sout_stream_sys_t *p_sys = p_stream->p_sys; block_ChainRelease( p_buffer ); if( p_sys->i_stream_start + 1500000 < mdate() ) vlc_sem_post(p_sys->data->sem); return VLC_SUCCESS; }
static void vlc_vidsplit_window_Resized(vout_window_t *wnd, unsigned width, unsigned height) { struct vlc_vidsplit_part *part = wnd->owner.sys; vlc_sem_wait(&part->lock); part->width = width; part->height = height; if (part->display != NULL) vout_display_SetSize(part->display, width, height); vlc_sem_post(&part->lock); }
static void vlc_vidsplit_window_Closed(vout_window_t *wnd) { struct vlc_vidsplit_part *part = wnd->owner.sys; vout_display_t *display; vlc_sem_wait(&part->lock); display = part->display; part->display = NULL; vlc_sem_post(&part->lock); if (display != NULL) vout_display_Delete(display); }
static void *joinable_thread(void *data) { vlc_thread_t th = data; void *ret; vlc_cleanup_push(finish_joinable_thread, th); thread = th; ret = th->entry(th->data); vlc_cleanup_pop(); vlc_sem_post(&th->finished); return ret; }
static void vlc_vidsplit_Display(vout_display_t *vd, picture_t *picture) { vout_display_sys_t *sys = vd->sys; for (int i = 0; i < sys->splitter.i_output; i++) { struct vlc_vidsplit_part *part = &sys->parts[i]; if (sys->pictures[i] != NULL) vout_display_Display(part->display, sys->pictures[i]); vlc_sem_post(&part->lock); } (void) picture; }
static int InputEvent( vlc_object_t *obj, const char *varname, vlc_value_t old, vlc_value_t cur, void *data ) { vlc_sem_t *done = data; int event = cur.i_int; if( event == INPUT_EVENT_DEAD ) vlc_sem_post( done ); (void) obj; (void) varname; (void) old; return VLC_SUCCESS; }
static void input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer) { block_t *block = (block_t *)buffer->user_data; decoder_t *dec = (decoder_t *)port->userdata; decoder_sys_t *sys = dec->p_sys; buffer->user_data = NULL; mmal_buffer_header_release(buffer); vlc_mutex_lock(&sys->mutex); if (block) block_Release(block); vlc_mutex_unlock(&sys->mutex); atomic_fetch_sub(&sys->input_in_transit, 1); vlc_sem_post(&sys->sem); }
static void input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer) { picture_t *picture = (picture_t *)buffer->user_data; filter_t *filter = (filter_t *)port->userdata; filter_sys_t *sys = filter->p_sys; if (picture) { picture_Release(picture); } else { msg_Warn(filter, "Got buffer without picture on input port - OOOPS"); mmal_buffer_header_release(buffer); } atomic_fetch_sub(&sys->input_in_transit, 1); vlc_sem_post(&sys->sem); }
static gboolean interface_ready( gpointer data ) { intf_thread_t *p_intf = (intf_thread_t *)data; p_intf->p_sys->xid = GDK_WINDOW_XID( gtk_widget_get_window(p_intf->p_sys->p_video_window) ); // Refresh playlist post_event( p_intf, EVENT_PLAYLIST_CURRENT ); // Everything is initialised vlc_sem_post (&p_intf->p_sys->ready); // We want it to be executed only one time return FALSE; }
static void *vlc_https_connect_thread(void *data) { struct vlc_https_connecting *c = data; vlc_tls_t *tls; char *proxy = vlc_https_proxy_find(c->host, c->port); if (proxy != NULL) { tls = vlc_https_connect_proxy(c->creds, c->host, c->port, &c->http2, proxy); free(proxy); } else tls = vlc_https_connect(c->creds, c->host, c->port, &c->http2); vlc_sem_post(&c->done); return tls; }
static int send_output_buffer(filter_t *filter) { filter_sys_t *sys = filter->p_sys; MMAL_BUFFER_HEADER_T *buffer; MMAL_STATUS_T status; picture_t *picture; int ret = 0; if (!sys->output->is_enabled) { ret = VLC_EGENERIC; goto out; } picture = filter_NewPicture(filter); if (!picture) { msg_Warn(filter, "Failed to get new picture"); ret = -1; goto out; } picture->format.i_frame_rate = filter->fmt_out.video.i_frame_rate; picture->format.i_frame_rate_base = filter->fmt_out.video.i_frame_rate_base; buffer = picture->p_sys->buffer; buffer->user_data = picture; buffer->cmd = 0; mmal_picture_lock(picture); status = mmal_port_send_buffer(sys->output, buffer); if (status != MMAL_SUCCESS) { msg_Err(filter, "Failed to send buffer to output port (status=%"PRIx32" %s)", status, mmal_status_to_string(status)); mmal_buffer_header_release(buffer); picture_Release(picture); ret = -1; } else { atomic_fetch_add(&sys->output_in_transit, 1); vlc_sem_post(&sys->sem); } out: return ret; }
int Upnp_i11e_cb::run( Upnp_EventType eventType, void *p_event, void *p_cookie ) { Upnp_i11e_cb *self = static_cast<Upnp_i11e_cb*>( p_cookie ); vlc_mutex_lock( &self->m_lock ); if ( --self->m_refCount == 0 ) { /* Interrupted, we can destroy self */ vlc_mutex_unlock( &self->m_lock ); delete self; return 0; } /* Process the user callback_ */ self->m_callback( eventType, p_event, self->m_cookie); vlc_mutex_unlock( &self->m_lock ); /* Signal that the callback is processed */ vlc_sem_post( &self->m_sem ); return 0; }
static void output_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer) { decoder_t *dec = (decoder_t *)port->userdata; decoder_sys_t *sys = dec->p_sys; picture_t *picture; MMAL_EVENT_FORMAT_CHANGED_T *fmt; MMAL_ES_FORMAT_T *format; if (buffer->cmd == 0) { if (buffer->length > 0) { mmal_queue_put(sys->decoded_pictures, buffer); } else { picture = (picture_t *)buffer->user_data; picture_Release(picture); if (sys->output_pool) { buffer->user_data = NULL; buffer->alloc_size = 0; buffer->data = NULL; mmal_buffer_header_release(buffer); } } atomic_fetch_sub(&sys->output_in_transit, 1); vlc_sem_post(&sys->sem); } else if (buffer->cmd == MMAL_EVENT_FORMAT_CHANGED) { fmt = mmal_event_format_changed_get(buffer); format = mmal_format_alloc(); mmal_format_full_copy(format, fmt->format); if (sys->opaque) format->encoding = MMAL_ENCODING_OPAQUE; sys->output_format = format; mmal_buffer_header_release(buffer); } else { mmal_buffer_header_release(buffer); } }
static void preparsed_changed(const libvlc_event_t *event, void *user_data) { (void)event; vlc_sem_t *sem = user_data; vlc_sem_post (sem); }
static void subitem_tree_added(const libvlc_event_t *event, void *user_data) { (void)event; vlc_sem_t *sem = user_data; vlc_sem_post (sem); }
static void libvlc_wait_wakeup( void *data ) { vlc_sem_post( data ); }
/** * 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; }
static void vlc_interrupt_sem(void *opaque) { vlc_sem_post(opaque); }
static void *Thread( void *obj ) { intf_thread_t *p_intf = (intf_thread_t *)obj; MainInterface *p_mi; char dummy[] = "vlc"; /* for WM_CLASS */ char *argv[4] = { dummy, NULL, }; int argc = 1; Q_INIT_RESOURCE( vlc ); /* Start the QApplication here */ #ifdef Q_WS_X11 if( x11_display != NULL ) { argv[argc++] = const_cast<char *>("-display"); argv[argc++] = x11_display; argv[argc] = NULL; } #endif QVLCApp app( argc, argv ); p_intf->p_sys->p_app = &app; /* All the settings are in the .conf/.ini style */ p_intf->p_sys->mainSettings = new QSettings( #ifdef WIN32 QSettings::IniFormat, #else QSettings::NativeFormat, #endif QSettings::UserScope, "vlc", "vlc-qt-interface" ); /* Icon setting */ if( QDate::currentDate().dayOfYear() >= 352 ) /* One Week before Xmas */ app.setWindowIcon( QIcon(vlc_christmas_xpm) ); else app.setWindowIcon( QIcon(vlc_xpm) ); /* Initialize timers and the Dialog Provider */ DialogsProvider::getInstance( p_intf ); /* Detect screensize for small screens like TV or EEEpc*/ p_intf->p_sys->i_screenHeight = app.QApplication::desktop()->availableGeometry().height(); #ifdef UPDATE_CHECK /* Checking for VLC updates */ if( var_InheritBool( p_intf, "qt-updates-notif" ) && !var_InheritBool( p_intf, "qt-privacy-ask" ) ) { int interval = var_InheritInteger( p_intf, "qt-updates-days" ); if( QDate::currentDate() > getSettings()->value( "updatedate" ).toDate().addDays( interval ) ) { /* The constructor of the update Dialog will do the 1st request */ UpdateDialog::getInstance( p_intf ); getSettings()->setValue( "updatedate", QDate::currentDate() ); } } #endif /* Create the normal interface in non-DP mode */ if( !p_intf->p_sys->b_isDialogProvider ) p_mi = new MainInterface( p_intf ); else p_mi = NULL; p_intf->p_sys->p_mi = p_mi; /* Explain how to show a dialog :D */ p_intf->pf_show_dialog = ShowDialog; /* */ vlc_sem_post (&ready); /* Last settings */ app.setQuitOnLastWindowClosed( false ); /* Retrieve last known path used in file browsing */ p_intf->p_sys->filepath = getSettings()->value( "filedialog-path", QVLCUserDir( VLC_HOME_DIR ) ).toString(); /* Loads and tries to apply the preferred QStyle */ QString s_style = getSettings()->value( "MainWindow/QtStyle", "" ).toString(); if( s_style.compare("") != 0 ) QApplication::setStyle( s_style ); /* Launch */ app.exec(); /* And quit */ QApplication::closeAllWindows(); if (p_mi != NULL) { #warning BUG! /* FIXME: the video window may still be registerd at this point */ /* See LP#448082 as an example. */ p_intf->p_sys->p_mi = NULL; /* Destroy first the main interface because it is connected to some slots in the MainInputManager */ delete p_mi; } /* Destroy all remaining windows, because some are connected to some slots in the MainInputManager Settings must be destroyed after that. */ DialogsProvider::killInstance(); /* Delete the recentsMRL object before the configuration */ RecentsMRL::killInstance(); /* Save the path */ getSettings()->setValue( "filedialog-path", p_intf->p_sys->filepath ); /* Delete the configuration. Application has to be deleted after that. */ delete p_intf->p_sys->mainSettings; /* Destroy the MainInputManager */ MainInputManager::killInstance(); /* Delete the application automatically */ 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; int cancel = vlc_savecancel(); video_format_t fmt; vout_opengl_t *gl; int i_last_width = 0; int i_last_height = 0; #ifdef HAVE_PROJECTM2 projectM::Settings settings; #endif /* 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; vlc_object_attach( p_sys->p_vout, p_filter ); /* */ 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; } /* Create the projectM object */ #ifndef HAVE_PROJECTM2 p_sys->p_projectm = new projectM( p_sys->psz_config ); #else settings.meshX = 32; settings.meshY = 24; settings.fps = 35; settings.textureSize = 1024; settings.windowWidth = p_sys->i_width; settings.windowHeight = p_sys->i_height; settings.presetURL = p_sys->psz_preset_path; settings.titleFontURL = p_sys->psz_title_font; settings.menuFontURL = p_sys->psz_menu_font; settings.smoothPresetDuration = 5; settings.presetDuration = 30; settings.beatSensitivity = 10; settings.aspectCorrection = 1; settings.easterEgg = 1; settings.shuffleEnabled = 1; p_sys->p_projectm = new projectM( settings ); #endif p_sys->i_buffer_size = p_sys->p_projectm->pcm()->maxsamples; p_sys->p_buffer = (float*)calloc( p_sys->i_buffer_size, sizeof( float ) ); vlc_sem_post( &p_sys->ready ); /* TODO: Give to projectm the name of the input p_sys->p_projectm->projectM_setTitle( "" ); */ /* */ 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_sys->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_sys->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_sys->p_projectm; vout_DeleteDisplay( p_sys->p_vd, NULL ); vlc_object_release( p_sys->p_vout ); return NULL; } vlc_mutex_unlock( &p_sys->lock ); p_sys->p_projectm->renderFrame(); /* */ mwait( i_deadline ); if( !vout_opengl_Lock(gl) ) { vout_opengl_Swap( gl ); vout_opengl_Unlock( gl ); } } abort(); error: p_sys->b_error = true; vlc_sem_post( &p_sys->ready ); 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; }
static void finish_joinable_thread(void *data) { vlc_thread_t th = data; vlc_sem_post(&th->finished); }
static void *Thread( void *obj ) { intf_thread_t *p_intf = (intf_thread_t *)obj; MainInterface *p_mi; char vlc_name[] = "vlc"; /* for WM_CLASS */ #ifdef QT5_HAS_X11 char platform_parm[] = "-platform"; char platform_value[] = "xcb"; #endif char *argv[] = { vlc_name, #ifdef QT5_HAS_X11 platform_parm, platform_value, #endif NULL, }; int argc = sizeof(argv) / sizeof(argv[0]) - 1; Q_INIT_RESOURCE( vlc ); /* Start the QApplication here */ QVLCApp app( argc, argv ); p_intf->p_sys->p_app = &app; /* All the settings are in the .conf/.ini style */ p_intf->p_sys->mainSettings = new QSettings( #ifdef _WIN32 QSettings::IniFormat, #else QSettings::NativeFormat, #endif QSettings::UserScope, "vlc", "vlc-qt-interface" ); /* Icon setting, Mac uses icon from .icns */ #ifndef Q_OS_MAC if( QDate::currentDate().dayOfYear() >= QT_XMAS_JOKE_DAY && var_InheritBool( p_intf, "qt-icon-change" ) ) app.setWindowIcon( QIcon::fromTheme( "vlc-xmas", QIcon( ":/logo/vlc128-xmas.png" ) ) ); else app.setWindowIcon( QIcon::fromTheme( "vlc", QIcon( ":/logo/vlc256.png" ) ) ); #endif /* Initialize the Dialog Provider and the Main Input Manager */ DialogsProvider::getInstance( p_intf ); MainInputManager::getInstance( p_intf ); #ifdef UPDATE_CHECK /* Checking for VLC updates */ if( var_InheritBool( p_intf, "qt-updates-notif" ) && !var_InheritBool( p_intf, "qt-privacy-ask" ) ) { int interval = var_InheritInteger( p_intf, "qt-updates-days" ); if( QDate::currentDate() > getSettings()->value( "updatedate" ).toDate().addDays( interval ) ) { /* The constructor of the update Dialog will do the 1st request */ UpdateDialog::getInstance( p_intf ); getSettings()->setValue( "updatedate", QDate::currentDate() ); } } #endif /* Create the normal interface in non-DP mode */ if( !p_intf->p_sys->b_isDialogProvider ) { p_mi = new MainInterface( p_intf ); p_intf->p_sys->p_mi = p_mi; } else p_mi = NULL; /* Explain how to show a dialog :D */ p_intf->pf_show_dialog = ShowDialog; /* Check window type from the Qt platform back-end */ p_intf->p_sys->voutWindowType = VOUT_WINDOW_TYPE_INVALID; #if HAS_QT5 || defined (Q_WS_QPA) QString platform = app.platformName(); if( platform == qfu("xcb") ) p_intf->p_sys->voutWindowType = VOUT_WINDOW_TYPE_XID; else if( platform == qfu("windows") ) p_intf->p_sys->voutWindowType = VOUT_WINDOW_TYPE_HWND; else if( platform == qfu("cocoa" ) ) p_intf->p_sys->voutWindowType = VOUT_WINDOW_TYPE_NSOBJECT; else msg_Err( p_intf, "unknown Qt platform: %s", qtu(platform) ); #elif defined (Q_WS_X11) p_intf->p_sys->voutWindowType = VOUT_WINDOW_TYPE_XID; #elif defined (Q_WS_WIN) || defined (Q_WS_PM) p_intf->p_sys->voutWindowType = VOUT_WINDOW_TYPE_HWND; #elif defined (Q_WS_MAC) p_intf->p_sys->voutWindowType = VOUT_WINDOW_TYPE_NSOBJECT; #endif /* Tell the main LibVLC thread we are ready */ vlc_sem_post (&ready); #ifdef Q_OS_MAC /* We took over main thread, register and start here */ if( !p_intf->p_sys->b_isDialogProvider ) { RegisterIntf( p_intf ); playlist_Play( THEPL ); } #endif /* Last settings */ app.setQuitOnLastWindowClosed( false ); /* Retrieve last known path used in file browsing */ p_intf->p_sys->filepath = getSettings()->value( "filedialog-path", QVLCUserDir( VLC_HOME_DIR ) ).toString(); /* Loads and tries to apply the preferred QStyle */ QString s_style = getSettings()->value( "MainWindow/QtStyle", "" ).toString(); if( s_style.compare("") != 0 ) QApplication::setStyle( s_style ); /* Launch */ app.exec(); msg_Dbg( p_intf, "QApp exec() finished" ); if (p_mi != NULL) { QMutexLocker locker (&lock); active = false; p_intf->p_sys->p_mi = NULL; /* Destroy first the main interface because it is connected to some slots in the MainInputManager */ delete p_mi; } /* */ ExtensionsManager::killInstance(); AddonsManager::killInstance(); /* Destroy all remaining windows, because some are connected to some slots in the MainInputManager Settings must be destroyed after that. */ DialogsProvider::killInstance(); /* Delete the recentsMRL object before the configuration */ RecentsMRL::killInstance(); /* Save the path or delete if recent play are disabled */ if( var_InheritBool( p_intf, "qt-recentplay" ) ) getSettings()->setValue( "filedialog-path", p_intf->p_sys->filepath ); else getSettings()->remove( "filedialog-path" ); /* */ delete p_intf->p_sys->pl_model; /* Delete the configuration. Application has to be deleted after that. */ delete p_intf->p_sys->mainSettings; /* Destroy the MainInputManager */ MainInputManager::killInstance(); /* Delete the application automatically */ 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; }