/* Enqueue an item for preparsing, and play it, if needed */
static void GoAndPreparse( playlist_t *p_playlist, int i_mode,
playlist_item_t *p_item )
{
PL_ASSERT_LOCKED;
if( (i_mode & PLAYLIST_GO ) )
{
pl_priv(p_playlist)->request.b_request = true;
pl_priv(p_playlist)->request.i_skip = 0;
pl_priv(p_playlist)->request.p_item = p_item;
if( pl_priv(p_playlist)->p_input )
input_Stop( pl_priv(p_playlist)->p_input, true );
pl_priv(p_playlist)->request.i_status = PLAYLIST_RUNNING;
vlc_cond_signal( &pl_priv(p_playlist)->signal );
}
/* Preparse if no artist/album info, and hasn't been preparsed allready
and if user has some preparsing option (auto-preparse variable)
enabled*/
char *psz_artist = input_item_GetArtist( p_item->p_input );
char *psz_album = input_item_GetAlbum( p_item->p_input );
if( pl_priv(p_playlist)->b_auto_preparse &&
input_item_IsPreparsed( p_item->p_input ) == false &&
( EMPTY_STR( psz_artist ) || ( EMPTY_STR( psz_album ) ) )
)
libvlc_MetaRequest( p_playlist->p_libvlc, p_item->p_input );
free( psz_artist );
free( psz_album );
}
/*****************************************************************************
* DoWork: process samples buffer
*****************************************************************************
* This function queues the audio buffer to be processed by the goom thread
*****************************************************************************/
static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter,
aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
{
aout_filter_sys_t *p_sys = p_filter->p_sys;
block_t *p_block;
p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
p_out_buf->i_nb_bytes = p_in_buf->i_nb_bytes;
/* Queue sample */
vlc_mutex_lock( &p_sys->p_thread->lock );
if( p_sys->p_thread->i_blocks == MAX_BLOCKS )
{
vlc_mutex_unlock( &p_sys->p_thread->lock );
return;
}
p_block = block_New( p_sys->p_thread, p_in_buf->i_nb_bytes );
if( !p_block ) return;
memcpy( p_block->p_buffer, p_in_buf->p_buffer, p_in_buf->i_nb_bytes );
p_block->i_pts = p_in_buf->start_date;
p_sys->p_thread->pp_blocks[p_sys->p_thread->i_blocks++] = p_block;
vlc_cond_signal( &p_sys->p_thread->wait );
vlc_mutex_unlock( &p_sys->p_thread->lock );
}
STDMETHODIMP CapturePin::Receive( IMediaSample *pSample )
{
#if 0 //def DEBUG_DSHOW
msg_Dbg( p_input, "CapturePin::Receive" );
#endif
pSample->AddRef();
mtime_t i_timestamp = mdate() * 10;
VLCMediaSample vlc_sample = {pSample, i_timestamp};
vlc_mutex_lock( &p_sys->lock );
samples_queue.push_front( vlc_sample );
/* Make sure we don't cache too many samples */
if( samples_queue.size() > 10 )
{
vlc_sample = samples_queue.back();
samples_queue.pop_back();
msg_Dbg( p_input, "CapturePin::Receive trashing late input sample" );
vlc_sample.p_sample->Release();
}
vlc_cond_signal( &p_sys->wait );
vlc_mutex_unlock( &p_sys->lock );
return S_OK;
}
/**
* @brief Add a directory to monitor
* @param p_ml This media_library_t object
* @param psz_dir the directory to add
* @return VLC_SUCCESS or VLC_EGENERIC
*/
int AddDirToMonitor( media_library_t *p_ml, const char *psz_dir )
{
assert( p_ml );
/* Verify if we can open the directory */
DIR *dir = vlc_opendir( psz_dir );
if( !dir )
{
int err = errno;
if( err != ENOTDIR )
msg_Err( p_ml, "%s: %m", psz_dir );
else
msg_Dbg( p_ml, "`%s' is not a directory", psz_dir );
errno = err;
return VLC_EGENERIC;
}
closedir( dir );
msg_Dbg( p_ml, "Adding directory `%s' to be monitored", psz_dir );
QuerySimple( p_ml, "INSERT INTO directories ( uri, timestamp, "
"recursive ) VALUES( %Q, 0, 0 )", psz_dir );
vlc_cond_signal( &p_ml->p_sys->p_mon->wait );
return VLC_SUCCESS;
}
/*****************************************************************************
* Close: close the ALSA device
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
aout_instance_t *p_aout = (aout_instance_t *)p_this;
struct aout_sys_t * p_sys = p_aout->output.p_sys;
int i_snd_rc;
/* Make sure that the thread will stop once it is waken up */
vlc_object_kill( p_aout );
/* make sure the audio output thread is waken up */
vlc_mutex_lock( &p_aout->output.p_sys->lock );
vlc_cond_signal( &p_aout->output.p_sys->wait );
vlc_mutex_unlock( &p_aout->output.p_sys->lock );
/* */
vlc_thread_join( p_aout );
p_aout->b_die = false;
i_snd_rc = snd_pcm_close( p_sys->p_snd_pcm );
if( i_snd_rc > 0 )
{
msg_Err( p_aout, "failed closing ALSA device (%s)",
snd_strerror( i_snd_rc ) );
}
#ifdef ALSA_DEBUG
snd_output_close( p_sys->p_snd_stderr );
#endif
free( p_sys );
}
static int RandomCallback( vlc_object_t *p_this, char const *psz_cmd,
vlc_value_t oldval, vlc_value_t newval, void *a )
{
(void)psz_cmd; (void)oldval; (void)newval; (void)a;
playlist_t *p_playlist = (playlist_t*)p_this;
bool random = newval.b_bool;
PL_LOCK;
if( !random ) {
pl_priv(p_playlist)->b_reset_currently_playing = true;
vlc_cond_signal( &pl_priv(p_playlist)->signal );
} else {
/* Shuffle and sync the playlist on activation of random mode.
* This preserves the current playing item, so that the user
* can return to it if needed. (See #4472)
*/
playlist_private_t *p_sys = pl_priv(p_playlist);
playlist_item_t *p_new = p_sys->status.p_item;
ResetCurrentlyPlaying( p_playlist, NULL );
if( p_new )
ResyncCurrentIndex( p_playlist, p_new );
}
PL_UNLOCK;
return VLC_SUCCESS;
}
static int
dialog_id_post(vlc_dialog_id *p_id, struct dialog_answer *p_answer)
{
vlc_mutex_lock(&p_id->lock);
if (p_answer == NULL)
{
p_id->b_cancelled = true;
}
else
{
p_id->answer = *p_answer;
p_id->b_answered = true;
}
p_id->i_refcount--;
if (p_id->i_refcount > 0)
{
vlc_cond_signal(&p_id->wait);
vlc_mutex_unlock(&p_id->lock);
}
else
{
vlc_mutex_unlock(&p_id->lock);
dialog_id_release(p_id);
}
return VLC_SUCCESS;
}
/* Enqueue an item for preparsing, and play it, if needed */
static void GoAndPreparse( playlist_t *p_playlist, int i_mode,
playlist_item_t *p_item )
{
playlist_private_t *sys = pl_priv(p_playlist);
PL_ASSERT_LOCKED;
if( (i_mode & PLAYLIST_GO ) )
{
sys->request.b_request = true;
sys->request.i_skip = 0;
sys->request.p_item = p_item;
if( sys->p_input != NULL )
input_Stop( sys->p_input );
vlc_cond_signal( &sys->signal );
}
/* Preparse if no artist/album info, and hasn't been preparsed already
and if user has some preparsing option (auto-preparse variable)
enabled*/
char *psz_artist = input_item_GetArtist( p_item->p_input );
char *psz_album = input_item_GetAlbum( p_item->p_input );
if( sys->b_preparse && !input_item_IsPreparsed( p_item->p_input )
&& (EMPTY_STR(psz_artist) || EMPTY_STR(psz_album)) )
libvlc_MetadataRequest( p_playlist->obj.libvlc, p_item->p_input, 0, -1,
NULL );
free( psz_artist );
free( psz_album );
}
/** Reports received stream data */
static int vlc_h2_stream_data(void *ctx, struct vlc_h2_frame *f)
{
struct vlc_h2_stream *s = ctx;
size_t len;
if (s->recv_end)
{
free(f);
return vlc_h2_stream_fatal(s, VLC_H2_STREAM_CLOSED);
}
/* Enforce the congestion window as required by the protocol spec */
vlc_h2_frame_data_get(f, &len);
if (len > s->recv_cwnd)
{
free(f);
s->recv_end = true;
return vlc_h2_stream_fatal(s, VLC_H2_FLOW_CONTROL_ERROR);
}
s->recv_cwnd -= len;
*(s->recv_tailp) = f;
s->recv_tailp = &f->next;
vlc_cond_signal(&s->recv_wait);
return 0;
}
/*****************************************************************************
* Close: close the plugin
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
aout_filter_t *p_filter = (aout_filter_t *)p_this;
aout_filter_sys_t *p_sys = p_filter->p_sys;
/* Stop Goom Thread */
p_sys->p_thread->b_die = VLC_TRUE;
vlc_mutex_lock( &p_sys->p_thread->lock );
vlc_cond_signal( &p_sys->p_thread->wait );
vlc_mutex_unlock( &p_sys->p_thread->lock );
vlc_thread_join( p_sys->p_thread );
/* Free data */
vout_Request( p_filter, p_sys->p_thread->p_vout, 0, 0, 0, 0 );
vlc_mutex_destroy( &p_sys->p_thread->lock );
vlc_cond_destroy( &p_sys->p_thread->wait );
vlc_object_detach( p_sys->p_thread );
while( p_sys->p_thread->i_blocks-- )
{
block_Release( p_sys->p_thread->pp_blocks[p_sys->p_thread->i_blocks] );
}
vlc_object_destroy( p_sys->p_thread );
free( p_sys );
}
static int FfmpegThread( struct thread_context_t *p_context )
{
while ( !p_context->b_die && !p_context->b_error )
{
vlc_mutex_lock( &p_context->lock );
while ( !p_context->b_work && !p_context->b_die && !p_context->b_error )
{
vlc_cond_wait( &p_context->cond, &p_context->lock );
}
p_context->b_work = 0;
vlc_mutex_unlock( &p_context->lock );
if ( p_context->b_die || p_context->b_error )
break;
if ( p_context->pf_func )
{
p_context->i_ret = p_context->pf_func( p_context->p_context,
p_context->arg );
}
vlc_mutex_lock( &p_context->lock );
p_context->b_done = 1;
vlc_cond_signal( &p_context->cond );
vlc_mutex_unlock( &p_context->lock );
}
return 0;
}
/**
* Moves an array of items
*
* This function must be entered with the playlist lock
*
* \param p_playlist the playlist
* \param i_items the number of indexes to move
* \param pp_items the array of indexes to move
* \param p_node the target node
* \param i_newpos the target position under this node
* \return VLC_SUCCESS or an error
*/
int playlist_TreeMoveMany( playlist_t *p_playlist,
int i_items, playlist_item_t **pp_items,
playlist_item_t *p_node, int i_newpos )
{
PL_ASSERT_LOCKED;
if ( p_node->i_children == -1 ) return VLC_EGENERIC;
int i;
for( i = 0; i < i_items; i++ )
{
playlist_item_t *p_item = pp_items[i];
int i_index = ItemIndex( p_item );
playlist_item_t *p_parent = p_item->p_parent;
REMOVE_ELEM( p_parent->pp_children, p_parent->i_children, i_index );
if ( p_parent == p_node && i_index < i_newpos ) i_newpos--;
}
for( i = i_items - 1; i >= 0; i-- )
{
playlist_item_t *p_item = pp_items[i];
INSERT_ELEM( p_node->pp_children, p_node->i_children, i_newpos, p_item );
p_item->p_parent = p_node;
}
pl_priv( p_playlist )->b_reset_currently_playing = true;
vlc_cond_signal( &pl_priv( p_playlist )->signal );
return VLC_SUCCESS;
}
/**
* This function does the preparsing and issues the art fetching requests
*/
static void *Thread( void *data )
{
playlist_preparser_t *p_preparser = data;
vlc_object_t *obj = p_preparser->object;
for( ;; )
{
input_item_t *p_current;
/* */
vlc_mutex_lock( &p_preparser->lock );
if( p_preparser->i_waiting > 0 )
{
p_current = p_preparser->pp_waiting[0];
REMOVE_ELEM( p_preparser->pp_waiting, p_preparser->i_waiting, 0 );
}
else
{
p_current = NULL;
p_preparser->b_live = false;
vlc_cond_signal( &p_preparser->wait );
}
vlc_mutex_unlock( &p_preparser->lock );
if( !p_current )
break;
Preparse( obj, p_current );
Art( p_preparser, p_current );
vlc_gc_decref(p_current);
}
return NULL;
}
void transcode_video_close( sout_stream_t *p_stream,
sout_stream_id_t *id )
{
if( p_stream->p_sys->i_threads >= 1 )
{
vlc_mutex_lock( &p_stream->p_sys->lock_out );
vlc_object_kill( p_stream->p_sys );
vlc_cond_signal( &p_stream->p_sys->cond );
vlc_mutex_unlock( &p_stream->p_sys->lock_out );
vlc_thread_join( p_stream->p_sys );
vlc_mutex_destroy( &p_stream->p_sys->lock_out );
vlc_cond_destroy( &p_stream->p_sys->cond );
}
video_timer_close( id->p_encoder );
/* Close decoder */
if( id->p_decoder->p_module )
module_unneed( id->p_decoder, id->p_decoder->p_module );
if( id->p_decoder->p_description )
vlc_meta_Delete( id->p_decoder->p_description );
free( id->p_decoder->p_owner );
/* Close encoder */
if( id->p_encoder->p_module )
module_unneed( id->p_encoder, id->p_encoder->p_module );
/* Close filters */
if( id->p_f_chain )
filter_chain_Delete( id->p_f_chain );
if( id->p_uf_chain )
filter_chain_Delete( id->p_uf_chain );
}
/*****************************************************************************
* Close: close the plugin
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys = p_filter->p_sys;
/* Stop Goom Thread */
vlc_mutex_lock( &p_sys->p_thread->lock );
p_sys->p_thread->b_exit = true;
vlc_cond_signal( &p_sys->p_thread->wait );
vlc_mutex_unlock( &p_sys->p_thread->lock );
vlc_join( p_sys->p_thread->thread, NULL );
/* Free data */
aout_filter_RequestVout( p_filter, p_sys->p_thread->p_vout, NULL );
vlc_mutex_destroy( &p_sys->p_thread->lock );
vlc_cond_destroy( &p_sys->p_thread->wait );
while( p_sys->p_thread->i_blocks-- )
{
block_Release( p_sys->p_thread->pp_blocks[p_sys->p_thread->i_blocks] );
}
free( p_sys->p_thread );
free( p_sys );
}
/*****************************************************************************
* Control: services discrovery control
****************************************************************************/
static int Control( services_discovery_t *p_sd, int i_command, va_list args )
{
services_discovery_sys_t *p_sys = p_sd->p_sys;
switch( i_command )
{
case SD_CMD_SEARCH:
{
const char *psz_query = va_arg( args, const char * );
vlc_mutex_lock( &p_sys->lock );
TAB_APPEND( p_sys->i_query, p_sys->ppsz_query, strdup( psz_query ) );
vlc_cond_signal( &p_sys->cond );
vlc_mutex_unlock( &p_sys->lock );
break;
}
case SD_CMD_DESCRIPTOR:
{
services_discovery_descriptor_t *p_desc = va_arg( args,
services_discovery_descriptor_t * );
return FillDescriptor( p_sd, p_desc );
}
}
return VLC_SUCCESS;
}
/*****************************************************************************
* HTTPClose: Stop the internal HTTP server
*****************************************************************************/
void HTTPClose( access_t *p_access )
{
access_sys_t *p_sys = p_access->p_sys;
if ( p_sys->p_httpd_host != NULL )
{
if ( p_sys->p_httpd_file != NULL )
{
/* Unlock the thread if it is stuck in HttpCallback */
vlc_mutex_lock( &p_sys->httpd_mutex );
if ( p_sys->b_request_frontend_info )
{
p_sys->b_request_frontend_info = false;
p_sys->psz_frontend_info = strdup("");
}
if ( p_sys->b_request_mmi_info )
{
p_sys->b_request_mmi_info = false;
p_sys->psz_mmi_info = strdup("");
}
vlc_cond_signal( &p_sys->httpd_cond );
vlc_mutex_unlock( &p_sys->httpd_mutex );
httpd_FileDelete( p_sys->p_httpd_file->p_file );
httpd_RedirectDelete( p_sys->p_httpd_redir );
}
httpd_HostDelete( p_sys->p_httpd_host );
}
vlc_mutex_destroy( &p_sys->httpd_mutex );
vlc_cond_destroy( &p_sys->httpd_cond );
}
/*****************************************************************************
* DoWork: process samples buffer
*****************************************************************************
* This function queues the audio buffer to be processed by the goom thread
*****************************************************************************/
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_block;
/* Queue sample */
vlc_mutex_lock( &p_sys->p_thread->lock );
if( p_sys->p_thread->i_blocks == MAX_BLOCKS )
{
vlc_mutex_unlock( &p_sys->p_thread->lock );
return p_in_buf;
}
p_block = block_Alloc( p_in_buf->i_buffer );
if( !p_block )
{
vlc_mutex_unlock( &p_sys->p_thread->lock );
return p_in_buf;
}
memcpy( p_block->p_buffer, p_in_buf->p_buffer, p_in_buf->i_buffer );
p_block->i_pts = p_in_buf->i_pts;
p_sys->p_thread->pp_blocks[p_sys->p_thread->i_blocks++] = p_block;
vlc_cond_signal( &p_sys->p_thread->wait );
vlc_mutex_unlock( &p_sys->p_thread->lock );
return p_in_buf;
}
/*****************************************************************************
* CloseEncoder: ffmpeg encoder destruction
*****************************************************************************/
void E_(CloseEncoder)( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys = p_enc->p_sys;
#if LIBAVCODEC_BUILD >= 4702
if ( p_sys->b_inited && p_enc->i_threads >= 1 )
{
int i;
struct thread_context_t ** pp_contexts =
(struct thread_context_t **)p_sys->p_context->thread_opaque;
for ( i = 0; i < p_enc->i_threads; i++ )
{
pp_contexts[i]->b_die = 1;
vlc_cond_signal( &pp_contexts[i]->cond );
vlc_thread_join( pp_contexts[i] );
vlc_mutex_destroy( &pp_contexts[i]->lock );
vlc_cond_destroy( &pp_contexts[i]->cond );
vlc_object_destroy( pp_contexts[i] );
}
free( pp_contexts );
}
#endif
avcodec_close( p_sys->p_context );
av_free( p_sys->p_context );
if( p_sys->p_buffer ) free( p_sys->p_buffer );
if( p_sys->p_buffer_out ) free( p_sys->p_buffer_out );
free( p_sys );
}
void background_worker_RequestProbe( struct background_worker* worker )
{
vlc_mutex_lock( &worker->lock );
worker->head.probe_request = true;
vlc_cond_signal( &worker->head.worker_wait );
vlc_mutex_unlock( &worker->lock );
}
/**
* Closes the audio device.
*/
static HRESULT Stop( aout_stream_sys_t *p_sys )
{
vlc_mutex_lock( &p_sys->lock );
p_sys->b_playing = true;
vlc_cond_signal( &p_sys->cond );
vlc_mutex_unlock( &p_sys->lock );
vlc_cancel( p_sys->eraser_thread );
vlc_join( p_sys->eraser_thread, NULL );
vlc_cond_destroy( &p_sys->cond );
vlc_mutex_destroy( &p_sys->lock );
if( p_sys->p_notify != NULL )
{
IDirectSoundNotify_Release(p_sys->p_notify );
p_sys->p_notify = NULL;
}
if( p_sys->p_dsbuffer != NULL )
{
IDirectSoundBuffer_Stop( p_sys->p_dsbuffer );
IDirectSoundBuffer_Release( p_sys->p_dsbuffer );
p_sys->p_dsbuffer = NULL;
}
if( p_sys->p_dsobject != NULL )
{
IDirectSound_Release( p_sys->p_dsobject );
p_sys->p_dsobject = NULL;
}
return DS_OK;
}
static HRESULT Play( vlc_object_t *obj, aout_stream_sys_t *sys,
block_t *p_buffer )
{
HRESULT dsresult;
dsresult = FillBuffer( obj, sys, p_buffer );
if( dsresult != DS_OK )
return dsresult;
/* start playing the buffer */
dsresult = IDirectSoundBuffer_Play( sys->p_dsbuffer, 0, 0,
DSBPLAY_LOOPING );
if( dsresult == DSERR_BUFFERLOST )
{
IDirectSoundBuffer_Restore( sys->p_dsbuffer );
dsresult = IDirectSoundBuffer_Play( sys->p_dsbuffer,
0, 0, DSBPLAY_LOOPING );
}
if( dsresult != DS_OK )
msg_Err( obj, "cannot start playing buffer: (hr=0x%0lx)", dsresult );
else
{
vlc_mutex_lock( &sys->lock );
sys->b_playing = true;
vlc_cond_signal(&sys->cond);
vlc_mutex_unlock( &sys->lock );
}
return dsresult;
}
static void EnqueueRequest( fingerprinter_thread_t *f, fingerprint_request_t *r )
{
fingerprinter_sys_t *p_sys = f->p_sys;
vlc_mutex_lock( &p_sys->incoming.lock );
vlc_array_append( p_sys->incoming.queue, r );
vlc_mutex_unlock( &p_sys->incoming.lock );
vlc_cond_signal( &p_sys->incoming_queue_filled );
}
/**
* @brief Thread reading frames from the subprocess
*/
static void* outputThread(void* userData)
{
filter_t* intf = (filter_t*)userData;
filter_sys_t* sys = intf->p_sys;
msg_Info(intf, "outputThread: enter");
bool gotHeader = false;
while (true)
{
if (!gotHeader)
{
video_format_Init(&sys->outFormat, VLC_CODEC_I420);
if (1 != readY4mHeader(intf, &sys->outFormat, sys->stdout))
break;
gotHeader = true;
}
picture_t* outPic = picture_NewFromFormat(&sys->outFormat);
if(1 != readY4mFrame(intf, outPic, sys->stdout))
{
picture_Release(outPic);
break;
}
//msg_Info(intf, "outputThread: read picture");
// fixme: deinterlace filter does this, not sure if we need to;
// y4m header contains this information
outPic->b_progressive = true;
outPic->i_nb_fields = 2;
picture_fifo_Push(sys->outputFifo, outPic);
vlc_cond_signal(&sys->outputCond);
}
msg_Info(intf, "outputThread: exit");
sys->threadExit = true;
vlc_cond_signal(&sys->outputCond);
return userData;
}
static void thumbnailer_callback_cancel( void* data, picture_t* p_thumbnail )
{
struct test_ctx* p_ctx = data;
assert( p_thumbnail == NULL );
vlc_mutex_lock( &p_ctx->lock );
p_ctx->b_done = true;
vlc_mutex_unlock( &p_ctx->lock );
vlc_cond_signal( &p_ctx->cond );
}
static void callback (void *ptr)
{
struct timer_data *data = ptr;
vlc_mutex_lock (&data->lock);
data->count += 1 + vlc_timer_getoverrun (data->timer);
vlc_cond_signal (&data->wait);
vlc_mutex_unlock (&data->lock);
}
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) {
vlc_mutex_lock(&sys->buffer_cond_mutex);
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_cond_signal(&sys->buffer_cond);
}
vlc_mutex_unlock(&sys->buffer_cond_mutex);
} 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 void vlc_h2_stream_wake_up(void *data)
{
struct vlc_h2_stream *s = data;
struct vlc_h2_conn *conn = s->conn;
vlc_mutex_lock(&conn->lock);
s->interrupted = true;
vlc_cond_signal(&s->recv_wait);
vlc_mutex_unlock(&conn->lock);
}
static int inputStateCallback( vlc_object_t *obj, const char *var,
vlc_value_t old, vlc_value_t cur, void *p_data )
{
VLC_UNUSED(obj);VLC_UNUSED(var);VLC_UNUSED(old);
fingerprinter_sys_t *p_sys = (fingerprinter_sys_t *) p_data;
if ( cur.i_int != INPUT_EVENT_STATE ) return VLC_SUCCESS;
p_sys->condwait.i_input_state = var_GetInteger( p_sys->p_input, "state" );
vlc_cond_signal( & p_sys->condwait.wait );
return VLC_SUCCESS;
}
static void vlc_rwlock_rdunlock (vlc_rwlock_t *lock)
{
vlc_mutex_lock (&lock->mutex);
assert (lock->readers > 0);
/* If there are no readers left, wake up a writer. */
if (--lock->readers == 0)
vlc_cond_signal (&lock->wait);
vlc_mutex_unlock (&lock->mutex);
}