自学教程：C++ vlc_cond_wait函数代码示例

static void *msg_thread (void *data){    msg_subscription_t *sub = data;    msg_bank_t *bank = libvlc_bank (sub->instance);    vlc_mutex_lock (&bank->lock);    for (;;)    {        /* Wait for messages */        assert (sub->begin < VLC_MSG_QSIZE);        assert (sub->end < VLC_MSG_QSIZE);        while (sub->begin != sub->end)        {            msg_item_t *msg = sub->items[sub->begin];            unsigned overruns = sub->overruns;            if (++sub->begin == VLC_MSG_QSIZE)                sub->begin = 0;            sub->overruns = 0;            vlc_mutex_unlock (&bank->lock);            sub->func (sub->opaque, msg, overruns);            msg_Release (msg);            vlc_mutex_lock (&bank->lock);        }        mutex_cleanup_push (&bank->lock);        vlc_cond_wait (&bank->wait, &bank->lock);        vlc_cleanup_pop ();    }    assert (0);}

/***************************************************************************** * ALSAThread: asynchronous thread used to DMA the data to the device *****************************************************************************/static void* ALSAThread( 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 canc = vlc_savecancel ();    p_sys->p_status = (snd_pcm_status_t *)malloc(snd_pcm_status_sizeof());    /* Wait for the exact time to start playing (avoids resampling) */    vlc_mutex_lock( &p_sys->lock );    while( !p_sys->start_date && vlc_object_alive (p_aout) )        vlc_cond_wait( &p_sys->wait, &p_sys->lock );    vlc_mutex_unlock( &p_sys->lock );    if( !vlc_object_alive (p_aout) )        goto cleanup;    mwait( p_sys->start_date - AOUT_PTS_TOLERANCE / 4 );    while ( vlc_object_alive (p_aout) )    {        ALSAFill( p_aout );    }cleanup:    snd_pcm_drop( p_sys->p_snd_pcm );    free( p_aout->output.p_sys->p_status );    vlc_restorecancel (canc);    return NULL;}

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 );}

picture_t *picture_pool_Wait(picture_pool_t *pool){    unsigned i;    vlc_mutex_lock(&pool->lock);    assert(pool->refs > 0);    while (pool->available == 0)        vlc_cond_wait(&pool->wait, &pool->lock);    i = ffsll(pool->available);    assert(i > 0);    pool->available &= ~(1ULL << (i - 1));    vlc_mutex_unlock(&pool->lock);    picture_t *picture = pool->picture[i - 1];    if (pool->pic_lock != NULL && pool->pic_lock(picture) != 0) {        vlc_mutex_lock(&pool->lock);        pool->available |= 1ULL << (i - 1);        vlc_cond_signal(&pool->wait);        vlc_mutex_unlock(&pool->lock);        return NULL;    }    picture_t *clone = picture_pool_ClonePicture(pool, i - 1);    if (clone != NULL) {        assert(clone->p_next == NULL);        atomic_fetch_add(&pool->refs, 1);    }    return clone;}

/************************************************************************** *       event_async_loop (private) : * * Send queued events. **************************************************************************/static void * event_async_loop(void * arg){    libvlc_event_manager_t * p_em = arg;    libvlc_event_listener_t listener;    libvlc_event_t event;    vlc_threadvar_set(queue(p_em)->is_asynch_dispatch_thread_var, p_em);    queue_lock(p_em);    while (true) {        int has_listener = pop(p_em, &listener, &event);        if (has_listener)        {            queue_unlock(p_em);            listener.pf_callback(&event, listener.p_user_data); // This might edit the queue            queue_lock(p_em);        }        else        {            queue(p_em)->is_idle = true;            mutex_cleanup_push(&queue(p_em)->lock);            vlc_cond_broadcast(&queue(p_em)->signal_idle); // We'll be idle            vlc_cond_wait(&queue(p_em)->signal, &queue(p_em)->lock);            vlc_cleanup_pop();            queue(p_em)->is_idle = false;        }    }    queue_unlock(p_em);    return NULL;}

static void flush(filter_t *filter){    filter_sys_t *sys = filter->p_sys;    MMAL_BUFFER_HEADER_T *buffer;    msg_Dbg(filter, "flush deinterlace filter");    if (atomic_load(&sys->input_in_transit) ||            atomic_load(&sys->output_in_transit)) {        msg_Dbg(filter, "flush: flush ports (input: %d, output: %d in transit)",                sys->input_in_transit, sys->output_in_transit);        mmal_port_flush(sys->output);        mmal_port_flush(sys->input);        msg_Dbg(filter, "flush: wait for all buffers to be returned");        vlc_mutex_lock(&sys->buffer_cond_mutex);        while (atomic_load(&sys->input_in_transit) ||                atomic_load(&sys->output_in_transit)) {            vlc_cond_wait(&sys->buffer_cond, &sys->buffer_cond_mutex);        }        vlc_mutex_unlock(&sys->buffer_cond_mutex);    }    while ((buffer = mmal_queue_get(sys->filtered_pictures))) {        picture_t *pic = (picture_t *)buffer->user_data;        msg_Dbg(filter, "flush: release already filtered pic %p",                (void *)pic);        picture_Release(pic);    }    msg_Dbg(filter, "flush: done");}

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;}

static intEcoreMainLoopCallSync( vout_display_t *vd, mainloop_cb p_cb ){    vout_display_sys_t *sys = vd->sys;    struct mainloop_cb_args args = { .vd = vd, .p_cb = p_cb, .b_signal = false };    ecore_main_loop_thread_safe_call_async( EcoreMainLoopCb, &args );    vlc_mutex_lock( &sys->cb_lock );    while( !args.b_signal )        vlc_cond_wait( &sys->cb_wait, &sys->cb_lock );    vlc_mutex_unlock( &sys->cb_lock );    return args.i_ret;}#ifdef HAVE_EVAS_CALLBACK_KEY_UPstatic voidEventSendKey( vout_display_t *vd, int i_key ){    vout_display_sys_t *sys = vd->sys;    struct event *p_event = malloc( sizeof(struct event) );    if( !p_event )        return;    p_event->i_type = VOUT_DISPLAY_EVENT_KEY;    p_event->u.i_key = i_key;    EVENT_FIFO_PUSH( p_event );}

static intdialog_wait(vlc_dialog_provider *p_provider, vlc_dialog_id *p_id,            enum dialog_type i_type, struct dialog_answer *p_answer){    struct dialog_i11e_context context = {        .p_provider = p_provider,        .p_id = p_id,    };    vlc_interrupt_register(dialog_wait_interrupted, &context);    vlc_mutex_lock(&p_id->lock);    /* Wait for the dialog to be dismissed, interrupted or answered */    while (!p_id->b_cancelled && !p_id->b_answered)        vlc_cond_wait(&p_id->wait, &p_id->lock);    int i_ret;    if (p_id->b_cancelled)        i_ret = 0;    else if (p_id->answer.i_type != i_type)        i_ret = VLC_EGENERIC;    else    {        i_ret = 1;        memcpy(p_answer, &p_id->answer, sizeof(p_id->answer));        memset(&p_id->answer, 0, sizeof(p_id->answer));    }    vlc_mutex_unlock(&p_id->lock);    vlc_interrupt_unregister();    vlc_mutex_lock(&p_provider->lock);    dialog_remove_locked(p_provider, p_id);    vlc_mutex_unlock(&p_provider->lock);    return i_ret;}

/** * Run the main control thread itself */static void *Thread ( void *data ){    playlist_t *p_playlist = data;    playlist_private_t *p_sys = pl_priv(p_playlist);    playlist_Lock( p_playlist );    while( vlc_object_alive( p_playlist ) || p_sys->p_input )    {        /* FIXME: what's that ! */        if( p_sys->b_reset_currently_playing &&            mdate() - p_sys->last_rebuild_date > 30000 ) // 30 ms        {            ResetCurrentlyPlaying( p_playlist,                                   get_current_status_item( p_playlist ) );            p_sys->last_rebuild_date = mdate();        }        /* If there is an input, check that it doesn't need to die. */        while( !LoopInput( p_playlist ) )            vlc_cond_wait( &p_sys->signal, &p_sys->lock );        LoopRequest( p_playlist );    }    playlist_Unlock( p_playlist );    return NULL;}

static void BackgroundWorkerCancel( struct background_worker* worker, void* id){    vlc_mutex_lock( &worker->lock );    for( size_t i = 0; i < vlc_array_count( &worker->tail.data ); )    {        struct bg_queued_item* item =            vlc_array_item_at_index( &worker->tail.data, i );        if( id == NULL || item->id == id )        {            vlc_array_remove( &worker->tail.data, i );            worker->conf.pf_release( item->entity );            free( item );            continue;        }        ++i;    }    while( ( id == NULL && worker->head.active )        || ( id != NULL && worker->head.id == id ) )    {        worker->head.deadline = VLC_TS_0;        vlc_cond_signal( &worker->head.worker_wait );        vlc_cond_signal( &worker->tail.wait );        vlc_cond_wait( &worker->head.wait, &worker->lock );    }    vlc_mutex_unlock( &worker->lock );}

/***************************************************************************** * Thread: *****************************************************************************/static void *Thread( void *p_thread_data ){    goom_thread_t *p_thread = (goom_thread_t*)p_thread_data;    date_t i_pts;    int16_t p_data[2][512];    int i_data = 0, i_count = 0;    PluginInfo *p_plugin_info;    int canc = vlc_savecancel ();    p_plugin_info = goom_init( p_thread->i_width, p_thread->i_height );    for( ;; )    {        uint32_t  *plane;        picture_t *p_pic;        /* FIXME the way the update is done is not really good.         *  Supurious wake up from p_thread->wait will make it generates a frame         * without using new samples (probably rare as we should not be waiting         * samples).         *  The frame rate at which the video is generated is not well controlled         * nor the time at which each frame is displayed (not smooth)         */        /* goom_update is damn slow, so just copy data and release the lock */        vlc_mutex_lock( &p_thread->lock );        if( !p_thread->b_exit &&            FillBuffer( (int16_t *)p_data, &i_data,                        &i_pts, &p_thread->date, p_thread ) != VLC_SUCCESS )            vlc_cond_wait( &p_thread->wait, &p_thread->lock );        bool b_exit = p_thread->b_exit;        vlc_mutex_unlock( &p_thread->lock );        if( b_exit )            break;        /* Speed selection */        if( p_thread->i_speed && (++i_count % (p_thread->i_speed+1)) ) continue;        /* Frame dropping if necessary */        if( date_Get( &i_pts ) + GOOM_DELAY <= mdate() ) continue;        plane = goom_update( p_plugin_info, p_data, 0, 0.0,                             NULL, NULL );        p_pic = vout_GetPicture( p_thread->p_vout );        if( unlikely(p_pic == NULL) )            continue;        memcpy( p_pic->p[0].p_pixels, plane, p_thread->i_width * p_thread->i_height * 4 );        p_pic->date = date_Get( &i_pts ) + GOOM_DELAY;        vout_PutPicture( p_thread->p_vout, p_pic );    }    goom_close( p_plugin_info );    vlc_restorecancel (canc);    return NULL;}

/** * Waits until the variable is inactive (i.e. not executing a callback) */static void WaitUnused(vlc_object_t *obj, variable_t *var){    vlc_object_internals_t *priv = vlc_internals(obj);    mutex_cleanup_push(&priv->var_lock);    while (var->b_incallback)        vlc_cond_wait(&priv->var_wait, &priv->var_lock);    vlc_cleanup_pop();}

/***************************************************************************** * 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 );    while( !p_sys->b_exiting )    {        /* Wait for a request */        while( !p_sys->i_query )            vlc_cond_wait( &p_sys->cond, &p_sys->lock );        /* Execute every query each one protected against cancelation */        cancel = vlc_savecancel();        while( !p_sys->b_exiting && p_sys->i_query )        {            char *psz_query = p_sys->ppsz_query[p_sys->i_query - 1];            REMOVE_ELEM( (char **), p_sys->ppsz_query, p_sys->i_query, p_sys->i_query - 1 );			// sunqueen modify            vlc_mutex_unlock( &p_sys->lock );            DoSearch( p_sd, psz_query );            free( psz_query );            vlc_mutex_lock( &p_sys->lock );        }        /* 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_cleanup_run();    return NULL;}

static void LoopRequest( playlist_t *p_playlist ){    playlist_private_t *p_sys = pl_priv(p_playlist);    assert( !p_sys->p_input );    /* No input. Several cases     *  - No request, running status -> start new item     *  - No request, stopped status -> collect garbage     *  - Request, running requested -> start new item     *  - Request, stopped requested -> collect garbage    */    const int i_status = p_sys->request.b_request ?                         p_sys->request.i_status : p_sys->status.i_status;    if( i_status == PLAYLIST_STOPPED || !vlc_object_alive( p_playlist ) )    {        p_sys->status.i_status = PLAYLIST_STOPPED;        if( p_sys->p_input_resource &&            input_resource_HasVout( p_sys->p_input_resource ) )        {            /* XXX We can unlock if we don't issue the wait as we will be             * call again without anything else done between the calls */            PL_UNLOCK;            /* input_resource_t must be manipulated without playlist lock */            input_resource_TerminateVout( p_sys->p_input_resource );            PL_LOCK;        }        else        {            if( vlc_object_alive( p_playlist ) )                vlc_cond_wait( &p_sys->signal, &p_sys->lock );        }        return;    }    playlist_item_t *p_item = NextItem( p_playlist );    if( p_item )    {        msg_Dbg( p_playlist, "starting playback of the new playlist item" );        PlayItem( p_playlist, p_item );        return;    }    msg_Dbg( p_playlist, "nothing to play" );    p_sys->status.i_status = PLAYLIST_STOPPED;    if( var_GetBool( p_playlist, "play-and-exit" ) )    {        msg_Info( p_playlist, "end of playlist, exiting" );        libvlc_Quit( p_playlist->p_libvlc );    }}

/** * Receives stream data. * * Dequeues pending incoming data for an HTTP/2 stream. If there is currently * no data block, wait for one. * * /return a VLC data block, or NULL on stream error or end of stream */static block_t *vlc_h2_stream_read(struct vlc_http_stream *stream){    struct vlc_h2_stream *s = (struct vlc_h2_stream *)stream;    struct vlc_h2_conn *conn = s->conn;    struct vlc_h2_frame *f;    vlc_h2_stream_lock(s);    while ((f = s->recv_head) == NULL && !s->recv_end && !s->interrupted)    {        mutex_cleanup_push(&conn->lock);        vlc_cond_wait(&s->recv_wait, &conn->lock);        vlc_cleanup_pop();    }    if (f == NULL)    {        vlc_h2_stream_unlock(s);        return NULL;    }    s->recv_head = f->next;    if (f->next == NULL)    {        assert(s->recv_tailp == &f->next);        s->recv_tailp = &s->recv_head;    }    /* Credit the receive window if missing credit exceeds 50%. */    uint_fast32_t credit = VLC_H2_INIT_WINDOW - s->recv_cwnd;    if (credit >= (VLC_H2_INIT_WINDOW / 2)     && !vlc_h2_output_send(conn->out,                            vlc_h2_frame_window_update(s->id, credit)))        s->recv_cwnd += credit;    vlc_h2_stream_unlock(s);    /* This, err, unconventional code to avoid copying data. */    block_t *block = block_heap_Alloc(f, sizeof (*f) + vlc_h2_frame_size(f));    if (unlikely(block == NULL))    {        free(f);        vlc_h2_stream_error(conn, s->id, VLC_H2_INTERNAL_ERROR);        return NULL;    }    size_t len;    uint8_t *buf = vlc_h2_frame_data_get(f, &len);    assert(block->i_buffer >= len);    assert(block->p_buffer <= buf);    assert(block->p_buffer + block->i_buffer >= buf + len);    block->p_buffer = buf;    block->i_buffer = len;    return block;}

static void* EncoderThread( void *obj ){    sout_stream_sys_t *p_sys = (sout_stream_sys_t*)obj;    sout_stream_id_sys_t *id = p_sys->id_video;    picture_t *p_pic = NULL;    int canc = vlc_savecancel ();    block_t *p_block = NULL;    vlc_mutex_lock( &p_sys->lock_out );    for( ;; )    {        while( !p_sys->b_abort &&               (p_pic = picture_fifo_Pop( p_sys->pp_pics )) == NULL )            vlc_cond_wait( &p_sys->cond, &p_sys->lock_out );        if( p_pic )        {            /* release lock while encoding */            vlc_mutex_unlock( &p_sys->lock_out );            p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );            picture_Release( p_pic );            vlc_mutex_lock( &p_sys->lock_out );            block_ChainAppend( &p_sys->p_buffers, p_block );        }        if( p_sys->b_abort )            break;    }    /*Encode what we have in the buffer on closing*/    while( (p_pic = picture_fifo_Pop( p_sys->pp_pics )) != NULL )    {        p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );        picture_Release( p_pic );        block_ChainAppend( &p_sys->p_buffers, p_block );    }    /*Now flush encoder*/    do {        p_block = id->p_encoder->pf_encode_video(id->p_encoder, NULL );        block_ChainAppend( &p_sys->p_buffers, p_block );    } while( p_block );    vlc_mutex_unlock( &p_sys->lock_out );    vlc_restorecancel (canc);    return NULL;}

static void vd_display(vout_display_t *vd, picture_t *picture,                subpicture_t *subpicture){    vout_display_sys_t *sys = vd->sys;    picture_sys_t *pic_sys = picture->p_sys;    MMAL_BUFFER_HEADER_T *buffer = pic_sys->buffer;    MMAL_STATUS_T status;    if (picture->format.i_frame_rate != sys->i_frame_rate ||        picture->format.i_frame_rate_base != sys->i_frame_rate_base ||        picture->b_progressive != sys->b_progressive ||        picture->b_top_field_first != sys->b_top_field_first) {        sys->b_top_field_first = picture->b_top_field_first;        sys->b_progressive = picture->b_progressive;        sys->i_frame_rate = picture->format.i_frame_rate;        sys->i_frame_rate_base = picture->format.i_frame_rate_base;        configure_display(vd, NULL, &picture->format);    }    if (!pic_sys->displayed || !sys->opaque) {        buffer->cmd = 0;        buffer->length = sys->input->buffer_size;        vlc_mutex_lock(&sys->buffer_mutex);        while (sys->buffers_in_transit >= MAX_BUFFERS_IN_TRANSIT)            vlc_cond_wait(&sys->buffer_cond, &sys->buffer_mutex);        status = mmal_port_send_buffer(sys->input, buffer);        if (status == MMAL_SUCCESS)            ++sys->buffers_in_transit;        vlc_mutex_unlock(&sys->buffer_mutex);        if (status != MMAL_SUCCESS) {            msg_Err(vd, "Failed to send buffer to input port. Frame dropped");            picture_Release(picture);        }        pic_sys->displayed = true;    } else {        picture_Release(picture);    }    display_subpicture(vd, subpicture);    if (subpicture)        subpicture_Delete(subpicture);    if (sys->next_phase_check == 0 && sys->adjust_refresh_rate)        maintain_phase_sync(vd);    sys->next_phase_check = (sys->next_phase_check + 1) % PHASE_CHECK_INTERVAL;}

static int media_parse(libvlc_media_t *media, bool b_async,                       libvlc_media_parse_flag_t parse_flag){    bool needed;    vlc_mutex_lock(&media->parsed_lock);    needed = !media->has_asked_preparse;    media->has_asked_preparse = true;    if (needed)        media->is_parsed = false;    vlc_mutex_unlock(&media->parsed_lock);    if (needed)    {        libvlc_int_t *libvlc = media->p_libvlc_instance->p_libvlc_int;        input_item_t *item = media->p_input_item;        input_item_meta_request_option_t art_scope = META_REQUEST_OPTION_NONE;        input_item_meta_request_option_t parse_scope = META_REQUEST_OPTION_SCOPE_LOCAL;        int ret;        if (parse_flag & libvlc_media_fetch_local)            art_scope |= META_REQUEST_OPTION_SCOPE_LOCAL;        if (parse_flag & libvlc_media_fetch_network)            art_scope |= META_REQUEST_OPTION_SCOPE_NETWORK;        if (art_scope != META_REQUEST_OPTION_NONE) {            ret = libvlc_ArtRequest(libvlc, item, art_scope);            if (ret != VLC_SUCCESS)                return ret;        }        if (parse_flag & libvlc_media_parse_network)            parse_scope |= META_REQUEST_OPTION_SCOPE_NETWORK;        if (parse_flag & libvlc_media_do_interact)            parse_scope |= META_REQUEST_OPTION_DO_INTERACT;        ret = libvlc_MetaRequest(libvlc, item, parse_scope);        if (ret != VLC_SUCCESS)            return ret;    }    else        return VLC_EGENERIC;    if (!b_async)    {        vlc_mutex_lock(&media->parsed_lock);        while (!media->is_parsed)            vlc_cond_wait(&media->parsed_cond, &media->parsed_lock);        vlc_mutex_unlock(&media->parsed_lock);    }    return VLC_SUCCESS;}

void vlc_rwlock_wrlock (vlc_rwlock_t *lock){    vlc_mutex_lock (&lock->mutex);    if (unlikely(lock->writers == ULONG_MAX))        abort ();    lock->writers++;    /* Wait until nobody owns the lock in either way. */    while ((lock->readers > 0) || (lock->writer != 0))        vlc_cond_wait (&lock->wait, &lock->mutex);    lock->writers--;    assert (lock->writer == 0);    lock->writer = _gettid ();    vlc_mutex_unlock (&lock->mutex);}

/***************************************************************************** * Close: close the audio device *****************************************************************************/static void Close ( vlc_object_t *p_this ){    audio_output_t *p_aout = (audio_output_t *)p_this;    aout_sys_t *p_sys = p_aout->sys;    msg_Dbg( p_aout, "closing portaudio");#ifdef PORTAUDIO_IS_SERIOUSLY_BROKEN    /* Signal end of stream */    vlc_mutex_lock( &pa_thread->lock_signal );    pa_thread->b_signal = true;    vlc_cond_signal( &pa_thread->signal );    vlc_mutex_unlock( &pa_thread->lock_signal );    /* Wait until thread is ready */    vlc_mutex_lock( &pa_thread->lock_wait );    while( !pa_thread->b_wait )        vlc_cond_wait( &pa_thread->wait, &pa_thread->lock_wait );    vlc_mutex_unlock( &pa_thread->lock_wait );    pa_thread->b_wait = false;#else    int i_err = Pa_StopStream( p_sys->p_stream );    if( i_err != paNoError )    {        msg_Err( p_aout, "Pa_StopStream: %d (%s)", i_err,                 Pa_GetErrorText( i_err ) );    }    i_err = Pa_CloseStream( p_sys->p_stream );    if( i_err != paNoError )    {        msg_Err( p_aout, "Pa_CloseStream: %d (%s)", i_err,                 Pa_GetErrorText( i_err ) );    }    i_err = Pa_Terminate();    if( i_err != paNoError )    {        msg_Err( p_aout, "Pa_Terminate: %d (%s)", i_err,                 Pa_GetErrorText( i_err ) );    }#endif    msg_Dbg( p_aout, "portaudio closed");    aout_PacketDestroy( p_aout );    free( p_sys );}

static void* EncoderThread( vlc_object_t* p_this ){    sout_stream_sys_t *p_sys = (sout_stream_sys_t*)p_this;    sout_stream_id_t *id = p_sys->id_video;    picture_t *p_pic;    int canc = vlc_savecancel ();    while( vlc_object_alive (p_sys) && !p_sys->b_error )    {        block_t *p_block;        vlc_mutex_lock( &p_sys->lock_out );        while( p_sys->i_last_pic == p_sys->i_first_pic )        {            vlc_cond_wait( &p_sys->cond, &p_sys->lock_out );            if( !vlc_object_alive (p_sys) || p_sys->b_error ) break;        }        if( !vlc_object_alive (p_sys) || p_sys->b_error )        {            vlc_mutex_unlock( &p_sys->lock_out );            break;        }        p_pic = p_sys->pp_pics[p_sys->i_first_pic++];        p_sys->i_first_pic %= PICTURE_RING_SIZE;        vlc_mutex_unlock( &p_sys->lock_out );        video_timer_start( id->p_encoder );        p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );        video_timer_stop( id->p_encoder );        vlc_mutex_lock( &p_sys->lock_out );        block_ChainAppend( &p_sys->p_buffers, p_block );        vlc_mutex_unlock( &p_sys->lock_out );        picture_Release( p_pic );    }    while( p_sys->i_last_pic != p_sys->i_first_pic )    {        p_pic = p_sys->pp_pics[p_sys->i_first_pic++];        p_sys->i_first_pic %= PICTURE_RING_SIZE;        picture_Release( p_pic );    }    block_ChainRelease( p_sys->p_buffers );    vlc_restorecancel (canc);    return NULL;}

/**************************************************************************** * HttpCallback: Return the index.html file ****************************************************************************/static int HttpCallback( httpd_file_sys_t *p_args,                         httpd_file_t *p_file,                         uint8_t *_psz_request,                         uint8_t **_pp_data, int *pi_data ){    VLC_UNUSED(p_file);    access_sys_t *p_sys = p_args->p_access->p_sys;    char *psz_request = (char *)_psz_request;    char **pp_data = (char **)_pp_data;    vlc_mutex_lock( &p_sys->httpd_mutex );    p_sys->i_httpd_timeout = mdate() + INT64_C(3000000); /* 3 s */    p_sys->psz_request = psz_request;    p_sys->b_request_frontend_info = true;    if ( p_sys->p_cam != NULL )    {        p_sys->b_request_mmi_info = true;    }    else    {        p_sys->psz_mmi_info = strdup( "No available CAM interface/n" );    }    do    {        vlc_cond_wait( &p_sys->httpd_cond, &p_sys->httpd_mutex );    }    while ( p_sys->b_request_frontend_info || p_sys->b_request_mmi_info );    p_sys->i_httpd_timeout = 0;    vlc_mutex_unlock( &p_sys->httpd_mutex );    *pi_data = strlen( psz_constant_header )                + strlen( p_sys->psz_mmi_info )                + strlen( psz_constant_middle )                + strlen( p_sys->psz_frontend_info )                + strlen( psz_constant_footer ) + 1;    *pp_data = malloc( *pi_data );    sprintf( *pp_data, "%s%s%s%s%s", psz_constant_header,             p_sys->psz_mmi_info, psz_constant_middle,             p_sys->psz_frontend_info, psz_constant_footer );    free( p_sys->psz_frontend_info );    free( p_sys->psz_mmi_info );    return VLC_SUCCESS;}

VLC_NORETURNstatic 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 ();}

/***************************************************************************** * Run: main thread *****************************************************************************/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, "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];            if( p_input->b_eof || p_input->b_error )            {                input_Stop( p_input, false );                vlc_thread_join( p_input );                vlc_object_release( 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();    assert(0); /* dead code */}