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

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

/************************************************************************** *       libvlc_event_async_fini (internal) : * * Destroy what might have been created by. **************************************************************************/voidlibvlc_event_async_fini(libvlc_event_manager_t * p_em){    if(!is_queue_initialized(p_em)) return;    if(current_thread_is_asynch_thread(p_em))    {        fprintf(stderr, "*** Error: releasing the last reference of the observed object from its callback thread is not (yet!) supported/n");        abort();    }    vlc_thread_t thread = queue(p_em)->thread;    if(thread)    {        vlc_cancel(thread);        vlc_join(thread, NULL);    }    vlc_mutex_destroy(&queue(p_em)->lock);    vlc_cond_destroy(&queue(p_em)->signal);    vlc_cond_destroy(&queue(p_em)->signal_idle);    vlc_threadvar_delete(&queue(p_em)->is_asynch_dispatch_thread_var);    struct queue_elmt * iter = queue(p_em)->elements;    while (iter) {        struct queue_elmt * elemt_to_delete = iter;        iter = iter->next;        free(elemt_to_delete);    }    free(queue(p_em));}

int vlc_mwait_i11e(mtime_t deadline){    vlc_interrupt_t *ctx = vlc_threadvar_get(vlc_interrupt_var);    if (ctx == NULL)        return mwait(deadline), 0;    vlc_cond_t wait;    vlc_cond_init(&wait);    int ret = vlc_interrupt_prepare(ctx, vlc_mwait_i11e_wake, &wait);    if (ret)    {        vlc_cond_destroy(&wait);        vlc_testcancel();        return ret;    }    vlc_mutex_lock(&ctx->lock);    vlc_cleanup_push(vlc_mwait_i11e_cleanup, ctx);    while (!ctx->interrupted        && vlc_cond_timedwait(&wait, &ctx->lock, deadline) == 0);    vlc_cleanup_pop();    vlc_mutex_unlock(&ctx->lock);    ret = vlc_interrupt_finish(ctx);    vlc_cond_destroy(&wait);    return ret;}

//---------------------------------------------------------------------------// Close: destroy interface//---------------------------------------------------------------------------static void Close( vlc_object_t *p_this ){    intf_thread_t *p_intf = (intf_thread_t *)p_this;    msg_Dbg( p_intf, "closing skins2 module" );    vlc_mutex_lock( &skin_load.mutex );    skin_load.intf = NULL;    vlc_mutex_unlock( &skin_load.mutex);    vlc_join( p_intf->p_sys->thread, NULL );    vlc_mutex_destroy( &p_intf->p_sys->init_lock );    vlc_cond_destroy( &p_intf->p_sys->init_wait );    if( p_intf->p_sys->p_playlist )        pl_Release( p_this );    // Unsubscribe from messages bank#if 0    msg_Unsubscribe( p_intf, p_intf->p_sys->p_sub );#endif    vlc_cond_destroy( &p_intf->p_sys->vout_wait );    vlc_mutex_destroy( &p_intf->p_sys->vout_lock );    // Destroy structure    free( p_intf->p_sys );}

void background_worker_Delete( struct background_worker* worker ){    BackgroundWorkerCancel( worker, NULL );    vlc_array_clear( &worker->tail.data );    vlc_mutex_destroy( &worker->lock );    vlc_cond_destroy( &worker->head.wait );    vlc_cond_destroy( &worker->head.worker_wait );    vlc_cond_destroy( &worker->tail.wait );    free( worker );}

static void Close( vlc_object_t *p_this ){    stream_t *s = (stream_t*)p_this;    stream_sys_t *p_sys = s->p_sys;    vlc_join( p_sys->download.thread, NULL );    vlc_mutex_destroy( &p_sys->lock );    vlc_cond_destroy( &p_sys->download.wait );    vlc_mutex_destroy( &p_sys->playback.lock );    vlc_cond_destroy( &p_sys->playback.wait );    SysCleanup( p_sys );    free( p_sys );}

void EventThreadDestroy( event_thread_t *p_event ){    free( p_event->psz_title );    vlc_cond_destroy( &p_event->wait );    vlc_mutex_destroy( &p_event->lock );    free( p_event );}

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

/***************************************************************************** * Open: initialize and create stuff *****************************************************************************/static int Open(vlc_object_t *p_this){    intf_thread_t   *p_intf     = (intf_thread_t*) p_this;    intf_sys_t      *p_sys      = calloc(1, sizeof(intf_sys_t));    if (!p_sys)        return VLC_ENOMEM;    p_intf->p_sys = p_sys;    vlc_mutex_init(&p_sys->lock);    vlc_cond_init(&p_sys->wait);    if (vlc_clone(&p_sys->thread, Run, p_intf, VLC_THREAD_PRIORITY_LOW))    {        vlc_cond_destroy(&p_sys->wait);        vlc_mutex_destroy(&p_sys->lock);        free(p_sys);        return VLC_ENOMEM;    }    var_AddCallback(pl_Get(p_intf), "activity", ItemChange, p_intf);    return VLC_SUCCESS;}

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

/***************************************************************************** * Close: destroy interface stuff *****************************************************************************/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;    vlc_playlist_t *playlist = p_sys->playlist;    vlc_cancel(p_sys->thread);    vlc_join(p_sys->thread, NULL);    int i;    for (i = 0; i < p_sys->i_songs; i++)        DeleteSong(&p_sys->p_queue[i]);    vlc_UrlClean(&p_sys->p_submit_url);    vlc_UrlClean(&p_sys->p_nowp_url);    vlc_cond_destroy(&p_sys->wait);    vlc_mutex_destroy(&p_sys->lock);    vlc_playlist_Lock(playlist);    vlc_player_RemoveListener(            vlc_playlist_GetPlayer(playlist), p_sys->player_listener);    vlc_playlist_RemoveListener(playlist, p_sys->playlist_listener);    vlc_playlist_Unlock(playlist);    free(p_sys);}

int vlc_timer_create (vlc_timer_t *id, void (*func) (void *), void *data){    struct vlc_timer *timer = malloc (sizeof (*timer));    if (unlikely(timer == NULL))        return ENOMEM;    vlc_mutex_init (&timer->lock);    vlc_cond_init (&timer->reschedule);    assert (func);    timer->func = func;    timer->data = data;    timer->value = 0;    timer->interval = 0;    atomic_init(&timer->overruns, 0);    if (vlc_clone (&timer->thread, vlc_timer_thread, timer,                   VLC_THREAD_PRIORITY_INPUT))    {        vlc_cond_destroy (&timer->reschedule);        vlc_mutex_destroy (&timer->lock);        free (timer);        return ENOMEM;    }    *id = timer;    return 0;}

/** **************************************************************************** * Destroy a vlc object (Internal) * * This function destroys an object that has been previously allocated with * vlc_object_create. The object's refcount must be zero and it must not be * attached to other objects in any way. * * This function must be called with cancellation disabled (currently). *****************************************************************************/static void vlc_object_destroy( vlc_object_t *p_this ){    vlc_object_internals_t *p_priv = vlc_internals( p_this );    /* Send a kill to the object's thread if applicable */    vlc_object_kill( p_this );    /* Call the custom "subclass" destructor */    if( p_priv->pf_destructor )        p_priv->pf_destructor( p_this );    /* Any thread must have been cleaned up at this point. */    assert( !p_priv->b_thread );    /* Destroy the associated variables. */    var_DestroyAll( p_this );    vlc_cond_destroy( &p_priv->var_wait );    vlc_mutex_destroy( &p_priv->var_lock );    free( p_this->psz_header );    free( p_priv->psz_name );    vlc_spin_destroy( &p_priv->ref_spin );    if( p_priv->pipes[1] != -1 && p_priv->pipes[1] != p_priv->pipes[0] )        close( p_priv->pipes[1] );    if( p_priv->pipes[0] != -1 )        close( p_priv->pipes[0] );    if( VLC_OBJECT(p_this->p_libvlc) == p_this )        vlc_mutex_destroy (&(libvlc_priv ((libvlc_int_t *)p_this)->structure_lock));    free( p_priv );}

/** * @brief Directory Monitoring thread loop */void *RunMonitoringThread( void *p_this ){    monitoring_thread_t *p_mon = (monitoring_thread_t*) p_this;    vlc_cond_init( &p_mon->wait );    vlc_mutex_init( &p_mon->lock );    var_Create( p_mon, "ml-recursive-scan", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    while( vlc_object_alive( p_mon ) )    {        vlc_mutex_lock( &p_mon->lock );        /* Update */        UpdateLibrary( p_mon );        /* We wait MONITORING_DELAY seconds or wait that the media library           signals us to do something */        vlc_cond_timedwait( &p_mon->wait, &p_mon->lock,                            mdate() + 1000000*MONITORING_DELAY );        vlc_mutex_unlock( &p_mon->lock );    }    vlc_cond_destroy( &p_mon->wait );    vlc_mutex_destroy( &p_mon->lock );    return NULL;}

/***************************************************************************** * Close: destroy interface stuff *****************************************************************************/static void Close( vlc_object_t *p_this ){    playlist_t                  *p_playlist = pl_Get( p_this );    input_thread_t              *p_input;    intf_thread_t               *p_intf = ( intf_thread_t* ) p_this;    intf_sys_t                  *p_sys  = p_intf->p_sys;    var_DelCallback( p_playlist, "item-current", ItemChange, p_intf );    p_input = playlist_CurrentInput( p_playlist );    if ( p_input )    {        if( p_sys->b_state_cb )            var_DelCallback( p_input, "intf-event", PlayingChange, p_intf );        vlc_object_release( p_input );    }    int i;    for( i = 0; i < p_sys->i_songs; i++ )        DeleteSong( &p_sys->p_queue[i] );    free( p_sys->psz_submit_host );    free( p_sys->psz_submit_file );#if 0 //NOT USED    free( p_sys->psz_nowp_host );    free( p_sys->psz_nowp_file );#endif    vlc_cond_destroy( &p_sys->wait );    vlc_mutex_destroy( &p_sys->lock );    free( p_sys );}

/***************************************************************************** * Close: *****************************************************************************/static void Close( vlc_object_t *p_this ){    services_discovery_t *p_sd = ( services_discovery_t* )p_this;    services_discovery_sys_t *p_sys  = p_sd->p_sys;    int i;    vlc_cancel (p_sys->thread);    vlc_join (p_sys->thread, NULL);    var_DelCallback( p_sd, "podcast-urls", UrlsChange, p_sys );    var_DelCallback( p_sd, "podcast-request", Request, p_sys );    vlc_cond_destroy( &p_sys->wait );    vlc_mutex_destroy( &p_sys->lock );    for( i = 0; i < p_sys->i_input; i++ )    {        input_thread_t *p_input = p_sd->p_sys->pp_input[i];        if( !p_input )            continue;        input_Stop( p_input, true );        vlc_thread_join( p_input );        vlc_object_release( p_input );        p_sd->p_sys->pp_input[i] = NULL;    }    free( p_sd->p_sys->pp_input );    for( i = 0; i < p_sys->i_urls; i++ ) free( p_sys->ppsz_urls[i] );    free( p_sys->ppsz_urls );    for( i = 0; i < p_sys->i_items; i++ ) vlc_gc_decref( p_sys->pp_items[i] );    free( p_sys->pp_items );    free( p_sys->psz_request );    free( p_sys );}

struct vlc_h2_output *vlc_h2_output_create(struct vlc_tls *tls, bool client){    struct vlc_h2_output *out = malloc(sizeof (*out));    if (unlikely(out == NULL))        return NULL;    out->tls = tls;    out->prio.first = NULL;    out->prio.last = &out->prio.first;    out->queue.first = NULL;    out->queue.last = &out->queue.first;    out->size = 0;    out->failed = false;    out->closing = false;    vlc_mutex_init(&out->lock);    vlc_cond_init(&out->wait);    void *(*cb)(void *) = client ? vlc_h2_client_output_thread                                 : vlc_h2_output_thread;    if (vlc_clone(&out->thread, cb, out, VLC_THREAD_PRIORITY_INPUT))    {        vlc_cond_destroy(&out->wait);        vlc_mutex_destroy(&out->lock);        free(out);        out = NULL;    }    return out;}

/***************************************************************************** * Close: destroy interface stuff *****************************************************************************/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;    var_DelCallback(pl_Get(p_intf), "activity", ItemChange, p_intf);    vlc_cancel(p_sys->thread);    vlc_join(p_sys->thread, NULL);    input_thread_t *p_input = pl_CurrentInput(p_intf);    if (p_input)    {        if (p_sys->b_state_cb)            var_DelCallback(p_input, "intf-event", PlayingChange, p_intf);        vlc_object_release(p_input);    }    int i;    for (i = 0; i < p_sys->i_songs; i++)        DeleteSong(&p_sys->p_queue[i]);    vlc_UrlClean(&p_sys->p_submit_url);#if 0 //NOT USED    free(p_sys->psz_nowp_host);    free(p_sys->psz_nowp_file);#endif    vlc_cond_destroy(&p_sys->wait);    vlc_mutex_destroy(&p_sys->lock);    free(p_sys);}

unsigned long _System _DLL_InitTerm(unsigned long hmod, unsigned long flag){    VLC_UNUSED (hmod);    switch (flag)    {        case 0 :    /* Initialization */            if(_CRT_init() == -1)                return 0;            vlc_mutex_init (&super_mutex);            vlc_cond_init (&super_variable);            vlc_threadvar_create (&thread_key, NULL);            vlc_rwlock_init (&config_lock);            vlc_rwlock_init (&msg_lock);            vlc_CPU_init ();            return 1;        case 1 :    /* Termination */            vlc_rwlock_destroy (&msg_lock);            vlc_rwlock_destroy (&config_lock);            vlc_threadvar_delete (&thread_key);            vlc_cond_destroy (&super_variable);            vlc_mutex_destroy (&super_mutex);            _CRT_term();            return 1;    }    return 0;   /* Failed */}

/***************************************************************************** * Close: close the target *****************************************************************************/static void Close( vlc_object_t * p_this ){    sout_access_out_t *p_access = (sout_access_out_t *) p_this;    sout_access_out_sys_t *p_sys = p_access->p_sys;    int i;    vlc_cancel( p_sys->p_thread->thread );    vlc_join( p_sys->p_thread->thread, NULL );    vlc_cond_destroy( &p_sys->p_thread->wait );    vlc_mutex_destroy( &p_sys->p_thread->lock );    block_FifoRelease( p_sys->p_thread->p_fifo_input );    block_FifoRelease( p_sys->p_thread->p_empty_blocks );    for( i = 0; i < 64; i++ ) /* RTMP_HEADER_STREAM_INDEX_MASK */    {        if( p_sys->p_thread->rtmp_headers_recv[i].body != NULL )        {            free( p_sys->p_thread->rtmp_headers_recv[i].body->body );            free( p_sys->p_thread->rtmp_headers_recv[i].body );        }    }    net_Close( p_sys->p_thread->fd );    vlc_object_release( p_sys->p_thread );    vlc_UrlClean( &p_sys->p_thread->url );    free( p_sys->p_thread->psz_application );    free( p_sys->p_thread->psz_media );    free( p_sys );}

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

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

/***************************************************************************** * Close: destroy interface stuff *****************************************************************************/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;    vlc_cancel(p_sys->thread);    vlc_join(p_sys->thread, NULL);    var_DelCallback(pl_Get(p_intf), "input-current", ItemChange, p_intf);    if (p_sys->p_input != NULL)    {        var_DelCallback(p_sys->p_input, "intf-event", PlayingChange, p_intf);        vlc_object_release(p_sys->p_input);    }    int i;    for (i = 0; i < p_sys->i_songs; i++)        DeleteSong(&p_sys->p_queue[i]);    vlc_UrlClean(&p_sys->p_submit_url);    vlc_UrlClean(&p_sys->p_nowp_url);    vlc_cond_destroy(&p_sys->wait);    vlc_mutex_destroy(&p_sys->lock);    free(p_sys);}

/************************************************************************** * Delete a media descriptor object **************************************************************************/void libvlc_media_release( libvlc_media_t *p_md ){    if (!p_md)        return;    p_md->i_refcount--;    if( p_md->i_refcount > 0 )        return;    if( p_md->p_subitems )        libvlc_media_list_release( p_md->p_subitems );    uninstall_input_item_observer( p_md );    vlc_gc_decref( p_md->p_input_item );    vlc_cond_destroy( &p_md->parsed_cond );    vlc_mutex_destroy( &p_md->parsed_lock );    /* Construct the event */    libvlc_event_t event;    event.type = libvlc_MediaFreed;    event.u.media_freed.md = p_md;    /* Send the event */    libvlc_event_send( p_md->p_event_manager, &event );    libvlc_event_manager_release( p_md->p_event_manager );    free( p_md );}

void playlist_preparser_Delete( playlist_preparser_t *p_preparser ){    vlc_mutex_lock( &p_preparser->lock );    /* Remove pending item to speed up preparser thread exit */    while( p_preparser->i_waiting > 0 )    {        preparser_entry_t *p_entry = p_preparser->pp_waiting[0];        vlc_gc_decref( p_entry->p_item );        free( p_entry );        REMOVE_ELEM( p_preparser->pp_waiting, p_preparser->i_waiting, 0 );    }    vlc_sem_post( &p_preparser->item_done );    while( p_preparser->b_live )        vlc_cond_wait( &p_preparser->wait, &p_preparser->lock );    vlc_mutex_unlock( &p_preparser->lock );    /* Destroy the item preparser */    vlc_sem_destroy( &p_preparser->item_done );    vlc_cond_destroy( &p_preparser->wait );    vlc_mutex_destroy( &p_preparser->lock );    if( p_preparser->p_fetcher != NULL )        playlist_fetcher_Delete( p_preparser->p_fetcher );    free( p_preparser );}

static void ReleaseDLSys(vlc_object_t *obj){    vlc_object_t *libvlc = VLC_OBJECT(obj->p_libvlc);    vlc_mutex_lock(&sys_lock);    struct decklink_sys_t *sys = (struct decklink_sys_t*)var_GetAddress(libvlc, "decklink-sys");    if (--sys->users == 0) {        msg_Dbg(obj, "Destroying decklink data");        vlc_mutex_destroy(&sys->lock);        vlc_cond_destroy(&sys->cond);        if (sys->p_output) {            sys->p_output->StopScheduledPlayback(0, NULL, 0);            sys->p_output->DisableVideoOutput();            sys->p_output->DisableAudioOutput();            sys->p_output->Release();        }        free(sys);        var_Destroy(libvlc, "decklink-sys");    }    vlc_mutex_unlock(&sys_lock);}

//BOOL WINAPI DllMain (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)BOOL WINAPI _CRT_INIT (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)   // sunqueen modify{    (void) hinstDll;    (void) lpvReserved;    switch (fdwReason)    {        case DLL_PROCESS_ATTACH:            InitializeCriticalSection (&clock_lock);            vlc_mutex_init (&super_mutex);            vlc_cond_init (&super_variable);            vlc_threadvar_create (&thread_key, NULL);            vlc_rwlock_init (&config_lock);            vlc_CPU_init ();            break;        case DLL_PROCESS_DETACH:            vlc_rwlock_destroy (&config_lock);            vlc_threadvar_delete (&thread_key);            vlc_cond_destroy (&super_variable);            vlc_mutex_destroy (&super_mutex);            DeleteCriticalSection (&clock_lock);            break;    }    return TRUE;}

//---------------------------------------------------------------------------// Close: destroy interface//---------------------------------------------------------------------------static void Close( vlc_object_t *p_this ){    intf_thread_t *p_intf = (intf_thread_t *)p_this;    msg_Dbg( p_intf, "closing skins2 module" );    /* Terminate input to ensure that our window provider is released. */    playlist_Deactivate( p_intf->p_sys->p_playlist );    vlc_mutex_lock( &skin_load.mutex );    skin_load.intf = NULL;    vlc_mutex_unlock( &skin_load.mutex);    AsyncQueue *pQueue = p_intf->p_sys->p_queue;    if( pQueue )    {        CmdGeneric *pCmd = new CmdExitLoop( p_intf );        if( pCmd )            pQueue->push( CmdGenericPtr( pCmd ) );    }    else    {        msg_Err( p_intf, "thread found already stopped (weird!)" );    }    vlc_join( p_intf->p_sys->thread, NULL );    vlc_mutex_destroy( &p_intf->p_sys->init_lock );    vlc_cond_destroy( &p_intf->p_sys->init_wait );    // Destroy structure    free( p_intf->p_sys );}