int vlc_sem_wait_i11e(vlc_sem_t *sem) { vlc_interrupt_t *ctx = vlc_interrupt_get(); if (ctx == NULL) return vlc_sem_wait(sem), 0; vlc_interrupt_prepare(ctx, vlc_interrupt_sem, sem); vlc_cleanup_push(vlc_interrupt_cleanup, ctx); vlc_sem_wait(sem); vlc_cleanup_pop(); return vlc_interrupt_finish(ctx); }
static void vlc_vidsplit_Prepare(vout_display_t *vd, picture_t *pic, subpicture_t *subpic, vlc_tick_t date) { vout_display_sys_t *sys = vd->sys; picture_Hold(pic); (void) subpic; vlc_mutex_lock(&sys->lock); if (video_splitter_Filter(&sys->splitter, sys->pictures, pic)) { vlc_mutex_unlock(&sys->lock); for (int i = 0; i < sys->splitter.i_output; i++) sys->pictures[i] = NULL; return; } vlc_mutex_unlock(&sys->lock); for (int i = 0; i < sys->splitter.i_output; i++) { struct vlc_vidsplit_part *part = &sys->parts[i]; vlc_sem_wait(&part->lock); sys->pictures[i] = vout_display_Prepare(part->display, sys->pictures[i], NULL, date); } }
static void flush(filter_t *filter) { filter_sys_t *sys = filter->p_sys; MMAL_BUFFER_HEADER_T *buffer; msg_Dbg(filter, "flush deinterlace filter"); 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"); while (atomic_load(&sys->input_in_transit) || atomic_load(&sys->output_in_transit)) vlc_sem_wait(&sys->sem); 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); } atomic_store(&sys->started, false); msg_Dbg(filter, "flush: done"); }
static void vlc_vidsplit_Close(vout_display_t *vd) { vout_display_sys_t *sys = vd->sys; int n = sys->splitter.i_output; for (int i = 0; i < n; i++) { struct vlc_vidsplit_part *part = &sys->parts[i]; vout_display_t *display; vlc_sem_wait(&part->lock); display = part->display; part->display = NULL; vlc_sem_post(&part->lock); if (display != NULL) vout_display_Delete(display); vout_window_Disable(part->window); vout_window_Delete(part->window); vlc_sem_destroy(&part->lock); } module_unneed(&sys->splitter, sys->splitter.p_module); video_format_Clean(&sys->splitter.fmt); vlc_mutex_destroy(&sys->lock); vlc_object_release(&sys->splitter); }
/* Open Interface */ static int Open( vlc_object_t *p_this, bool isDialogProvider ) { intf_thread_t *p_intf = (intf_thread_t *)p_this; #ifdef Q_WS_X11 if( !vlc_xlib_init( p_this ) ) return VLC_EGENERIC; char *display = var_CreateGetNonEmptyString( p_intf, "x11-display" ); Display *p_display = XOpenDisplay( x11_display ); if( !p_display ) { msg_Err( p_intf, "Could not connect to X server" ); free (display); return VLC_EGENERIC; } XCloseDisplay( p_display ); #else char *display = NULL; #endif QMutexLocker locker (&lock); if (busy) { msg_Err (p_this, "cannot start Qt4 multiple times"); free (display); return VLC_EGENERIC; } /* Allocations of p_sys */ intf_sys_t *p_sys = p_intf->p_sys = new intf_sys_t; p_intf->p_sys->b_isDialogProvider = isDialogProvider; p_sys->p_mi = NULL; p_sys->p_playlist = pl_Get( p_intf ); /* */ #ifdef Q_WS_X11 x11_display = display; #endif vlc_sem_init (&ready, 0); if( vlc_clone( &p_sys->thread, Thread, p_intf, VLC_THREAD_PRIORITY_LOW ) ) { delete p_sys; free (display); return VLC_ENOMEM; } /* */ vlc_sem_wait (&ready); vlc_sem_destroy (&ready); busy = active = true; if( !p_sys->b_isDialogProvider ) { playlist_t *pl = pl_Get(p_this); var_Create (pl, "qt4-iface", VLC_VAR_ADDRESS); var_SetAddress (pl, "qt4-iface", p_this); } return VLC_SUCCESS; }
static int flush_decoder(decoder_t *dec) { decoder_sys_t *sys = dec->p_sys; MMAL_BUFFER_HEADER_T *buffer; MMAL_STATUS_T status; int ret = 0; msg_Dbg(dec, "Flushing decoder ports..."); mmal_port_disable(sys->output); mmal_port_disable(sys->input); mmal_port_flush(sys->output); mmal_port_flush(sys->input); /* Reload extradata if available */ if (dec->fmt_in.i_codec == VLC_CODEC_H264) { if (dec->fmt_in.i_extra > 0) { status = mmal_format_extradata_alloc(sys->input->format, dec->fmt_in.i_extra); if (status == MMAL_SUCCESS) { memcpy(sys->input->format->extradata, dec->fmt_in.p_extra, dec->fmt_in.i_extra); sys->input->format->extradata_size = dec->fmt_in.i_extra; } else { msg_Err(dec, "Failed to allocate extra format data on input port %s (status=%"PRIx32" %s)", sys->input->name, status, mmal_status_to_string(status)); } } } status = mmal_port_format_commit(sys->input); if (status != MMAL_SUCCESS) { msg_Err(dec, "Failed to commit format for input port %s (status=%"PRIx32" %s)", sys->input->name, status, mmal_status_to_string(status)); } mmal_port_enable(sys->output, output_port_cb); mmal_port_enable(sys->input, input_port_cb); while (atomic_load(&sys->output_in_transit)) vlc_sem_wait(&sys->sem); /* Free pictures which are decoded but have not yet been sent * out to the core */ while ((buffer = mmal_queue_get(sys->decoded_pictures))) { picture_t *pic = (picture_t *)buffer->user_data; picture_Release(pic); if (sys->output_pool) { buffer->user_data = NULL; buffer->alloc_size = 0; buffer->data = NULL; mmal_buffer_header_release(buffer); } } msg_Dbg(dec, "Ports flushed, returning to normal operation"); return ret; }
void vlc_join (vlc_thread_t handle, void **result) { vlc_sem_wait (&handle->finished); vlc_sem_destroy (&handle->finished); int val = pthread_join (handle->thread, result); VLC_THREAD_ASSERT ("joining thread"); clean_detached_thread(handle); }
void libvlc_wait( libvlc_instance_t *p_i ) { vlc_sem_t sem; vlc_sem_init( &sem, 0 ); libvlc_set_exit_handler( p_i, libvlc_wait_wakeup, &sem ); vlc_sem_wait( &sem ); libvlc_set_exit_handler( p_i, NULL, NULL ); vlc_sem_destroy( &sem ); }
int vlc_sem_wait_i11e(vlc_sem_t *sem) { vlc_interrupt_t *ctx = vlc_threadvar_get(vlc_interrupt_var); if (ctx == NULL) return vlc_sem_wait(sem), 0; int ret = vlc_interrupt_prepare(ctx, vlc_interrupt_sem, sem); if (ret) { vlc_testcancel(); return ret; } vlc_cleanup_push(vlc_interrupt_cleanup, ctx); vlc_sem_wait(sem); vlc_cleanup_pop(); return vlc_interrupt_finish(ctx); }
void vlc_join (vlc_thread_t handle, void **result) { vlc_sem_wait (&handle->finished); vlc_sem_destroy (&handle->finished); int val = pthread_join (handle->thread, result); VLC_THREAD_ASSERT ("joining thread"); vlc_mutex_destroy(&handle->lock); free(handle); }
/** * Open the module * @param p_this: the filter object * @return VLC_SUCCESS or vlc error codes */ static int Open( vlc_object_t * p_this ) { filter_t *p_filter = (filter_t *)p_this; filter_sys_t *p_sys; /* Test the audio format */ if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 || p_filter->fmt_out.audio.i_format != VLC_CODEC_FL32 ) { msg_Warn( p_filter, "bad input or output format" ); return VLC_EGENERIC; } if( !AOUT_FMTS_SIMILAR( &p_filter->fmt_in.audio, &p_filter->fmt_out.audio ) ) { msg_Warn( p_filter, "input and outut are not similar" ); return VLC_EGENERIC; } p_filter->pf_audio_filter = DoWork; p_sys = p_filter->p_sys = (filter_sys_t*)malloc( sizeof( *p_sys ) ); if( !p_sys ) return VLC_ENOMEM; /* Create the object for the thread */ vlc_sem_init( &p_sys->ready, 0 ); p_sys->b_error = false; p_sys->b_quit = false; p_sys->i_width = var_InheritInteger( p_filter, "projectm-width" ); p_sys->i_height = var_InheritInteger( p_filter, "projectm-height" ); p_sys->i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio ); vlc_mutex_init( &p_sys->lock ); p_sys->p_buffer = NULL; p_sys->i_buffer_size = 0; p_sys->i_nb_samples = 0; /* Create the thread */ if( vlc_clone( &p_sys->thread, Thread, p_filter, VLC_THREAD_PRIORITY_LOW ) ) goto error; vlc_sem_wait( &p_sys->ready ); if( p_sys->b_error ) { vlc_join( p_sys->thread, NULL ); goto error; } return VLC_SUCCESS; error: vlc_sem_destroy( &p_sys->ready ); free (p_sys ); return VLC_EGENERIC; }
/** * Open the module. * @param p_this: the filter object * @return VLC_SUCCESS or vlc error codes */ static int Open(vlc_object_t * p_this) { filter_t *p_filter = (filter_t *)p_this; filter_sys_t *p_sys; p_sys = p_filter->p_sys = (filter_sys_t*)malloc(sizeof(*p_sys)); if (p_sys == NULL) return VLC_ENOMEM; /* Create the object for the thread */ vlc_sem_init(&p_sys->ready, 0); p_sys->b_error = false; p_sys->i_width = var_InheritInteger(p_filter, "glspectrum-width"); p_sys->i_height = var_InheritInteger(p_filter, "glspectrum-height"); p_sys->i_channels = aout_FormatNbChannels(&p_filter->fmt_in.audio); p_sys->i_prev_nb_samples = 0; p_sys->p_prev_s16_buff = NULL; p_sys->f_rotationAngle = 0; p_sys->f_rotationIncrement = ROTATION_INCREMENT; /* Fetch the FFT window parameters */ window_get_param( VLC_OBJECT( p_filter ), &p_sys->wind_param ); /* Create the FIFO for the audio data. */ p_sys->fifo = block_FifoNew(); if (p_sys->fifo == NULL) goto error; /* Create the thread */ if (vlc_clone(&p_sys->thread, Thread, p_filter, VLC_THREAD_PRIORITY_VIDEO)) goto error; /* Wait for the displaying thread to be ready. */ vlc_sem_wait(&p_sys->ready); if (p_sys->b_error) { vlc_join(p_sys->thread, NULL); goto error; } p_filter->fmt_in.audio.i_format = VLC_CODEC_FL32; p_filter->fmt_out.audio = p_filter->fmt_in.audio; p_filter->pf_audio_filter = DoWork; return VLC_SUCCESS; error: vlc_sem_destroy(&p_sys->ready); free(p_sys); return VLC_EGENERIC; }
/** * Open the module * @param p_this: the filter object * @return VLC_SUCCESS or vlc error codes */ static int Open( vlc_object_t * p_this ) { filter_t *p_filter = (filter_t *)p_this; filter_sys_t *p_sys; /* Test the audio format */ if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 ) { msg_Warn( p_filter, "bad input format" ); return VLC_EGENERIC; } p_sys = p_filter->p_sys = (filter_sys_t*)malloc( sizeof( *p_sys ) ); if( unlikely( !p_sys ) ) { return VLC_ENOMEM; } /* Create the object for the thread */ vlc_sem_init( &p_sys->ready, 0 ); p_sys->b_error = false; p_sys->b_quit = false; p_sys->i_width = var_InheritInteger( p_filter, "vsxu-width" ); p_sys->i_height = var_InheritInteger( p_filter, "vsxu-height" ); p_sys->i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio ); vlc_mutex_init( &p_sys->lock ); vlc_mutex_init( &p_sys->cyclic_block_mutex ); p_sys->vsxu_cyclic_buffer = new cyclic_block_queue(); /* Create the thread */ if( vlc_clone( &p_sys->thread, Thread, p_filter, VLC_THREAD_PRIORITY_LOW ) ) goto error; vlc_sem_wait( &p_sys->ready ); if( p_sys->b_error ) { vlc_join( p_sys->thread, NULL ); goto error; } p_filter->fmt_out.audio = p_filter->fmt_in.audio; p_filter->pf_audio_filter = DoWork; return VLC_SUCCESS; error: vlc_sem_destroy( &p_sys->ready ); free (p_sys ); return VLC_EGENERIC; }
static void vlc_vidsplit_window_Closed(vout_window_t *wnd) { struct vlc_vidsplit_part *part = wnd->owner.sys; vout_display_t *display; vlc_sem_wait(&part->lock); display = part->display; part->display = NULL; vlc_sem_post(&part->lock); if (display != NULL) vout_display_Delete(display); }
static void vlc_vidsplit_window_Resized(vout_window_t *wnd, unsigned width, unsigned height) { struct vlc_vidsplit_part *part = wnd->owner.sys; vlc_sem_wait(&part->lock); part->width = width; part->height = height; if (part->display != NULL) vout_display_SetSize(part->display, width, height); vlc_sem_post(&part->lock); }
static void test_media_subitems_media(libvlc_media_t *media, bool play) { libvlc_media_add_option(media, ":ignore-filetypes= "); bool subitems_found[TEST_SUBITEMS_COUNT] = { 0 }; vlc_sem_t sem; vlc_sem_init (&sem, 0); libvlc_event_manager_t *em = libvlc_media_event_manager (media); libvlc_event_attach (em, libvlc_MediaSubItemTreeAdded, subitem_tree_added, &sem); libvlc_event_attach (em, libvlc_MediaSubItemAdded, subitem_added, subitems_found); if (play) { /* XXX: libvlc_media_parse_async won't work with fd, since it won't be * preparsed because fd:// is an unknown type, so play the file to * force parsing. */ libvlc_media_player_t *mp = libvlc_media_player_new_from_media (media); assert (mp); assert (libvlc_media_player_play (mp) != -1); vlc_sem_wait (&sem); libvlc_media_player_release (mp); } else { libvlc_media_parse_async (media); vlc_sem_wait (&sem); } vlc_sem_destroy (&sem); for (unsigned i = 0; i < TEST_SUBITEMS_COUNT; ++i) { log ("test if %s was added\n", test_media_subitems_list[i].file); assert (subitems_found[i]); } }
/***************************************************************************** * ALSAThread: asynchronous thread used to DMA the data to the device *****************************************************************************/ static void* ALSAThread( void *data ) { aout_instance_t * p_aout = data; struct aout_sys_t * p_sys = p_aout->output.p_sys; /* Wait for the exact time to start playing (avoids resampling) */ vlc_sem_wait( &p_sys->wait ); mwait( p_sys->start_date - AOUT_PTS_TOLERANCE / 4 ); vlc_cleanup_push( pcm_drop, p_sys->p_snd_pcm ); for(;;) ALSAFill( p_aout ); assert(0); vlc_cleanup_pop(); }
/** * This function preparses an item when needed. */ static void Preparse( playlist_preparser_t *preparser, input_item_t *p_item, input_item_meta_request_option_t i_options ) { vlc_mutex_lock( &p_item->lock ); int i_type = p_item->i_type; bool b_net = p_item->b_net; vlc_mutex_unlock( &p_item->lock ); bool b_preparse = false; switch (i_type) { case ITEM_TYPE_FILE: case ITEM_TYPE_DIRECTORY: case ITEM_TYPE_PLAYLIST: case ITEM_TYPE_NODE: if (!b_net || i_options & META_REQUEST_OPTION_SCOPE_NETWORK) b_preparse = true; break; } /* Do not preparse if it is already done (like by playing it) */ if( b_preparse && !input_item_IsPreparsed( p_item ) ) { input_thread_t *input = input_CreatePreparser( preparser->object, p_item ); if( input == NULL ) return; var_AddCallback( input, "intf-event", InputEvent, &preparser->item_done ); if( input_Start( input ) == VLC_SUCCESS ) vlc_sem_wait( &preparser->item_done ); var_DelCallback( input, "intf-event", InputEvent, &preparser->item_done ); /* Normally, the input is already stopped since we waited for it. But * if the playlist preparser is being deleted, then the input might * still be running. Force it to stop. */ input_Stop( input ); input_Close( input ); var_SetAddress( preparser->object, "item-change", p_item ); } input_item_SetPreparsed( p_item, true ); input_item_SignalPreparseEnded( p_item ); }
static void media_parse_sync(libvlc_media_t *p_m) { vlc_sem_t sem; vlc_sem_init(&sem, 0); libvlc_event_manager_t *p_em = libvlc_media_event_manager(p_m); libvlc_event_attach(p_em, libvlc_MediaParsedChanged, finished_event, &sem); int i_ret = libvlc_media_parse_with_options(p_m, libvlc_media_parse_local); assert(i_ret == 0); vlc_sem_wait (&sem); libvlc_event_detach(p_em, libvlc_MediaParsedChanged, finished_event, &sem); vlc_sem_destroy (&sem); }
/***************************************************************************** * Module callbacks *****************************************************************************/ static int Open( vlc_object_t *p_this ) { intf_thread_t *p_intf = (intf_thread_t *)p_this; intf_sys_t *p_sys; vlc_value_t val; if( !vlc_xlib_init( p_this ) ) return VLC_EGENERIC; /* Allocate instance and initialize some members */ p_intf->p_sys = p_sys = malloc( sizeof( intf_sys_t ) ); if( p_intf->p_sys == NULL ) return VLC_ENOMEM; p_sys->p_playlist = pl_Get( p_intf ); p_sys->p_input = NULL; p_sys->p_main_window = NULL; p_sys->p_video_window = NULL; p_sys->p_control_window = NULL; p_sys->b_fullscreen = false; p_sys->i_event = 0; vlc_spin_init( &p_sys->event_lock ); /* Create separate thread for main interface */ vlc_sem_init (&p_sys->ready, 0); if( vlc_clone( &p_sys->thread, Thread, p_intf, VLC_THREAD_PRIORITY_LOW ) ) { free (p_sys); return VLC_ENOMEM; } /* Wait for interface thread to be fully initialised */ vlc_sem_wait (&p_sys->ready); vlc_sem_destroy (&p_sys->ready); var_Create (p_this->p_libvlc, "hildon-iface", VLC_VAR_ADDRESS); val.p_address = p_this; var_Set (p_this->p_libvlc, "hildon-iface", val); return VLC_SUCCESS; }
static void test_media_preparsed(const char** argv, int argc) { // We use this image file because "empty.voc" has no track. const char * file = SRCDIR"/samples/image.jpg"; log ("Testing set_media\n"); libvlc_instance_t *vlc = libvlc_new (argc, argv); assert (vlc != NULL); libvlc_media_t *media = libvlc_media_new_path (vlc, file); assert (media != NULL); vlc_sem_t sem; vlc_sem_init (&sem, 0); // Check to see if we are properly receiving the event. libvlc_event_manager_t *em = libvlc_media_event_manager (media); libvlc_event_attach (em, libvlc_MediaParsedChanged, preparsed_changed, &sem); // Parse the media. This is synchronous. libvlc_media_parse_async(media); // Wait for preparsed event vlc_sem_wait (&sem); vlc_sem_destroy (&sem); // We are good, now check Elementary Stream info. libvlc_media_track_t **tracks; unsigned nb_tracks = libvlc_media_tracks_get (media, &tracks); assert (nb_tracks == 1); assert (tracks[0]->i_type == libvlc_track_video); libvlc_media_tracks_release (tracks, nb_tracks); libvlc_media_release (media); libvlc_release (vlc); }
static void mediaplayer_play_sync(libvlc_media_player_t *p_mp) { vlc_sem_t sem; vlc_sem_init(&sem, 0); libvlc_event_manager_t *p_em = libvlc_media_player_event_manager(p_mp); libvlc_event_attach(p_em, libvlc_MediaPlayerPlaying, finished_event, &sem); libvlc_event_attach(p_em, libvlc_MediaPlayerEndReached, finished_event, &sem); libvlc_event_attach(p_em, libvlc_MediaPlayerEncounteredError, finished_event, &sem); int i_ret = libvlc_media_player_play(p_mp); assert(i_ret == 0); vlc_sem_wait (&sem); libvlc_event_detach(p_em, libvlc_MediaPlayerPlaying, finished_event, &sem); libvlc_event_detach(p_em, libvlc_MediaPlayerEndReached, finished_event, &sem); libvlc_event_detach(p_em, libvlc_MediaPlayerEncounteredError, finished_event, &sem); libvlc_media_player_stop(p_mp); vlc_sem_destroy (&sem); }
/* Open Interface */ static int Open( vlc_object_t *p_this, bool isDialogProvider ) { intf_thread_t *p_intf = (intf_thread_t *)p_this; #if defined (QT5_HAS_X11) || defined (Q_WS_X11) if( !vlc_xlib_init( p_this ) ) return VLC_EGENERIC; Display *p_display = XOpenDisplay( NULL ); if( !p_display ) { msg_Err( p_intf, "Could not connect to X server" ); return VLC_EGENERIC; } XCloseDisplay( p_display ); #endif QMutexLocker locker (&lock); if (busy) { msg_Err (p_this, "cannot start Qt multiple times"); return VLC_EGENERIC; } /* Allocations of p_sys */ intf_sys_t *p_sys = p_intf->p_sys = new intf_sys_t; p_intf->p_sys->b_isDialogProvider = isDialogProvider; p_sys->p_mi = NULL; p_sys->pl_model = NULL; /* set up the playlist to work on */ if( isDialogProvider ) p_intf->p_sys->p_playlist = pl_Get( (intf_thread_t *)p_intf->p_parent ); else p_intf->p_sys->p_playlist = pl_Get( p_intf ); /* */ vlc_sem_init (&ready, 0); #ifdef Q_OS_MAC /* Run mainloop on the main thread as Cocoa requires */ libvlc_SetExitHandler( p_intf->p_libvlc, Abort, p_intf ); Thread( (void *)p_intf ); #else if( vlc_clone( &p_sys->thread, Thread, p_intf, VLC_THREAD_PRIORITY_LOW ) ) { delete p_sys; return VLC_ENOMEM; } #endif /* Wait for the interface to be ready. This prevents the main * LibVLC thread from starting video playback before we can create * an embedded video window. */ vlc_sem_wait (&ready); vlc_sem_destroy (&ready); busy = active = true; #ifndef Q_OS_MAC if( !isDialogProvider ) RegisterIntf( p_intf ); #endif return VLC_SUCCESS; }
int main(void) { struct vlc_h2_output *out; /* Dummy */ out = vlc_h2_output_create(NULL, false); assert(out != NULL); vlc_h2_output_destroy(out); vlc_sem_init(&rx, 0); out = vlc_h2_output_create(NULL, expect_hello = true); assert(out != NULL); vlc_h2_output_destroy(out); vlc_sem_destroy(&rx); /* Success */ vlc_sem_init(&rx, 0); out = vlc_h2_output_create(NULL, false); assert(out != NULL); assert(vlc_h2_output_send_prio(out, NULL) == -1); assert(vlc_h2_output_send_prio(out, frame(0)) == 0); assert(vlc_h2_output_send_prio(out, frame(1)) == 0); assert(vlc_h2_output_send(out, NULL) == -1); assert(vlc_h2_output_send(out, frame(2)) == 0); assert(vlc_h2_output_send(out, frame(3)) == 0); assert(vlc_h2_output_send(out, frame_list(frame(4), frame(5), frame(6), NULL)) == 0); assert(vlc_h2_output_send(out, frame(7)) == 0); for (unsigned i = 0; i < 8; i++) vlc_sem_wait(&rx); assert(vlc_h2_output_send_prio(out, frame(8)) == 0); assert(vlc_h2_output_send(out, frame(9)) == 0); vlc_h2_output_destroy(out); vlc_sem_destroy(&rx); /* Failure */ send_failure = true; vlc_sem_init(&rx, 0); counter = 10; out = vlc_h2_output_create(NULL, false); assert(out != NULL); assert(vlc_h2_output_send(out, frame(10)) == 0); for (unsigned char i = 11; vlc_h2_output_send(out, frame(i)) == 0; i++) msleep(CLOCK_FREQ/10); /* eventually, it should start failing */ assert(vlc_h2_output_send(out, frame(0)) == -1); assert(vlc_h2_output_send_prio(out, frame(0)) == -1); vlc_h2_output_destroy(out); vlc_sem_destroy(&rx); /* Failure during hello */ vlc_sem_init(&rx, 0); counter = 0; out = vlc_h2_output_create(NULL, expect_hello = true); assert(out != NULL); vlc_sem_wait(&rx); for (unsigned char i = 1; vlc_h2_output_send_prio(out, frame(i)) == 0; i++) msleep(CLOCK_FREQ/10); assert(vlc_h2_output_send(out, frame(0)) == -1); assert(vlc_h2_output_send_prio(out, frame(0)) == -1); vlc_h2_output_destroy(out); vlc_sem_destroy(&rx); return 0; }