int MediaLibrary::listAlbums( int listQuery, const medialibrary::QueryParameters* paramsPtr,
const char* pattern, uint32_t nbItems, uint32_t offset, va_list args )
{
auto album = m_ml->album( va_arg( args, int64_t ) );
if ( album == nullptr )
return VLC_EGENERIC;
switch ( listQuery )
{
case VLC_ML_LIST_ALBUM_TRACKS:
case VLC_ML_COUNT_ALBUM_TRACKS:
{
medialibrary::Query<medialibrary::IMedia> query;
if ( pattern != nullptr )
query = album->searchTracks( pattern, paramsPtr );
else
query = album->tracks( paramsPtr );
if ( query == nullptr )
return VLC_EGENERIC;
switch ( listQuery )
{
case VLC_ML_LIST_ALBUM_TRACKS:
*va_arg( args, vlc_ml_media_list_t**) =
ml_convert_list<vlc_ml_media_list_t, vlc_ml_media_t>(
query->items( nbItems, offset ) );
return VLC_SUCCESS;
case VLC_ML_COUNT_ALBUM_TRACKS:
*va_arg( args, size_t* ) = query->count();
return VLC_SUCCESS;
default:
vlc_assert_unreachable();
}
}
case VLC_ML_LIST_ALBUM_ARTISTS:
case VLC_ML_COUNT_ALBUM_ARTISTS:
{
auto query = album->artists( paramsPtr );
if ( query == nullptr )
return VLC_EGENERIC;
switch ( listQuery )
{
case VLC_ML_LIST_ALBUM_ARTISTS:
*va_arg( args, vlc_ml_artist_list_t**) =
ml_convert_list<vlc_ml_artist_list_t, vlc_ml_artist_t>(
query->items( nbItems, offset ) );
return VLC_SUCCESS;
case VLC_ML_COUNT_ALBUM_ARTISTS:
*va_arg( args, size_t* ) = query->count();
return VLC_SUCCESS;
default:
vlc_assert_unreachable();
}
}
default:
vlc_assert_unreachable();
}
}
void vlc_event_detach( vlc_event_manager_t *p_em,
vlc_event_type_t event_type,
vlc_event_callback_t pf_callback,
void *p_user_data )
{
vlc_event_listeners_group_t *slot = &p_em->events[event_type];
vlc_mutex_lock( &p_em->lock );
for (int i = 0; i < slot->listeners.i_size; ++i)
{
struct vlc_event_listener_t *listener = slot->listeners.p_elems[i];
if( listener->pf_callback == pf_callback &&
listener->p_user_data == p_user_data )
{
/* that's our listener */
ARRAY_REMOVE( slot->listeners, i );
vlc_mutex_unlock( &p_em->lock );
free( listener );
return;
}
}
vlc_assert_unreachable();
}
static int Control(vout_display_t *vd, int query, va_list ap)
{
vout_display_sys_t *sys = vd->sys;
switch (query) {
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
case VOUT_DISPLAY_CHANGE_ZOOM:
case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
case VOUT_DISPLAY_CHANGE_SOURCE_CROP: {
const vout_display_cfg_t *cfg = va_arg(ap,
const vout_display_cfg_t *);
/* Update the window size */
uint32_t mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
const uint32_t values[] = {
cfg->display.width, cfg->display.height
};
xcb_configure_window(sys->conn, sys->drawable.dest, mask, values);
DeleteBuffers(vd);
CreateBuffers(vd, cfg);
xcb_flush(sys->conn);
return VLC_SUCCESS;
}
case VOUT_DISPLAY_RESET_PICTURES:
vlc_assert_unreachable();
default:
msg_Err(vd, "Unknown request in XCB RENDER display");
return VLC_EGENERIC;
}
}
static void* Raw1394EventThread( void *obj )
{
event_thread_t *p_ev = (event_thread_t *)obj;
access_t *p_access = (access_t *) p_ev->p_access;
access_sys_t *p_sys = (access_sys_t *) p_access->p_sys;
int result = 0;
int canc = vlc_savecancel();
AVCPlay( p_access, p_sys->i_node );
vlc_cleanup_push( Raw1394EventThreadCleanup, p_ev );
vlc_restorecancel( canc );
for( ;; )
{
while( ( result = poll( &p_sys->raw1394_poll, 1, -1 ) ) < 0 )
{
if( errno != EINTR )
msg_Err( p_access, "poll error: %s", vlc_strerror_c(errno) );
}
if( result > 0 && ( ( p_sys->raw1394_poll.revents & POLLIN )
|| ( p_sys->raw1394_poll.revents & POLLPRI ) ) )
{
canc = vlc_savecancel();
result = raw1394_loop_iterate( p_sys->p_raw1394 );
vlc_restorecancel( canc );
}
}
vlc_cleanup_pop();
vlc_assert_unreachable();
}
/**
* Finds the value of a variable. If the specified object does not hold a
* variable with the specified name, try the parent object, and iterate until
* the top of the tree. If no match is found, the value is read from the
* configuration.
*/
int var_Inherit( vlc_object_t *p_this, const char *psz_name, int i_type,
vlc_value_t *p_val )
{
i_type &= VLC_VAR_CLASS;
for( vlc_object_t *obj = p_this; obj != NULL; obj = obj->obj.parent )
{
if( var_GetChecked( obj, psz_name, i_type, p_val ) == VLC_SUCCESS )
return VLC_SUCCESS;
}
/* else take value from config */
switch( i_type & VLC_VAR_CLASS )
{
case VLC_VAR_STRING:
p_val->psz_string = config_GetPsz( p_this, psz_name );
if( !p_val->psz_string ) p_val->psz_string = strdup("");
break;
case VLC_VAR_FLOAT:
p_val->f_float = config_GetFloat( p_this, psz_name );
break;
case VLC_VAR_INTEGER:
p_val->i_int = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_BOOL:
p_val->b_bool = config_GetInt( p_this, psz_name );
break;
default:
vlc_assert_unreachable();
case VLC_VAR_ADDRESS:
return VLC_ENOOBJ;
}
return VLC_SUCCESS;
}
void ExtendedDialog::saveConfig()
{
assert( currentTab() == AUDIO_TAB || currentTab() == VIDEO_TAB );
QHash<QString, QVariant> *hashConfig = &m_hashConfigs[currentTab()];
for( QHash<QString, QVariant>::iterator i = hashConfig->begin();
i != hashConfig->end(); ++i )
{
QVariant &value = i.value();
switch( static_cast<QMetaType::Type>(value.type()) )
{
case QMetaType::QString:
config_PutPsz( p_intf, qtu(i.key()), qtu(value.toString()) );
break;
case QMetaType::Int:
config_PutInt( p_intf, qtu(i.key()), value.toInt() ) ;
break;
case QMetaType::Double:
case QMetaType::Float:
config_PutFloat( p_intf, qtu(i.key()), value.toFloat() ) ;
break;
default:
vlc_assert_unreachable();
}
}
config_SaveConfigFile( p_intf );
hashConfig->clear();
m_applyButton->setEnabled( false );
}
medialibrary::SortingCriteria MediaLibrary::sortingCriteria(int sort)
{
switch ( sort )
{
case VLC_ML_SORTING_DEFAULT:
return medialibrary::SortingCriteria::Default;
case VLC_ML_SORTING_ALPHA:
return medialibrary::SortingCriteria::Alpha;
case VLC_ML_SORTING_DURATION:
return medialibrary::SortingCriteria::Duration;
case VLC_ML_SORTING_INSERTIONDATE:
return medialibrary::SortingCriteria::InsertionDate;
case VLC_ML_SORTING_LASTMODIFICATIONDATE:
return medialibrary::SortingCriteria::LastModificationDate;
case VLC_ML_SORTING_RELEASEDATE:
return medialibrary::SortingCriteria::ReleaseDate;
case VLC_ML_SORTING_FILESIZE:
return medialibrary::SortingCriteria::FileSize;
case VLC_ML_SORTING_ARTIST:
return medialibrary::SortingCriteria::Artist;
case VLC_ML_SORTING_PLAYCOUNT:
return medialibrary::SortingCriteria::PlayCount;
case VLC_ML_SORTING_ALBUM:
return medialibrary::SortingCriteria::Album;
case VLC_ML_SORTING_FILENAME:
return medialibrary::SortingCriteria::Filename;
case VLC_ML_SORTING_TRACKNUMBER:
return medialibrary::SortingCriteria::TrackNumber;
default:
vlc_assert_unreachable();
}
}
char *config_GetUserDir (vlc_userdir_t type)
{
switch (type)
{
case VLC_HOME_DIR:
return config_GetShellDir (CSIDL_PERSONAL);
case VLC_CONFIG_DIR:
case VLC_DATA_DIR:
case VLC_CACHE_DIR:
return config_GetAppDir ();
case VLC_DESKTOP_DIR:
case VLC_DOWNLOAD_DIR:
case VLC_TEMPLATES_DIR:
case VLC_PUBLICSHARE_DIR:
case VLC_DOCUMENTS_DIR:
return config_GetUserDir(VLC_HOME_DIR);
case VLC_MUSIC_DIR:
return config_GetShellDir (CSIDL_MYMUSIC);
case VLC_PICTURES_DIR:
return config_GetShellDir (CSIDL_MYPICTURES);
case VLC_VIDEOS_DIR:
return config_GetShellDir (CSIDL_MYVIDEO);
}
vlc_assert_unreachable ();
}
/** Background thread for Wayland shell events handling */
static void *Thread(void *data)
{
vout_window_t *wnd = data;
struct wl_display *display = wnd->display.wl;
struct pollfd ufd[1];
int canc = vlc_savecancel();
vlc_cleanup_push(cleanup_wl_display_read, display);
ufd[0].fd = wl_display_get_fd(display);
ufd[0].events = POLLIN;
for (;;)
{
while (wl_display_prepare_read(display) != 0)
wl_display_dispatch_pending(display);
wl_display_flush(display);
vlc_restorecancel(canc);
while (poll(ufd, 1, -1) < 0);
canc = vlc_savecancel();
wl_display_read_events(display);
wl_display_dispatch_pending(display);
}
vlc_assert_unreachable();
vlc_cleanup_pop();
//vlc_restorecancel(canc);
//return NULL;
}
static uint16_t get_data_type( filter_t *p_filter, block_t *p_in )
{
#define IEC61937_AC3 0x01
#define IEC61937_DTS1 0x0B
#define IEC61937_DTS2 0x0C
#define IEC61937_DTS3 0x0D
switch( p_filter->fmt_in.audio.i_format )
{
case VLC_CODEC_A52:
if( unlikely( p_in->i_buffer < 6
|| p_in->i_nb_samples != A52_FRAME_NB ) )
return 0;
return ( (p_in->p_buffer[5] & 0x7) << 8 ) /* bsmod */ | IEC61937_AC3;
case VLC_CODEC_DTS:
if( unlikely( p_in->i_buffer < 1 ) )
return 0;
switch( p_in->i_nb_samples )
{
case 512: return IEC61937_DTS1;
case 1024: return IEC61937_DTS2;
case 2048: return IEC61937_DTS3;
default:
msg_Err( p_filter, "Frame size %d not supported",
p_in->i_nb_samples );
return 0;
}
default:
vlc_assert_unreachable();
}
return 0;
}
static void DelCallback( vlc_object_t *p_this, const char *psz_name,
callback_entry_t entry, vlc_callback_type_t i_type )
{
int i_entry;
variable_t *p_var;
#ifndef NDEBUG
bool b_found_similar = false;
#endif
assert( p_this );
vlc_object_internals_t *p_priv = vlc_internals( p_this );
p_var = Lookup( p_this, psz_name );
if( p_var == NULL )
{
vlc_mutex_unlock( &p_priv->var_lock );
msg_Err( p_this, "cannot delete callback %p from nonexistent "
"variable '%s'", entry.p_callback, psz_name );
return;
}
WaitUnused( p_this, p_var );
callback_table_t *p_table;
if (i_type == vlc_value_callback)
p_table = &p_var->value_callbacks;
else
p_table = &p_var->list_callbacks;
for( i_entry = p_table->i_entries ; i_entry-- ; )
{
if( p_table->p_entries[i_entry].p_callback == entry.p_callback
&& p_table->p_entries[i_entry].p_data == entry.p_data )
{
break;
}
#ifndef NDEBUG
else if( p_table->p_entries[i_entry].p_callback == entry.p_callback )
b_found_similar = true;
#endif
}
if( i_entry < 0 )
{
#ifndef NDEBUG
if( b_found_similar )
fprintf( stderr, "Calling var_DelCallback for '%s' with the same "
"function but not the same data.", psz_name );
vlc_assert_unreachable();
#endif
vlc_mutex_unlock( &p_priv->var_lock );
return;
}
TAB_ERASE(p_table->i_entries, p_table->p_entries, i_entry);
vlc_mutex_unlock( &p_priv->var_lock );
}
static int tt_node_Skip( xml_reader_t *p_reader, const char *psz_skipped )
{
size_t i_depth = 1;
const char *psz_cur;
/* need a copy as psz_skipped would point to next node after NextNode */
char *psz_skip = strdup( psz_skipped );
if(!psz_skip)
return VLC_EGENERIC;
for( ;; )
{
int i_type = xml_ReaderNextNode( p_reader, &psz_cur );
switch( i_type )
{
case XML_READER_STARTELEM:
if( i_depth == SIZE_MAX )
{
free( psz_skip );
return VLC_EGENERIC;
}
if( !xml_ReaderIsEmptyElement( p_reader ) )
i_depth++;
break;
case XML_READER_ENDELEM:
if( !strcmp( psz_cur, psz_skip ) )
{
free( psz_skip );
if( i_depth != 1 )
return VLC_EGENERIC;
return VLC_SUCCESS;
}
else
{
if( i_depth == 1 )
{
free( psz_skip );
return VLC_EGENERIC;
}
i_depth--;
}
break;
default:
if( i_type <= XML_READER_NONE )
{
free( psz_skip );
return VLC_EGENERIC;
}
break;
}
}
vlc_assert_unreachable();
return VLC_EGENERIC;
}
/*****************************************************************************
* Run: Thread entry-point
****************************************************************************/
static void* Run( void *data )
{
services_discovery_t *p_sd = ( services_discovery_t * )data;
services_discovery_sys_t *p_sys = p_sd->p_sys;
lua_State *L = p_sys->L;
int cancel = vlc_savecancel();
lua_getglobal( L, "main" );
if( !lua_isfunction( L, lua_gettop( L ) ) || lua_pcall( L, 0, 1, 0 ) )
{
msg_Err( p_sd, "Error while running script %s, "
"function main(): %s", p_sys->psz_filename,
lua_tostring( L, lua_gettop( L ) ) );
lua_pop( L, 1 );
vlc_restorecancel( cancel );
return NULL;
}
msg_Dbg( p_sd, "LuaSD script loaded: %s", p_sys->psz_filename );
/* Force garbage collection, because the core will keep the SD
* open, but lua will never gc until lua_close(). */
lua_gc( L, LUA_GCCOLLECT, 0 );
vlc_restorecancel( cancel );
/* Main loop to handle search requests */
vlc_mutex_lock( &p_sys->lock );
mutex_cleanup_push( &p_sys->lock );
for( ;; )
{
/* Wait for a request */
if( !p_sys->i_query )
{
vlc_cond_wait( &p_sys->cond, &p_sys->lock );
continue;
}
/* Execute one query (protected against cancellation) */
char *psz_query = p_sys->ppsz_query[p_sys->i_query - 1];
TAB_ERASE(p_sys->i_query, p_sys->ppsz_query, p_sys->i_query - 1);
vlc_mutex_unlock( &p_sys->lock );
cancel = vlc_savecancel();
DoSearch( p_sd, psz_query );
free( psz_query );
/* Force garbage collection, because the core will keep the SD
* open, but lua will never gc until lua_close(). */
lua_gc( L, LUA_GCCOLLECT, 0 );
vlc_restorecancel( cancel );
vlc_mutex_lock( &p_sys->lock );
}
vlc_cleanup_pop();
vlc_assert_unreachable();
}
// Get all the callbacks
static int AllCallback( vlc_object_t *p_this, const char *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
intf_thread_t *p_intf = p_data;
callback_info_t info = { .signal = SIGNAL_NONE };
// Wich event is it ?
if( !strcmp( "input-current", psz_var ) )
info.signal = SIGNAL_ITEM_CURRENT;
else if( !strcmp( "volume", psz_var ) )
{
if( oldval.f_float != newval.f_float )
info.signal = SIGNAL_VOLUME_CHANGE;
}
else if( !strcmp( "mute", psz_var ) )
{
if( oldval.b_bool != newval.b_bool )
info.signal = SIGNAL_VOLUME_MUTED;
}
else if( !strcmp( "playlist-item-append", psz_var ) )
info.signal = SIGNAL_PLAYLIST_ITEM_APPEND;
else if( !strcmp( "playlist-item-deleted", psz_var ) )
info.signal = SIGNAL_PLAYLIST_ITEM_DELETED;
else if( !strcmp( "random", psz_var ) )
info.signal = SIGNAL_RANDOM;
else if( !strcmp( "fullscreen", psz_var ) )
info.signal = SIGNAL_FULLSCREEN;
else if( !strcmp( "repeat", psz_var ) )
info.signal = SIGNAL_REPEAT;
else if( !strcmp( "loop", psz_var ) )
info.signal = SIGNAL_LOOP;
else if( !strcmp( "can-seek", psz_var ) )
info.signal = SIGNAL_CAN_SEEK;
else if( !strcmp( "can-pause", psz_var ) )
info.signal = SIGNAL_CAN_PAUSE;
else
vlc_assert_unreachable();
if( info.signal == SIGNAL_NONE )
return VLC_SUCCESS;
callback_info_t *p_info = malloc( sizeof( *p_info ) );
if( unlikely(p_info == NULL) )
return VLC_ENOMEM;
// Append the event
*p_info = info;
vlc_mutex_lock( &p_intf->p_sys->lock );
vlc_array_append( p_intf->p_sys->p_events, p_info );
vlc_mutex_unlock( &p_intf->p_sys->lock );
wakeup_main_loop( p_intf );
(void) p_this;
return VLC_SUCCESS;
}
static int Control(vout_display_t *vd, int query, va_list args)
{
switch (query) {
case VOUT_DISPLAY_RESET_PICTURES:
vlc_assert_unreachable();
return VLC_EGENERIC;
default:
return CommonControl(vd, query, args);
}
}
static bool is_big_endian( filter_t *p_filter, block_t *p_in )
{
switch( p_filter->fmt_in.audio.i_format )
{
case VLC_CODEC_A52:
return true;
case VLC_CODEC_DTS:
return p_in->p_buffer[0] == 0x1F || p_in->p_buffer[0] == 0x7F;
default:
vlc_assert_unreachable();
}
return 0;
}
int Open(vlc_object_t *p_this)
{
decoder_t *p_dec = (decoder_t *)p_this;
decoder_sys_t *p_sys;
if (p_dec->fmt_in.i_cat != VIDEO_ES && p_dec->fmt_in.i_cat != AUDIO_ES)
return VLC_EGENERIC;
p_sys = p_dec->p_sys = calloc(1, sizeof(*p_sys));
if (!p_sys)
return VLC_ENOMEM;
if( FAILED(CoInitializeEx(NULL, COINIT_MULTITHREADED)) )
vlc_assert_unreachable();
if (LoadMFTLibrary(&p_sys->mf_handle))
{
msg_Err(p_dec, "Failed to load MFT library.");
goto error;
}
if (FindMFT(p_dec))
{
msg_Err(p_dec, "Could not find suitable MFT decoder");
goto error;
}
/* Only one output sample is needed, we can allocate one and reuse it. */
if (AllocateOutputSample(p_dec, 0, &p_sys->output_sample))
goto error;
if (p_sys->is_async)
{
p_dec->pf_decode_video = (picture_t *(*)(decoder_t *, block_t **))DecodeAsync;
p_dec->pf_decode_audio = (block_t *(*)(decoder_t *, block_t **))DecodeAsync;
}
else
{
p_dec->pf_decode_video = (picture_t *(*)(decoder_t *, block_t **))DecodeSync;
p_dec->pf_decode_audio = (block_t *(*)(decoder_t *, block_t **))DecodeSync;
}
p_dec->fmt_out.i_cat = p_dec->fmt_in.i_cat;
p_dec->b_need_packetized = true;
return VLC_SUCCESS;
error:
Close(p_this);
return VLC_EGENERIC;
}
int libvlc_media_slaves_add( libvlc_media_t *p_md,
libvlc_media_slave_type_t i_type,
unsigned int i_priority,
const char *psz_uri )
{
assert( p_md && psz_uri );
input_item_t *p_input_item = p_md->p_input_item;
enum slave_type i_input_slave_type;
switch( i_type )
{
case libvlc_media_slave_type_subtitle:
i_input_slave_type = SLAVE_TYPE_SPU;
break;
case libvlc_media_slave_type_audio:
i_input_slave_type = SLAVE_TYPE_AUDIO;
break;
default:
vlc_assert_unreachable();
return -1;
}
enum slave_priority i_input_slave_priority;
switch( i_priority )
{
case 0:
i_input_slave_priority = SLAVE_PRIORITY_MATCH_NONE;
break;
case 1:
i_input_slave_priority = SLAVE_PRIORITY_MATCH_RIGHT;
break;
case 2:
i_input_slave_priority = SLAVE_PRIORITY_MATCH_LEFT;
break;
case 3:
i_input_slave_priority = SLAVE_PRIORITY_MATCH_ALL;
break;
default:
case 4:
i_input_slave_priority = SLAVE_PRIORITY_USER;
break;
}
input_item_slave_t *p_slave = input_item_slave_New( psz_uri,
i_input_slave_type,
i_input_slave_priority );
if( p_slave == NULL )
return -1;
return input_item_AddSlave( p_input_item, p_slave ) == VLC_SUCCESS ? 0 : -1;
}
int PLItem::id( int type )
{
switch( type )
{
case INPUTITEM_ID:
return inputItem()->i_id;
case PLAYLIST_ID:
return i_playlist_id;
default:
case MLMEDIA_ID:
vlc_assert_unreachable();
return -1;
}
}
/*****************************************************************************
* Run: main thread
*****************************************************************************/
VLC_NORETURN
static void *Run( void *data )
{
services_discovery_t *p_sd = data;
services_discovery_sys_t *p_sys = p_sd->p_sys;
vlc_mutex_lock( &p_sys->lock );
mutex_cleanup_push( &p_sys->lock );
for( ;; )
{
while( !p_sys->b_update )
vlc_cond_wait( &p_sys->wait, &p_sys->lock );
int canc = vlc_savecancel ();
msg_Dbg( p_sd, "Update required" );
if( p_sys->update_type == UPDATE_URLS )
{
char *psz_urls = var_GetNonEmptyString( p_sd->p_parent,
"podcast-urls" );
ParseUrls( p_sd, psz_urls );
free( psz_urls );
}
else if( p_sys->update_type == UPDATE_REQUEST )
ParseRequest( p_sd );
p_sys->b_update = false;
for( int i = 0; i < p_sd->p_sys->i_input; i++ )
{
input_thread_t *p_input = p_sd->p_sys->pp_input[i];
int state = var_GetInteger( p_input, "state" );
if( state == END_S || state == ERROR_S )
{
input_Stop( p_input );
input_Close( p_input );
p_sd->p_sys->pp_input[i] = NULL;
REMOVE_ELEM( p_sys->pp_input, p_sys->i_input, i );
i--;
}
}
vlc_restorecancel (canc);
}
vlc_cleanup_pop();
vlc_assert_unreachable(); /* dead code */
}
void* MediaLibrary::Get( int query, int64_t id )
{
if ( Start() == false )
return nullptr;
switch ( query )
{
case VLC_ML_GET_MEDIA:
{
auto media = m_ml->media( id );
return CreateAndConvert<vlc_ml_media_t>( media.get() );
}
case VLC_ML_GET_INPUT_ITEM:
{
auto media = m_ml->media( id );
return MediaToInputItem( media.get() );
}
case VLC_ML_GET_ALBUM:
{
auto album = m_ml->album( id );
return CreateAndConvert<vlc_ml_album_t>( album.get() );
}
case VLC_ML_GET_ARTIST:
{
auto artist = m_ml->artist( id );
return CreateAndConvert<vlc_ml_artist_t>( artist.get() );
}
case VLC_ML_GET_GENRE:
{
auto genre = m_ml->genre( id );
return CreateAndConvert<vlc_ml_genre_t>( genre.get() );
}
case VLC_ML_GET_SHOW:
{
auto show = m_ml->show( id );
return CreateAndConvert<vlc_ml_show_t>( show.get() );
}
case VLC_ML_GET_PLAYLIST:
{
auto playlist = m_ml->playlist( id );
return CreateAndConvert<vlc_ml_playlist_t>( playlist.get() );
}
default:
vlc_assert_unreachable();
}
return nullptr;
}
static block_t *DoWork( filter_t *p_filter, block_t *p_in_buf )
{
filter_sys_t *p_sys = p_filter->p_sys;
block_t *p_out_buf = NULL;
int i_ret;
switch( p_filter->fmt_in.audio.i_format )
{
case VLC_CODEC_A52:
i_ret = write_buffer_ac3( p_filter, p_in_buf );
break;
case VLC_CODEC_EAC3:
i_ret = write_buffer_eac3( p_filter, p_in_buf );
break;
case VLC_CODEC_MLP:
case VLC_CODEC_TRUEHD:
i_ret = write_buffer_truehd( p_filter, p_in_buf );
break;
case VLC_CODEC_DTS:
/* if the fmt_out is configured for a higher rate than 48kHz
* (IEC958 rate), use the DTS-HD framing to pass the DTS Core and
* or DTS substreams (like DTS-HD MA). */
if( p_filter->fmt_out.audio.i_rate > 48000 )
i_ret = write_buffer_dtshd( p_filter, p_in_buf );
else
i_ret = write_buffer_dts( p_filter, p_in_buf );
break;
default:
vlc_assert_unreachable();
}
switch( i_ret )
{
case SPDIF_SUCCESS:
assert( p_sys->p_out_buf->i_buffer == p_sys->i_out_offset );
p_out_buf = p_sys->p_out_buf;
p_sys->p_out_buf = NULL;
break;
case SPDIF_MORE_DATA:
break;
case SPDIF_ERROR:
Flush( p_filter );
break;
}
block_Release( p_in_buf );
return p_out_buf;
}
VLC_NORETURN
static void *vlc_timer_thread (void *data)
{
struct vlc_timer *timer = data;
vlc_mutex_lock (&timer->lock);
mutex_cleanup_push (&timer->lock);
for (;;)
{
while (timer->value == 0)
vlc_cond_wait (&timer->reschedule, &timer->lock);
if (vlc_cond_timedwait (&timer->reschedule, &timer->lock,
timer->value) == 0)
continue;
if (timer->interval == 0)
timer->value = 0; /* disarm */
vlc_mutex_unlock (&timer->lock);
int canc = vlc_savecancel ();
timer->func (timer->data);
vlc_restorecancel (canc);
mtime_t now = mdate ();
unsigned misses;
vlc_mutex_lock (&timer->lock);
if (timer->interval == 0)
continue;
misses = (now - timer->value) / timer->interval;
timer->value += timer->interval;
/* Try to compensate for one miss (mwait() will return immediately)
* but no more. Otherwise, we might busy loop, after extended periods
* without scheduling (suspend, SIGSTOP, RT preemption, ...). */
if (misses > 1)
{
misses--;
timer->value += misses * timer->interval;
atomic_fetch_add_explicit (&timer->overruns, misses,
memory_order_relaxed);
}
}
vlc_cleanup_pop ();
vlc_assert_unreachable ();
}
static void
vlc_chroma_to_vaapi(int i_vlc_chroma, unsigned *va_rt_format, int *va_fourcc)
{
switch (i_vlc_chroma)
{
case VLC_CODEC_VAAPI_420:
*va_rt_format = VA_RT_FORMAT_YUV420;
*va_fourcc = VA_FOURCC_NV12;
break;
case VLC_CODEC_VAAPI_420_10BPP:
*va_rt_format = VA_RT_FORMAT_YUV420_10BPP;
*va_fourcc = VA_FOURCC_P010;
break;
default:
vlc_assert_unreachable();
}
}
medialibrary::IMedia::MetadataType MediaLibrary::metadataType( int meta )
{
switch ( meta )
{
case VLC_ML_PLAYBACK_PREF_RATING:
return medialibrary::IMedia::MetadataType::Rating;
case VLC_ML_PLAYBACK_PREF_PROGRESS:
return medialibrary::IMedia::MetadataType::Progress;
case VLC_ML_PLAYBACK_PREF_SPEED:
return medialibrary::IMedia::MetadataType::Speed;
case VLC_ML_PLAYBACK_PREF_TITLE:
return medialibrary::IMedia::MetadataType::Title;
case VLC_ML_PLAYBACK_PREF_CHAPTER:
return medialibrary::IMedia::MetadataType::Chapter;
case VLC_ML_PLAYBACK_PREF_PROGRAM:
return medialibrary::IMedia::MetadataType::Program;
case VLC_ML_PLAYBACK_PREF_SEEN:
return medialibrary::IMedia::MetadataType::Seen;
case VLC_ML_PLAYBACK_PREF_VIDEO_TRACK:
return medialibrary::IMedia::MetadataType::VideoTrack;
case VLC_ML_PLAYBACK_PREF_ASPECT_RATIO:
return medialibrary::IMedia::MetadataType::AspectRatio;
case VLC_ML_PLAYBACK_PREF_ZOOM:
return medialibrary::IMedia::MetadataType::Zoom;
case VLC_ML_PLAYBACK_PREF_CROP:
return medialibrary::IMedia::MetadataType::Crop;
case VLC_ML_PLAYBACK_PREF_DEINTERLACE:
return medialibrary::IMedia::MetadataType::Deinterlace;
case VLC_ML_PLAYBACK_PREF_VIDEO_FILTER:
return medialibrary::IMedia::MetadataType::VideoFilter;
case VLC_ML_PLAYBACK_PREF_AUDIO_TRACK:
return medialibrary::IMedia::MetadataType::AudioTrack;
case VLC_ML_PLAYBACK_PREF_GAIN:
return medialibrary::IMedia::MetadataType::Gain;
case VLC_ML_PLAYBACK_PREF_AUDIO_DELAY:
return medialibrary::IMedia::MetadataType::AudioDelay;
case VLC_ML_PLAYBACK_PREF_SUBTITLE_TRACK:
return medialibrary::IMedia::MetadataType::SubtitleTrack;
case VLC_ML_PLAYBACK_PREF_SUBTITLE_DELAY:
return medialibrary::IMedia::MetadataType::SubtitleDelay;
case VLC_ML_PLAYBACK_PREF_APP_SPECIFIC:
return medialibrary::IMedia::MetadataType::ApplicationSpecific;
default:
vlc_assert_unreachable();
}
}
static void *proxy_thread(void *data)
{
int lfd = (intptr_t)data;
for (;;)
{
int cfd = accept4(lfd, NULL, NULL, SOCK_CLOEXEC);
if (cfd == -1)
continue;
int canc = vlc_savecancel();
proxy_client_process(cfd);
close(cfd);
connection_count++;
vlc_restorecancel(canc);
}
vlc_assert_unreachable();
}
static void CommonChangeThumbnailClip(vlc_object_t *obj, vout_display_sys_win32_t *sys, bool show)
{
/* Windows 7 taskbar thumbnail code */
OSVERSIONINFO winVer;
winVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if (!GetVersionEx(&winVer) || winVer.dwMajorVersion <= 5)
return;
if( FAILED(CoInitializeEx(NULL, COINIT_MULTITHREADED)) )
vlc_assert_unreachable();
void *ptr;
if (S_OK == CoCreateInstance(&CLSID_TaskbarList,
NULL, CLSCTX_INPROC_SERVER,
&IID_ITaskbarList3,
&ptr)) {
ITaskbarList3 *taskbl = ptr;
taskbl->lpVtbl->HrInit(taskbl);
HWND hroot = GetAncestor(sys->hvideownd, GA_ROOT);
RECT video;
if (show) {
GetWindowRect(sys->hparent, &video);
POINT client = {video.left, video.top};
if (ScreenToClient(hroot, &client))
{
unsigned int width = RECTWidth(video);
unsigned int height = RECTHeight(video);
video.left = client.x;
video.top = client.y;
video.right = video.left + width;
video.bottom = video.top + height;
}
}
HRESULT hr;
hr = taskbl->lpVtbl->SetThumbnailClip(taskbl, hroot,
show ? &video : NULL);
if ( hr != S_OK )
msg_Err(obj, "SetThumbNailClip failed: 0x%0lx", hr);
taskbl->lpVtbl->Release(taskbl);
}
CoUninitialize();
}
uintmax_t vlc_http_file_get_size(struct vlc_http_file *file)
{
int status = vlc_http_file_get_status(file);
if (status < 0)
return -1;
const char *range = vlc_http_msg_get_header(file->resp, "Content-Range");
if (status == 206 /* Partial Content */)
{ /* IETF RFC7233 §4.1 */
assert(range != NULL); /* checked by vlc_http_file_open() */
uintmax_t end, total;
switch (sscanf(range, "bytes %*u-%ju/%ju", &end, &total))
{
case 1:
if (unlikely(end == UINTMAX_MAX))
return -1; /* avoid wrapping to zero */
return end + 1;
case 2:
return total;
}
vlc_assert_unreachable(); /* checked by vlc_http_file_open() */
}
if (status == 416 /* Range Not Satisfiable */)
{ /* IETF RFC7233 §4.4 */
uintmax_t total;
if (range == NULL)
return -1; /* valid but helpless response */
if (sscanf(range, "bytes */%ju", &total) == 1)
return total; /* this occurs when seeking beyond EOF */
}
if (status >= 300 || status == 201)
return -1; /* Error or redirection, size is unknown/irrelevant. */
/* Content-Range is meaningless here (see RFC7233 B), so check if the size
* of the response entity body is known. */
return vlc_http_msg_get_size(file->resp);
}
static char *getAppDependentDir(vlc_userdir_t type)
{
const char *psz_path;
switch (type) {
case VLC_CONFIG_DIR:
psz_path = "%s/Library/Preferences/%s";
break;
case VLC_TEMPLATES_DIR:
case VLC_DATA_DIR:
psz_path = "%s/Library/Application Support/%s";
break;
case VLC_CACHE_DIR:
psz_path = "%s/Library/Caches/%s";
break;
default:
vlc_assert_unreachable();
break;
}
// Default fallback
const char *name = "org.videolan.vlc";
CFBundleRef mainBundle = CFBundleGetMainBundle();
if (mainBundle) {
CFStringRef identifierAsNS = CFBundleGetIdentifier(mainBundle);
if (identifierAsNS) {
char identifier[256];
Boolean ret = CFStringGetCString(identifierAsNS, identifier, sizeof(identifier), kCFStringEncodingUTF8);
if (ret)
name = identifier;
}
}
char *psz_parent = config_GetHomeDir ();
char *psz_dir;
if ( asprintf( &psz_dir, psz_path, psz_parent, name) == -1 )
psz_dir = NULL;
free(psz_parent);
return psz_dir;
}
int MediaLibrary::listPlaylist( int listQuery, const medialibrary::QueryParameters* paramsPtr,
const char* pattern, uint32_t nbItems, uint32_t offset, va_list args )
{
switch( listQuery )
{
case VLC_ML_LIST_PLAYLISTS:
case VLC_ML_COUNT_PLAYLISTS:
{
medialibrary::Query<medialibrary::IPlaylist> query;
if ( pattern != nullptr )
query = m_ml->searchPlaylists( pattern, paramsPtr );
else
query = m_ml->playlists( paramsPtr );
if ( query == nullptr )
return VLC_EGENERIC;
switch ( listQuery )
{
case VLC_ML_LIST_PLAYLISTS:
*va_arg( args, vlc_ml_playlist_list_t** ) =
ml_convert_list<vlc_ml_playlist_list_t, vlc_ml_playlist_t>(
query->items( nbItems, offset ) );
return VLC_SUCCESS;
case VLC_ML_COUNT_PLAYLISTS:
*va_arg( args, size_t* ) = query->count();
return VLC_SUCCESS;
default:
vlc_assert_unreachable();
}
}
case VLC_ML_LIST_PLAYLIST_MEDIA:
case VLC_ML_COUNT_PLAYLIST_MEDIA:
{
auto playlist = m_ml->playlist( va_arg( args, int64_t ) );
if ( playlist == nullptr )
return VLC_EGENERIC;
medialibrary::Query<medialibrary::IMedia> query;
if ( pattern != nullptr )
query = playlist->searchMedia( pattern, paramsPtr );
else
query = playlist->media();
if ( query == nullptr )
return VLC_EGENERIC;
switch ( listQuery )
{
case VLC_ML_LIST_PLAYLIST_MEDIA:
*va_arg( args, vlc_ml_media_list_t**) =
ml_convert_list<vlc_ml_media_list_t, vlc_ml_media_t>(
query->items( nbItems, offset ) );
return VLC_SUCCESS;
case VLC_ML_COUNT_PLAYLIST_MEDIA:
*va_arg( args, size_t* ) = query->count();
return VLC_SUCCESS;
default:
vlc_assert_unreachable();
}
}
default:
vlc_assert_unreachable();
}
}