static void list(struct event_channel *channel, unsigned int descriptor)
{
struct record record;
file_open(descriptor);
event_reply(channel, EVENT_DATA);
while (file_readall(descriptor, &record, sizeof (struct record)))
{
if (event_avail(&channel->o) < record.length + 1)
{
event_place(channel->o.header.target, &channel->o);
event_reset(&channel->o);
}
event_append(&channel->o, record.length, record.name);
event_append(&channel->o, 1, "\n");
if (!file_step(descriptor))
break;
}
event_place(channel->o.header.target, &channel->o);
file_close(descriptor);
}
static void Reset(Jitter_Buffer *jitter_buffer) {
//free frame list
Frame_Buffer * frame = jitter_buffer->frameList.next;
Frame_Buffer * next_frame;
while(frame != &jitter_buffer->frameList) {
next_frame = frame->next;
pj_list_erase(frame);
list_alloc_insert(frame, &jitter_buffer->frame_alloc);
frame = next_frame;
}
frame = jitter_buffer->decodingFrameList.next;
while(frame != &jitter_buffer->decodingFrameList) {
next_frame = frame->next;
if(frame->frame_status != FRAME_STATUS_DECODING) {
//not decoding ,release it
pj_list_erase(frame);
list_alloc_insert(frame, &jitter_buffer->frame_alloc);
}
frame = next_frame;
}
jitter_buffer->number_of_frames = 0;
//reset decode state
decode_state_reset(&jitter_buffer->decode_state);
//reset jitter estimator
jitter_estimator_reset(&jitter_buffer->jitter_estimator);
//reset inter_frame_delay
inter_frame_delay_reset(&jitter_buffer->inter_frame_delay);
//reset rtt
if(jitter_buffer->high_rtt_threshold_ms == -1)
jitter_buffer->rttMs = DEFAULT_RTT_MS;
else
jitter_buffer->rttMs = 0;
jitter_buffer->nack_seq_num = 0;
jitter_buffer->waiting_for_key_frame = PJ_TRUE;
//reset event
event_reset(jitter_buffer->frame_event);
event_reset(jitter_buffer->packet_event);
jitter_buffer->first_packet = PJ_FALSE;
//waiting for completed frame
jitter_buffer->waiting_for_completed_frame.timestamp = 0;
jitter_buffer->waiting_for_completed_frame.frame_size = 0;
jitter_buffer->waiting_for_completed_frame.latest_packet_timestamp = -1;
}
static int
machine_select_machine( fuse_machine_info *machine )
{
int width, height, i;
int capabilities;
machine_current = machine;
settings_set_string( &settings_current.start_machine, machine->id );
tstates = 0;
/* Reset the event stack */
event_reset();
if( event_add( 0, timer_event ) ) return 1;
if( event_add( machine->timings.tstates_per_frame, spectrum_frame_event ) )
return 1;
sound_end();
if( uidisplay_end() ) return 1;
capabilities = libspectrum_machine_capabilities( machine->machine );
/* Set screen sizes here */
if( capabilities & LIBSPECTRUM_MACHINE_CAPABILITY_TIMEX_VIDEO ) {
width = DISPLAY_SCREEN_WIDTH;
height = 2*DISPLAY_SCREEN_HEIGHT;
} else {
width = DISPLAY_ASPECT_WIDTH;
height = DISPLAY_SCREEN_HEIGHT;
}
if( uidisplay_init( width, height ) ) return 1;
sound_init( settings_current.sound_device );
/* Mark RAM as not-present/read-only. The machine's reset function will
* mark available pages as present/writeable.
*/
for( i = 0; i < 2 * SPECTRUM_RAM_PAGES; i++ )
memory_map_ram[i].writable = 0;
/* Do a hard reset */
if( machine_reset( 1 ) ) return 1;
/* And the dock menu item */
if( capabilities & LIBSPECTRUM_MACHINE_CAPABILITY_TIMEX_DOCK ) {
ui_menu_activate( UI_MENU_ITEM_MEDIA_CARTRIDGE_DOCK_EJECT, 0 );
}
/* Reset any dialogue boxes etc. which contain machine-dependent state */
ui_widgets_reset();
return 0;
}
int
event_shutdown(events_t *ev)
{
if(ev->handlers)
free(ev->handlers);
event_reset(ev);
ev->currfd = -1;
ev->max_fd = -1;
ev->nevents = 0;
return 0;
}
static int
machine_select_machine( fuse_machine_info *machine )
{
int width, height;
int capabilities;
machine_current = machine;
settings_set_string( &settings_current.start_machine, machine->id );
tstates = 0;
/* Reset the event stack */
event_reset();
event_add( 0, timer_event );
event_add( machine->timings.tstates_per_frame, spectrum_frame_event );
sound_end();
if( uidisplay_end() ) return 1;
capabilities = libspectrum_machine_capabilities( machine->machine );
/* Set screen sizes here */
if( capabilities & LIBSPECTRUM_MACHINE_CAPABILITY_TIMEX_VIDEO ) {
width = DISPLAY_SCREEN_WIDTH;
height = 2*DISPLAY_SCREEN_HEIGHT;
} else {
width = DISPLAY_ASPECT_WIDTH;
height = DISPLAY_SCREEN_HEIGHT;
}
if( uidisplay_init( width, height ) ) return 1;
sound_init( settings_current.sound_device );
/* Do a hard reset */
if( machine_reset( 1 ) ) return 1;
/* And the dock menu item */
if( capabilities & LIBSPECTRUM_MACHINE_CAPABILITY_TIMEX_DOCK ) {
ui_menu_activate( UI_MENU_ITEM_MEDIA_CARTRIDGE_DOCK_EJECT, 0 );
}
/* Reset any dialogue boxes etc. which contain machine-dependent state */
ui_widgets_reset();
return 0;
}
void event_test(void)
{
pthread_t threads[2];
assert(0 == event_create(&ev1));
assert(0 == event_create(&ev2));
event_signal(&ev1);
event_reset(&ev1);
thread_create(&threads[0], thread0, NULL);
thread_create(&threads[1], thread1, NULL);
thread_destroy(threads[0]);
thread_destroy(threads[1]);
assert(0 == event_destroy(&ev1));
assert(0 == event_destroy(&ev2));
}
int
event_initialize(events_t *ev)
{
// Current fd es usado para el iterator (get next event)
ev->currfd = -1;
ev->maxfds = FD_SETSIZE - 24; /* dejamos algunos fd's libres par ala app. */
ev->max_fd = -1; /* socket maximo en -1 */
ev->nevents = 0;
ev->handlers = (handler_t *) calloc(ev->maxfds, sizeof(handler_t));
if(ev->handlers == NULL)
{
perror("event_initialize():");
return -1;
}
event_reset(ev);
return 0;
}
PJ_DEF(pj_ssize_t) jitter_buffer_nextTimestamp(Jitter_Buffer *jitter_buffer, pj_uint32_t max_wait_time_ms,
pjmedia_frame_type *frame_type, pj_ssize_t *next_render_time) {
//running
if(!jitter_buffer->running)
return -1;
if(pj_mutex_lock(jitter_buffer->jb_mutex) != PJ_SUCCESS) {
return -1;
}
//clean old frames
CleanOldFrames(jitter_buffer);
pj_ssize_t timestamp = -1;
//get first frame
Frame_Buffer *frame = jitter_buffer->frameList.next;
//if no first frame , wait 'max_wait_time_ms'
if(frame == &jitter_buffer->frameList) {
if(max_wait_time_ms > 0) {
event_reset(jitter_buffer->frame_event); //reset event for next waiting
pj_mutex_unlock(jitter_buffer->jb_mutex); //realse lock
if(event_wait(jitter_buffer->frame_event, max_wait_time_ms) == WAIT_RET_SIGNAL) {
CleanOldFrames(jitter_buffer); //jitter buffer status may be changed in other threads
frame = jitter_buffer->frameList.next;
}
pj_mutex_lock(jitter_buffer->jb_mutex);
}
}
//no first frame ,return
if(frame == &jitter_buffer->frameList) {
pj_mutex_unlock(jitter_buffer->jb_mutex);
return timestamp;
}
//get values
*next_render_time = frame->renderTimeMs;
*frame_type = frame->frame_type;
timestamp = (pj_ssize_t)frame->ts;
pj_mutex_unlock(jitter_buffer->jb_mutex);
return timestamp;
}
void
io_wait_dowork (struct context *c, const unsigned int flags)
{
unsigned int socket = 0;
unsigned int tuntap = 0;
struct event_set_return esr[4];
/* These shifts all depend on EVENT_READ and EVENT_WRITE */
static int socket_shift = 0; /* depends on SOCKET_READ and SOCKET_WRITE */
static int tun_shift = 2; /* depends on TUN_READ and TUN_WRITE */
static int err_shift = 4; /* depends on ES_ERROR */
#ifdef ENABLE_MANAGEMENT
static int management_shift = 6; /* depends on MANAGEMENT_READ and MANAGEMENT_WRITE */
#endif
/*
* Decide what kind of events we want to wait for.
*/
event_reset (c->c2.event_set);
/*
* On win32 we use the keyboard or an event object as a source
* of asynchronous signals.
*/
if (flags & IOW_WAIT_SIGNAL)
wait_signal (c->c2.event_set, (void*)&err_shift);
/*
* If outgoing data (for TCP/UDP port) pending, wait for ready-to-send
* status from TCP/UDP port. Otherwise, wait for incoming data on
* TUN/TAP device.
*/
if (flags & IOW_TO_LINK)
{
if (flags & IOW_SHAPER)
{
/*
* If sending this packet would put us over our traffic shaping
* quota, don't send -- instead compute the delay we must wait
* until it will be OK to send the packet.
*/
#ifdef ENABLE_FEATURE_SHAPER
int delay = 0;
/* set traffic shaping delay in microseconds */
if (c->options.shaper)
delay = max_int (delay, shaper_delay (&c->c2.shaper));
if (delay < 1000)
{
socket |= EVENT_WRITE;
}
else
{
shaper_soonest_event (&c->c2.timeval, delay);
}
#else /* ENABLE_FEATURE_SHAPER */
socket |= EVENT_WRITE;
#endif /* ENABLE_FEATURE_SHAPER */
}
else
{
socket |= EVENT_WRITE;
}
}
else if (!((flags & IOW_FRAG) && TO_LINK_FRAG (c)))
{
if (flags & IOW_READ_TUN)
tuntap |= EVENT_READ;
}
/*
* If outgoing data (for TUN/TAP device) pending, wait for ready-to-send status
* from device. Otherwise, wait for incoming data on TCP/UDP port.
*/
if (flags & IOW_TO_TUN)
{
tuntap |= EVENT_WRITE;
}
else
{
if (flags & IOW_READ_LINK)
socket |= EVENT_READ;
}
/*
* outgoing bcast buffer waiting to be sent?
*/
if (flags & IOW_MBUF)
socket |= EVENT_WRITE;
/*
* Force wait on TUN input, even if also waiting on TCP/UDP output
*/
if (flags & IOW_READ_TUN_FORCE)
tuntap |= EVENT_READ;
/*
* Configure event wait based on socket, tuntap flags.
*/
socket_set (c->c2.link_socket, c->c2.event_set, socket, (void*)&socket_shift, NULL);
tun_set (c->c1.tuntap, c->c2.event_set, tuntap, (void*)&tun_shift, NULL);
#ifdef ENABLE_MANAGEMENT
if (management)
management_socket_set (management, c->c2.event_set, (void*)&management_shift, NULL);
#endif
/*
* Possible scenarios:
* (1) tcp/udp port has data available to read
* (2) tcp/udp port is ready to accept more data to write
* (3) tun dev has data available to read
* (4) tun dev is ready to accept more data to write
* (5) we received a signal (handler sets signal_received)
* (6) timeout (tv) expired
*/
c->c2.event_set_status = ES_ERROR;
if (!c->sig->signal_received)
{
if (!(flags & IOW_CHECK_RESIDUAL) || !socket_read_residual (c->c2.link_socket))
{
int status;
#ifdef ENABLE_DEBUG
if (check_debug_level (D_EVENT_WAIT))
show_wait_status (c);
#endif
/*
* Wait for something to happen.
*/
status = event_wait (c->c2.event_set, &c->c2.timeval, esr, SIZE(esr));
check_status (status, "event_wait", NULL, NULL);
if (status > 0)
{
int i;
c->c2.event_set_status = 0;
for (i = 0; i < status; ++i)
{
const struct event_set_return *e = &esr[i];
c->c2.event_set_status |= ((e->rwflags & 3) << *((int*)e->arg));
}
}
else if (status == 0)
{
c->c2.event_set_status = ES_TIMEOUT;
}
}
else
{
c->c2.event_set_status = SOCKET_READ;
}
}
/* 'now' should always be a reasonably up-to-date timestamp */
update_time ();
/* set signal_received if a signal was received */
if (c->c2.event_set_status & ES_ERROR)
get_signal (&c->sig->signal_received);
dmsg (D_EVENT_WAIT, "I/O WAIT status=0x%04x", c->c2.event_set_status);
}
void event_stop(void)
{
//TIMSK &= ~(1<<OCIE2); // Disable timer2 ISR
enable &= ~(1<<ENABLE_EVENT);
event_reset();
}
PJ_DEF(Frame_Buffer *) jitter_buffer_getCompleteFrameForDecoding(Jitter_Buffer *jitter_buffer, pj_uint32_t max_wait_time_ms) {
//running
if(!jitter_buffer->running)
return NULL;
if(pj_mutex_lock(jitter_buffer->jb_mutex) != PJ_SUCCESS) { //error
return NULL;
}
/*{
char buf[1024];
getFrameInfo(&jitter_buffer->frameList, &jitter_buffer->decode_state, buf, 1024);
PJ_LOG(4, (THIS_FILE, "jb status:\n%s\n", buf));
}*/
//the first frame must be a key frame
if(jitter_buffer->decode_state.inited == PJ_FALSE)
jitter_buffer->waiting_for_key_frame == PJ_TRUE;
//clean old frames
CleanOldFrames(jitter_buffer);
//get complete , continuous frame
Frame_Buffer * frame = findOldestCompleteContinuousFrame(jitter_buffer);
//if not got, try to wait a frame
if(frame == NULL) {
if(max_wait_time_ms == 0)
goto ON_RET;
pj_timestamp current ;
pj_get_timestamp(¤t);
pj_timestamp end = current;
pj_add_timestamp32(&end, max_wait_time_ms);
pj_int32_t wait_time_ms = max_wait_time_ms;
event_reset(jitter_buffer->packet_event);
while(wait_time_ms > 0) {
pj_mutex_unlock(jitter_buffer->jb_mutex);
if(event_wait(jitter_buffer->packet_event, wait_time_ms) == WAIT_RET_SIGNAL) {
//incoming a packet
pj_mutex_lock(jitter_buffer->jb_mutex);
if(!jitter_buffer->running) //jitter buffer stoped
goto ON_RET;
CleanOldFrames(jitter_buffer);
frame = findOldestCompleteContinuousFrame(jitter_buffer);
if(frame != NULL)
break;
pj_get_timestamp(¤t);
int elapsed_msec = pj_elapsed_msec(¤t, &end);
wait_time_ms = elapsed_msec;
} else {
pj_mutex_lock(jitter_buffer->jb_mutex); //error or timeout
break;
}
}
} else
event_reset(jitter_buffer->packet_event);
if(frame == NULL)
goto ON_RET;
/*if(jitter_buffer->waiting_for_key_frame && !frame->session_info.isKeyFrame) {
frame = NULL; //not a key frame
goto ON_RET;
}*/
//got one, update jitter
if(frame->nack_count > 0) {
jitter_estimator_frameNacked(&jitter_buffer->jitter_estimator); //nacked
} else {
//update jitter estimator
UpdateJitterEstimatorForFrame(jitter_buffer, frame);
}
//set frame status
frame_buffer_setStatus(frame, FRAME_STATUS_DECODING);
//update decode state
decode_state_updateFrame(frame, &jitter_buffer->decode_state);
//waiting for key frame
if(frame->session_info.isKeyFrame)
jitter_buffer->waiting_for_key_frame = PJ_FALSE;
//clean old frames
CleanOldFrames(jitter_buffer);
//return frame
ON_RET:
pj_mutex_unlock(jitter_buffer->jb_mutex);
return frame;
}
