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