void sms_Free( sms_stream_t *sms ) { if( sms->qlevels ) { for( int n = 0; n < vlc_array_count( sms->qlevels ); n++ ) { quality_level_t *qlevel = (quality_level_t *)vlc_array_item_at_index( sms->qlevels, n ); // sunqueen modify if( qlevel ) ql_Free( qlevel ); } vlc_array_destroy( sms->qlevels ); } if( sms->chunks ) { for( int n = 0; n < vlc_array_count( sms->chunks ); n++ ) { chunk_t *chunk = (chunk_t *)vlc_array_item_at_index( sms->chunks, n ); // sunqueen modify if( chunk) chunk_Free( chunk ); } vlc_array_destroy( sms->chunks ); } free( sms->name ); free( sms->url_template ); free( sms ); sms = NULL; }
/***************************************************************************** * Close: *****************************************************************************/ static void Close(vlc_object_t *p_this) { fingerprinter_thread_t *p_fingerprinter = (fingerprinter_thread_t*) p_this; fingerprinter_sys_t *p_sys = p_fingerprinter->p_sys; vlc_cancel( p_sys->thread ); vlc_join( p_sys->thread, NULL ); vlc_mutex_destroy( &p_sys->condwait.lock ); vlc_cond_destroy( &p_sys->condwait.wait ); for ( int i = 0; i < vlc_array_count( p_sys->incoming.queue ); i++ ) fingerprint_request_Delete( vlc_array_item_at_index( p_sys->incoming.queue, i ) ); vlc_array_destroy( p_sys->incoming.queue ); vlc_mutex_destroy( &p_sys->incoming.lock ); vlc_cond_destroy( &p_sys->incoming_queue_filled ); for ( int i = 0; i < vlc_array_count( p_sys->processing.queue ); i++ ) fingerprint_request_Delete( vlc_array_item_at_index( p_sys->processing.queue, i ) ); vlc_array_destroy( p_sys->processing.queue ); vlc_mutex_destroy( &p_sys->processing.lock ); for ( int i = 0; i < vlc_array_count( p_sys->results.queue ); i++ ) fingerprint_request_Delete( vlc_array_item_at_index( p_sys->results.queue, i ) ); vlc_array_destroy( p_sys->results.queue ); vlc_mutex_destroy( &p_sys->results.lock ); free( p_sys ); }
static void Close ( vlc_object_t *p_this ) { intf_thread_t *p_intf = (intf_thread_t*) p_this; playlist_t *p_playlist = pl_Hold( p_intf );; input_thread_t *p_input; var_DelCallback( p_playlist, "item-current", AllCallback, p_intf ); var_DelCallback( p_playlist, "intf-change", AllCallback, p_intf ); var_DelCallback( p_playlist, "playlist-item-append", AllCallback, p_intf ); var_DelCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf ); var_DelCallback( p_playlist, "random", AllCallback, p_intf ); var_DelCallback( p_playlist, "repeat", AllCallback, p_intf ); var_DelCallback( p_playlist, "loop", AllCallback, p_intf ); p_input = playlist_CurrentInput( p_playlist ); if ( p_input ) { var_DelCallback( p_input, "state", AllCallback, p_intf ); vlc_object_release( p_input ); } pl_Release( p_intf ); dbus_connection_unref( p_intf->p_sys->p_conn ); // Free the events array for( int i = 0; i < vlc_array_count( p_intf->p_sys->p_events ); i++ ) { callback_info_t* info = vlc_array_item_at_index( p_intf->p_sys->p_events, i ); free( info ); } vlc_mutex_destroy( &p_intf->p_sys->lock ); vlc_array_destroy( p_intf->p_sys->p_events ); free( p_intf->p_sys ); }
bool MLModel::event( QEvent *event ) { if ( event->type() == MLEvent::MediaAdded_Type ) { event->accept(); MLEvent *e = static_cast<MLEvent *>(event); vlc_array_t* p_result = vlc_array_new(); if ( ml_FindMedia( e->p_ml, p_result, ML_ID, e->ml_media_id ) == VLC_SUCCESS ) { insertResultArray( p_result ); ml_DestroyResultArray( p_result ); } vlc_array_destroy( p_result ); return true; } else if( event->type() == MLEvent::MediaRemoved_Type ) { event->accept(); MLEvent *e = static_cast<MLEvent *>(event); removeRow( getIndexByMLID( e->ml_media_id ).row() ); return true; } else if( event->type() == MLEvent::MediaUpdated_Type ) { event->accept(); /* Never implemented... */ return true; } return VLCModel::event( event ); }
void MLModel::removeAll() { vlc_array_t* p_where = vlc_array_new(); if ( !p_where ) return; int rows = rowCount(); if( rows > 0 ) { beginRemoveRows( createIndex( 0, 0 ), 0, rows-1 ); QList< MLItem* >::iterator it = items.begin(); ml_element_t p_find[ items.count() ]; int i = 0; while( it != items.end() ) { p_find[i].criteria = ML_ID; p_find[i].value.i = (*it)->id( MLMEDIA_ID ); vlc_array_append( p_where, & p_find[i++] ); delete *it; it++; } ml_Delete( p_ml, p_where ); items.clear(); endRemoveRows(); } vlc_array_destroy( p_where ); reset(); }
/** * @brief Remove a directory to monitor * @param p_ml A media library object * @param psz_dir the directory to remove * @return VLC_SUCCESS or VLC_EGENERIC */ int RemoveDirToMonitor( media_library_t *p_ml, const char *psz_dir ) { assert( p_ml ); char **pp_results = NULL; int i_cols = 0, i_rows = 0, i_ret = VLC_SUCCESS; int i; bool b_recursive = var_CreateGetBool( p_ml, "ml-recursive-scan" ); if( b_recursive ) { i_ret = Query( p_ml, &pp_results, &i_rows, &i_cols, "SELECT media.id FROM media JOIN directories ON " "(media.directory_id = directories.id) WHERE " "directories.uri LIKE '%q%%'", psz_dir ); if( i_ret != VLC_SUCCESS ) { msg_Err( p_ml, "Error occured while making a query to the database" ); return i_ret; } QuerySimple( p_ml, "DELETE FROM directories WHERE uri LIKE '%q%%'", psz_dir ); } else { i_ret = Query( p_ml, &pp_results, &i_rows, &i_cols, "SELECT media.id FROM media JOIN directories ON " "(media.directory_id = directories.id) WHERE " "directories.uri = %Q", psz_dir ); if( i_ret != VLC_SUCCESS ) { msg_Err( p_ml, "Error occured while making a query to the database" ); return i_ret; } QuerySimple( p_ml, "DELETE FROM directories WHERE uri = %Q", psz_dir ); } vlc_array_t *p_where = vlc_array_new(); for( i = 1; i <= i_rows; i++ ) { int id = atoi( pp_results[i*i_cols] ); ml_element_t* p_find = ( ml_element_t * ) calloc( 1, sizeof( ml_element_t ) ); p_find->criteria = ML_ID; p_find->value.i = id; vlc_array_append( p_where, p_find ); } Delete( p_ml, p_where ); FreeSQLResult( p_ml, pp_results ); for( i = 0; i < vlc_array_count( p_where ); i++ ) { free( vlc_array_item_at_index( p_where, i ) ); } vlc_array_destroy( p_where ); return VLC_SUCCESS; }
void bdsm_SdClose (vlc_object_t *p_this) { services_discovery_t *sd = (services_discovery_t *)p_this; services_discovery_sys_t *p_sys = sd->p_sys; if( p_sys == NULL ) return; if( p_sys->p_ns ) { netbios_ns_discover_stop( p_sys->p_ns ); netbios_ns_destroy( p_sys->p_ns ); } if( p_sys->p_entry_item_list ) { for ( int i = 0; i < vlc_array_count( p_sys->p_entry_item_list ); i++ ) { struct entry_item *p_entry_item; p_entry_item = vlc_array_item_at_index( p_sys->p_entry_item_list, i ); vlc_gc_decref( p_entry_item->p_item ); free( p_entry_item ); } vlc_array_destroy( p_sys->p_entry_item_list ); } free( p_sys ); }
static void Close ( vlc_object_t *p_this ) { intf_thread_t *p_intf = (intf_thread_t*) p_this; intf_sys_t *p_sys = p_intf->p_sys; playlist_t *p_playlist = p_sys->p_playlist; vlc_cancel( p_sys->thread ); vlc_join( p_sys->thread, NULL ); var_DelCallback( p_playlist, "input-current", AllCallback, p_intf ); var_DelCallback( p_playlist, "volume", AllCallback, p_intf ); var_DelCallback( p_playlist, "mute", AllCallback, p_intf ); var_DelCallback( p_playlist, "playlist-item-append", AllCallback, p_intf ); var_DelCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf ); var_DelCallback( p_playlist, "random", AllCallback, p_intf ); var_DelCallback( p_playlist, "repeat", AllCallback, p_intf ); var_DelCallback( p_playlist, "loop", AllCallback, p_intf ); var_DelCallback( p_playlist, "fullscreen", AllCallback, p_intf ); if( p_sys->p_input ) { var_DelCallback( p_sys->p_input, "intf-event", InputCallback, p_intf ); var_DelCallback( p_sys->p_input, "can-pause", AllCallback, p_intf ); var_DelCallback( p_sys->p_input, "can-seek", AllCallback, p_intf ); vlc_object_release( p_sys->p_input ); } /* The dbus connection is private, so we are responsible * for closing it */ dbus_connection_close( p_sys->p_conn ); dbus_connection_unref( p_sys->p_conn ); // Free the events array for( int i = 0; i < vlc_array_count( p_sys->p_events ); i++ ) { callback_info_t* info = vlc_array_item_at_index( p_sys->p_events, i ); free( info ); } vlc_mutex_destroy( &p_sys->lock ); vlc_array_destroy( p_sys->p_events ); vlc_array_destroy( p_sys->p_timeouts ); vlc_array_destroy( p_sys->p_watches ); vlc_close( p_sys->p_pipe_fds[1] ); vlc_close( p_sys->p_pipe_fds[0] ); free( p_sys ); }
static void Close( vlc_object_t *p_this ) { stream_t *s = (stream_t*)p_this; stream_sys_t *p_sys = s->p_sys; vlc_mutex_lock( &p_sys->download.lock_wait ); p_sys->b_close = true; /* Negate the condition variable's predicate */ for( int i = 0; i < 3; i++ ) p_sys->download.lead[i] = 0; p_sys->playback.toffset = 0; vlc_cond_signal(&p_sys->download.wait); vlc_mutex_unlock( &p_sys->download.lock_wait ); vlc_join( p_sys->thread, NULL ); vlc_mutex_destroy( &p_sys->download.lock_wait ); vlc_cond_destroy( &p_sys->download.wait ); /* Free sms streams */ sms_stream_t *sms; for( int i = 0; i < vlc_array_count( p_sys->sms_streams ); i++ ) { sms = vlc_array_item_at_index( p_sys->sms_streams, i ); if( sms ) sms_Free( sms ); } /* Free downloaded chunks */ chunk_t *chunk; for( int i = 0; i < vlc_array_count( p_sys->init_chunks ); i++ ) { chunk = vlc_array_item_at_index( p_sys->init_chunks, i ); chunk_Free( chunk ); } sms_queue_free( p_sys->bws ); vlc_array_destroy( p_sys->sms_streams ); vlc_array_destroy( p_sys->selected_st ); vlc_array_destroy( p_sys->download.chunks ); vlc_array_destroy( p_sys->init_chunks ); free( p_sys->base_url ); free( p_sys ); }
static void SysCleanup( stream_sys_t *p_sys ) { if ( p_sys->sms_streams ) { for ( int i=0; i< p_sys->sms_streams->i_count ; i++ ) sms_Free( p_sys->sms_streams->pp_elems[i] ); vlc_array_destroy( p_sys->sms_streams ); } vlc_array_destroy( p_sys->selected_st ); vlc_array_destroy( p_sys->download.chunks ); if ( p_sys->init_chunks ) { for ( int i=0; i< p_sys->init_chunks->i_count ; i++ ) chunk_Free( p_sys->init_chunks->pp_elems[i] ); vlc_array_destroy( p_sys->init_chunks ); } sms_queue_free( p_sys->bws ); free( p_sys->base_url ); }
static int mediaAdded( vlc_object_t *p_this, char const *psz_var, vlc_value_t oldval, vlc_value_t newval, void *data ) { VLC_UNUSED( psz_var ); VLC_UNUSED( oldval ); int ret = VLC_SUCCESS; media_library_t *p_ml = ( media_library_t* )p_this; MLModel* p_model = ( MLModel* )data; vlc_array_t* p_result = vlc_array_new(); ret = ml_FindMedia( p_ml, p_result, ML_ID, newval.i_int ); if( ret != VLC_SUCCESS ) { vlc_array_destroy( p_result ); return VLC_EGENERIC; } p_model->insertResultArray( p_result ); vlc_array_destroy( p_result ); return VLC_SUCCESS; }
/** * @brief Definition of the result item model for the result tree * @param parent the parent Qt object */ MLModel::MLModel( intf_thread_t* _p_intf, QObject *parent ) :VLCModel( _p_intf, parent ) { p_ml = ml_Get( p_intf ); if ( !p_ml ) return; vlc_array_t *p_result_array = vlc_array_new(); if ( p_result_array ) { ml_Find( p_ml, p_result_array, ML_MEDIA ); insertResultArray( p_result_array ); ml_DestroyResultArray( p_result_array ); vlc_array_destroy( p_result_array ); } var_AddCallback( p_ml, "media-added", mediaAdded, this ); var_AddCallback( p_ml, "media-deleted", mediaDeleted, this ); var_AddCallback( p_ml, "media-meta-change", mediaUpdated, this ); }
static int CreatePlaylist( stream_t *s, char **pp_buffer ) { stream_sys_t *p_sys = s->p_sys; unzFile file = p_sys->zipFile; if( !file ) return -1; /* Get some infos about zip archive */ int i_ret = 0; vlc_array_t *p_filenames = vlc_array_new(); /* Will contain char* */ /* List all file names in Zip archive */ i_ret = GetFilesInZip( s, file, p_filenames, NULL ); if( i_ret < 0 ) { i_ret = -1; goto exit; } /* Construct the xspf playlist */ i_ret = WriteXSPF( pp_buffer, p_filenames, p_sys->psz_path ); if( i_ret > 0 ) i_ret = 1; else if( i_ret < 0 ) i_ret = -1; exit: /* Close archive */ unzClose( file ); p_sys->zipFile = NULL; for( int i = 0; i < vlc_array_count( p_filenames ); i++ ) { free( vlc_array_item_at_index( p_filenames, i ) ); } vlc_array_destroy( p_filenames ); return i_ret; }
/** * @brief Update a ml_media_t * * @param p_ml the media library object * @param p_media media to synchronise in the database * @return VLC_SUCCESS or VLC_EGENERIC * @note: the media id may be 0, in this case, the update is based * on the url (less powerful). This function is threadsafe * * This synchronises all non NULL and non zero fields of p_media * Synchronization of album and people is TODO */ int UpdateMedia( media_library_t *p_ml, ml_media_t *p_media ) { assert( p_media->i_id || ( p_media->psz_uri && *p_media->psz_uri ) ); vlc_array_t *changes = vlc_array_new(); ml_element_t *find = NULL; int i_ret = VLC_EGENERIC; ml_LockMedia( p_media ); #define APPEND_ICHANGES( cond, crit ) \ if( cond ) { \ find = ( ml_element_t* ) calloc( 1, sizeof( ml_element_t ) ); \ find->criteria = crit; \ find->value.i = cond; \ vlc_array_append( changes, find ); \ } #define APPEND_SCHANGES( cond, crit ) \ if( cond ) { \ find = ( ml_element_t* ) calloc( 1, sizeof( ml_element_t ) ); \ find->criteria = crit; \ find->value.str = cond; \ vlc_array_append( changes, find ); \ } APPEND_SCHANGES( p_media->psz_title, ML_TITLE ); APPEND_ICHANGES( p_media->i_type, ML_TYPE ); APPEND_ICHANGES( p_media->i_duration, ML_DURATION ); APPEND_SCHANGES( p_media->psz_preview, ML_PREVIEW ); APPEND_SCHANGES( p_media->psz_cover, ML_COVER ); APPEND_ICHANGES( p_media->i_disc_number, ML_DISC_NUMBER ); APPEND_ICHANGES( p_media->i_track_number, ML_TRACK_NUMBER ); APPEND_ICHANGES( p_media->i_year, ML_YEAR); APPEND_SCHANGES( p_media->psz_genre, ML_GENRE ); APPEND_ICHANGES( p_media->i_album_id, ML_ALBUM_ID ); APPEND_SCHANGES( p_media->psz_album, ML_ALBUM ); APPEND_ICHANGES( p_media->i_skipped_count, ML_SKIPPED_COUNT ); APPEND_ICHANGES( p_media->i_last_skipped, ML_LAST_SKIPPED ); APPEND_ICHANGES( p_media->i_played_count, ML_PLAYED_COUNT ); APPEND_ICHANGES( p_media->i_last_played, ML_LAST_PLAYED ); APPEND_ICHANGES( p_media->i_first_played, ML_FIRST_PLAYED ); APPEND_ICHANGES( p_media->i_vote, ML_VOTE ); APPEND_ICHANGES( p_media->i_score, ML_SCORE ); APPEND_SCHANGES( p_media->psz_comment, ML_COMMENT ); APPEND_SCHANGES( p_media->psz_extra, ML_EXTRA ); APPEND_SCHANGES( p_media->psz_language, ML_LANGUAGE ); if( p_media->psz_uri && p_media->i_id ) { find = ( ml_element_t* ) calloc( 1, sizeof( ml_element_t ) ); find->criteria = ML_URI; find->value.str = p_media->psz_uri; vlc_array_append( changes, find ); } /*TODO: implement extended meta */ /* We're not taking import time! Good */ #undef APPEND_ICHANGES #undef APPEND_SCHANGES ml_person_t* person = p_media->p_people; while( person ) { if( person->i_id > 0 ) { find = ( ml_element_t* ) calloc( 1, sizeof( ml_element_t ) ); find->criteria = ML_PEOPLE_ID; find->lvalue.str = person->psz_role; find->value.i = person->i_id; vlc_array_append( changes, find ); } else if( person->psz_name && *person->psz_name ) { find = ( ml_element_t* ) calloc( 1, sizeof( ml_element_t ) ); find->criteria = ML_PEOPLE; find->lvalue.str = person->psz_role; find->value.str = person->psz_name; vlc_array_append( changes, find ); } person = person->p_next; } ml_ftree_t* p_where = NULL; ml_ftree_t* p_where_elt = ( ml_ftree_t* ) calloc( 1, sizeof( ml_ftree_t ) ); if( p_media->i_id ) { p_where_elt->criteria = ML_ID; p_where_elt->value.i = p_media->i_id ; p_where_elt->comp = ML_COMP_EQUAL; p_where = ml_FtreeFastAnd( p_where, p_where_elt ); } else if( p_media->psz_uri ) { p_where_elt->criteria = ML_URI; p_where_elt->value.str = p_media->psz_uri; p_where_elt->comp = ML_COMP_EQUAL; p_where = ml_FtreeFastAnd( p_where, p_where_elt ); } else { goto quit1; } i_ret = Update( p_ml, ML_MEDIA, NULL, p_where, changes ); quit1: ml_FreeFindTree( p_where ); for( int i = 0; i < vlc_array_count( changes ); i++ ) /* Note: DO NOT free the strings because * they belong to the ml_media_t object */ free( vlc_array_item_at_index( changes, i ) ); vlc_array_destroy( changes ); ml_UnlockMedia( p_media ); return i_ret; }
/** * @brief Scan files in a particular directory */ static void ScanFiles( monitoring_thread_t *p_mon, int i_dir_id, bool b_recursive, stat_list_t *stparent ) { int i_rows, i_cols, i_dir_content, i, i_mon_rows, i_mon_cols; char **ppsz_monitored_files; char **pp_results, *psz_dir; char **pp_dir_content; bool *pb_processed; input_item_t *p_input; struct stat s_stat; media_library_t *p_ml = (media_library_t *)p_mon->p_ml; Query( p_ml, &pp_results, &i_rows, &i_cols, "SELECT uri AS directory_uri FROM directories WHERE id = '%d'", i_dir_id ); if( i_rows < 1 ) { msg_Dbg( p_mon, "query returned no directory for dir_id: %d (%s:%d)", i_dir_id, __FILE__, __LINE__ ); return; } psz_dir = strdup( pp_results[1] ); FreeSQLResult( p_ml, pp_results ); struct stat_list_t stself; if( vlc_stat( psz_dir, &stself.st ) == -1 ) { msg_Err( p_ml, "Cannot stat `%s': %m", psz_dir ); free( psz_dir ); return; } #ifndef WIN32 for( stat_list_t *stats = stparent; stats != NULL; stats = stats->parent ) { if( ( stself.st.st_ino == stats->st.st_ino ) && ( stself.st.st_dev == stats->st.st_dev ) ) { msg_Warn( p_ml, "Ignoring infinitely recursive directory `%s'", psz_dir ); free( psz_dir ); return; } } #else /* Windows has st_dev (driver letter - 'A'), but it zeroes st_ino, * so that the test above will always incorrectly succeed. * Besides, Windows does not have dirfd(). */ #endif stself.parent = stparent; QuerySimple( p_ml, "UPDATE directories SET timestamp=%d WHERE id = %d", stself.st.st_mtime, i_dir_id ); Query( p_ml, &ppsz_monitored_files, &i_mon_rows, &i_mon_cols, "SELECT id AS media_id, timestamp AS media_ts, uri AS media_uri " "FROM media WHERE directory_id = %d", i_dir_id ); pb_processed = malloc(sizeof(bool) * i_mon_rows); for( i = 0; i < i_mon_rows ; i++) pb_processed[i] = false; i_dir_content = vlc_scandir( psz_dir, &pp_dir_content, NULL, Sort ); if( i_dir_content == -1 ) { msg_Err( p_mon, "Cannot read `%s': %m", psz_dir ); free( pb_processed ); free( psz_dir ); return; } else if( i_dir_content == 0 ) { msg_Dbg( p_mon, "Nothing in directory `%s'", psz_dir ); free( pb_processed ); free( psz_dir ); return; } for( i = 0; i < i_dir_content; i++ ) { const char *psz_entry = pp_dir_content[i]; if( psz_entry[0] != '.' ) { /* 7 is the size of "file://" */ char psz_uri[strlen(psz_dir) + strlen(psz_entry) + 2 + 7]; sprintf( psz_uri, "%s/%s", psz_dir, psz_entry ); if( vlc_stat( psz_uri, &s_stat ) == -1 ) { msg_Err( p_mon, "%s: %m", psz_uri ); free( pb_processed ); free( psz_dir ); return; } if( S_ISREG( s_stat.st_mode ) ) { const char *psz_dot = strrchr( psz_uri, '.' ); if( psz_dot++ && *psz_dot ) { int i_is_media = 0; for( int a = 0; ppsz_MediaExtensions[a]; a++ ) { if( !strcasecmp( psz_dot, ppsz_MediaExtensions[a] ) ) { i_is_media = 1; break; } } if( !i_is_media ) { msg_Dbg( p_mon, "ignoring file %s", psz_uri ); continue; } } char * psz_tmp = encode_URI_component( psz_uri ); char * psz_encoded_uri = ( char * )calloc( strlen( psz_tmp ) + 9, 1 ); strcpy( psz_encoded_uri, "file:///" ); strcat( psz_encoded_uri, psz_tmp ); free( psz_tmp ); /* Check if given media is already in DB and it has been updated */ bool b_skip = false; bool b_update = false; int j = 1; for( j = 1; j <= i_mon_rows; j++ ) { if( strcasecmp( ppsz_monitored_files[ j * i_mon_cols + 2 ], psz_encoded_uri ) != 0 ) continue; b_update = true; pb_processed[ j - 1 ] = true; if( atoi( ppsz_monitored_files[ j * i_mon_cols + 1 ] ) < s_stat.st_mtime ) { b_skip = false; break; } else { b_skip = true; break; } } msg_Dbg( p_ml , "Checking if %s is in DB. Found: %d", psz_encoded_uri, b_skip? 1 : 0 ); if( b_skip ) continue; p_input = input_item_New( psz_encoded_uri, psz_entry ); playlist_t* p_pl = pl_Get( p_mon ); preparsed_item_t* p_itemobject; p_itemobject = malloc( sizeof( preparsed_item_t ) ); p_itemobject->i_dir_id = i_dir_id; p_itemobject->psz_uri = psz_encoded_uri; p_itemobject->i_mtime = s_stat.st_mtime; p_itemobject->p_mon = p_mon; p_itemobject->b_update = b_update; p_itemobject->i_update_id = b_update ? atoi( ppsz_monitored_files[ j * i_mon_cols + 0 ] ) : 0 ; vlc_event_manager_t *p_em = &p_input->event_manager; vlc_event_attach( p_em, vlc_InputItemPreparsedChanged, PreparseComplete, p_itemobject ); playlist_PreparseEnqueue( p_pl, p_input ); } else if( S_ISDIR( s_stat.st_mode ) && b_recursive ) { Query( p_ml, &pp_results, &i_rows, &i_cols, "SELECT id AS directory_id FROM directories " "WHERE uri=%Q", psz_uri ); FreeSQLResult( p_ml, pp_results ); if( i_rows <= 0 ) { msg_Dbg( p_mon, "New directory `%s' in dir of id %d", psz_uri, i_dir_id ); QuerySimple( p_ml, "INSERT INTO directories (uri, timestamp, " "recursive) VALUES(%Q, 0, 1)", psz_uri ); // We get the id of the directory we've just added Query( p_ml, &pp_results, &i_rows, &i_cols, "SELECT id AS directory_id FROM directories WHERE uri=%Q", psz_uri ); if( i_rows <= 0 ) { msg_Err( p_mon, "Directory `%s' was not sucessfully" " added to the database", psz_uri ); FreeSQLResult( p_ml, pp_results ); continue; } ScanFiles( p_mon, atoi( pp_results[1] ), b_recursive, &stself ); FreeSQLResult( p_ml, pp_results ); } } } } vlc_array_t* delete_ids = vlc_array_new(); for( i = 0; i < i_mon_rows; i++ ) { if( !pb_processed[i] ) { /* This file doesn't exist anymore. Let's...urm...delete it. */ ml_element_t* find = ( ml_element_t* ) calloc( 1, sizeof( ml_element_t ) ); find->criteria = ML_ID; find->value.i = atoi( ppsz_monitored_files[ (i + 1) * i_mon_cols ] ); vlc_array_append( delete_ids, find ); } } /* Delete the unfound media */ if( Delete( p_ml, delete_ids ) != VLC_SUCCESS ) msg_Dbg( p_ml, "Something went wrong in multi delete" ); for( i = 0; i < vlc_array_count( delete_ids ); i++ ) { free( vlc_array_item_at_index( delete_ids, i ) ); } vlc_array_destroy( delete_ids ); FreeSQLResult( p_ml, ppsz_monitored_files ); for( i = 0; i < i_dir_content; i++ ) free( pp_dir_content[i] ); free( pp_dir_content ); free( psz_dir ); free( pb_processed ); }
static int Open( vlc_object_t *p_this ) { intf_thread_t *p_intf = (intf_thread_t*)p_this; /* initialisation of the connection */ if( !dbus_threads_init_default() ) return VLC_EGENERIC; intf_sys_t *p_sys = calloc( 1, sizeof( intf_sys_t ) ); if( unlikely(!p_sys) ) return VLC_ENOMEM; playlist_t *p_playlist; DBusConnection *p_conn; p_sys->i_player_caps = PLAYER_CAPS_NONE; p_sys->i_playing_state = PLAYBACK_STATE_INVALID; if( vlc_pipe( p_sys->p_pipe_fds ) ) { free( p_sys ); msg_Err( p_intf, "Could not create pipe" ); return VLC_EGENERIC; } DBusError error; dbus_error_init( &error ); /* connect privately to the session bus * the connection will not be shared with other vlc modules which use dbus, * thus avoiding a whole class of concurrency issues */ p_conn = dbus_bus_get_private( DBUS_BUS_SESSION, &error ); if( !p_conn ) { msg_Err( p_this, "Failed to connect to the D-Bus session daemon: %s", error.message ); dbus_error_free( &error ); vlc_close( p_sys->p_pipe_fds[1] ); vlc_close( p_sys->p_pipe_fds[0] ); free( p_sys ); return VLC_EGENERIC; } dbus_connection_set_exit_on_disconnect( p_conn, FALSE ); /* Register the entry point object path */ dbus_connection_register_object_path( p_conn, DBUS_MPRIS_OBJECT_PATH, &dbus_mpris_vtable, p_this ); /* Try to register org.mpris.MediaPlayer2.vlc */ dbus_bus_request_name( p_conn, DBUS_MPRIS_BUS_NAME, 0, &error ); if( dbus_error_is_set( &error ) ) { msg_Dbg( p_this, "Failed to get service name %s: %s", DBUS_MPRIS_BUS_NAME, error.message ); dbus_error_free( &error ); /* Register an instance-specific well known name of the form * org.mpris.MediaPlayer2.vlc.instanceXXXX where XXXX is the * current Process ID */ char unique_service[sizeof( DBUS_MPRIS_BUS_NAME ) + sizeof( DBUS_INSTANCE_ID_PREFIX ) + 10]; snprintf( unique_service, sizeof (unique_service), DBUS_MPRIS_BUS_NAME"."DBUS_INSTANCE_ID_PREFIX"%"PRIu32, (uint32_t)getpid() ); dbus_bus_request_name( p_conn, unique_service, 0, &error ); if( dbus_error_is_set( &error ) ) { msg_Err( p_this, "Failed to get service name %s: %s", DBUS_MPRIS_BUS_NAME, error.message ); dbus_error_free( &error ); } else msg_Dbg( p_intf, "listening on dbus as: %s", unique_service ); } else msg_Dbg( p_intf, "listening on dbus as: %s", DBUS_MPRIS_BUS_NAME ); dbus_connection_flush( p_conn ); p_intf->p_sys = p_sys; p_sys->p_conn = p_conn; p_sys->p_events = vlc_array_new(); p_sys->p_timeouts = vlc_array_new(); p_sys->p_watches = vlc_array_new(); vlc_mutex_init( &p_sys->lock ); p_playlist = pl_Get( p_intf ); p_sys->p_playlist = p_playlist; var_AddCallback( p_playlist, "input-current", AllCallback, p_intf ); var_AddCallback( p_playlist, "volume", AllCallback, p_intf ); var_AddCallback( p_playlist, "mute", AllCallback, p_intf ); var_AddCallback( p_playlist, "playlist-item-append", AllCallback, p_intf ); var_AddCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf ); var_AddCallback( p_playlist, "random", AllCallback, p_intf ); var_AddCallback( p_playlist, "repeat", AllCallback, p_intf ); var_AddCallback( p_playlist, "loop", AllCallback, p_intf ); var_AddCallback( p_playlist, "fullscreen", AllCallback, p_intf ); if( !dbus_connection_set_timeout_functions( p_conn, add_timeout, remove_timeout, toggle_timeout, p_intf, NULL ) ) goto error; if( !dbus_connection_set_watch_functions( p_conn, add_watch, remove_watch, watch_toggled, p_intf, NULL ) ) goto error; if( vlc_clone( &p_sys->thread, Run, p_intf, VLC_THREAD_PRIORITY_LOW ) ) goto error; return VLC_SUCCESS; error: /* The dbus connection is private, * so we are responsible for closing it * XXX: Does this make sense when OOM ? */ dbus_connection_close( p_sys->p_conn ); dbus_connection_unref( p_conn ); vlc_array_destroy( p_sys->p_events ); vlc_array_destroy( p_sys->p_timeouts ); vlc_array_destroy( p_sys->p_watches ); vlc_mutex_destroy( &p_sys->lock ); vlc_close( p_sys->p_pipe_fds[1] ); vlc_close( p_sys->p_pipe_fds[0] ); free( p_sys ); return VLC_ENOMEM; }