// Filter data through filter
static struct mp_audio *play(struct af_instance *af, struct mp_audio *data)
{
af_scaletempo_t *s = af->priv;
if (s->scale == 1.0) {
af->delay = 0;
return data;
}
mp_audio_realloc_min(af->data,
((int)(data->samples / s->frames_stride_scaled) + 1) * s->frames_stride);
int offset_in = fill_queue(af, data, 0);
int8_t *pout = af->data->planes[0];
while (s->bytes_queued >= s->bytes_queue) {
int ti;
float tf;
int bytes_off = 0;
// output stride
if (s->output_overlap) {
if (s->best_overlap_offset)
bytes_off = s->best_overlap_offset(s);
s->output_overlap(s, pout, bytes_off);
}
memcpy(pout + s->bytes_overlap,
s->buf_queue + bytes_off + s->bytes_overlap,
s->bytes_standing);
pout += s->bytes_stride;
// input stride
memcpy(s->buf_overlap,
s->buf_queue + bytes_off + s->bytes_stride,
s->bytes_overlap);
tf = s->frames_stride_scaled + s->frames_stride_error;
ti = (int)tf;
s->frames_stride_error = tf - ti;
s->bytes_to_slide = ti * s->bytes_per_frame;
offset_in += fill_queue(af, data, offset_in);
}
// This filter can have a negative delay when scale > 1:
// output corresponding to some length of input can be decided and written
// after receiving only a part of that input.
af->delay = (s->bytes_queued - s->bytes_to_slide) / s->scale
/ af->data->sstride / af->data->rate;
data->planes[0] = af->data->planes[0];
data->samples = (pout - (int8_t *)af->data->planes[0]) / af->data->sstride;
return data;
}
void memory_c::run_a_cycle()
{
if (KNOB(KNOB_PRINT_MEM_DEBUG)->getValue()) {
dprint_queues();
dprint_dram_banks();
}
/* This function is called from run_a_cycle() every cycle */
/* You do not add new code here */
/* insert D-cache/I-cache (D-cache for only Lab #2) and wakes up instructions */
fill_queue();
/* move memory requests from dram to cache and MSHR*/ /* out queue */
send_bus_out_queue();
/* memory requests are scheduled */
dram_schedule();
/* memory requests are moved from bus_queue to DRAM scheduler */
push_dram_sch_queue();
/* new memory requests send from MSRH to in_bus_queue */
send_bus_in_queue();
}
dsp_thread_queue * operator()(node_graph * graph)
{
bool has_parallelism = graph->root_group()->has_parallel_group_children();
/* pessimize: reserve enough memory for the worst case */
q = new node_graph::dsp_thread_queue(graph->synth_count_, has_parallelism);
fill_queue(*graph->root_group()); // LATER: we could optimize the case when we do not have any paralleism
return q;
}
/*****************************************************************************
* transform_buffer: main filter loop
*****************************************************************************/
static size_t transform_buffer( filter_t *p_filter,
uint8_t *p_buffer,
size_t i_buffer,
uint8_t *pout )
{
filter_sys_t *p = p_filter->p_sys;
size_t offset_in = fill_queue( p_filter, p_buffer, i_buffer, 0 );
unsigned bytes_out = 0;
while( p->bytes_queued >= p->bytes_queue_max ) {
unsigned bytes_off = 0;
// output stride
if( p->output_overlap ) {
if( p->best_overlap_offset ) {
bytes_off = p->best_overlap_offset( p_filter );
}
p->output_overlap( p_filter, pout, bytes_off );
}
memcpy( pout + p->bytes_overlap,
p->buf_queue + bytes_off + p->bytes_overlap,
p->bytes_standing );
pout += p->bytes_stride;
bytes_out += p->bytes_stride;
// input stride
memcpy( p->buf_overlap,
p->buf_queue + bytes_off + p->bytes_stride,
p->bytes_overlap );
double frames_to_slide = p->frames_stride_scaled + p->frames_stride_error;
unsigned frames_to_stride_whole = (int)frames_to_slide;
p->bytes_to_slide = frames_to_stride_whole * p->bytes_per_frame;
p->frames_stride_error = frames_to_slide - frames_to_stride_whole;
offset_in += fill_queue( p_filter, p_buffer, i_buffer, offset_in );
}
return bytes_out;
}
SERVER_OBJ *init_network(SERVER_QUEUE_OBJ *messages){
struct sockaddr_in server_addr;
SERVER_OBJ *server = (SERVER_OBJ *)malloc(sizeof(SERVER_OBJ));
memset(server, 0, sizeof(SERVER_OBJ));
server->server_socket = socket(AF_INET, SOCK_STREAM, 0);
if(pthread_mutex_init(&mutex, NULL) != 0)
return NULL; //Couldn't create mutex
if(sem_init(&messages_sem, 0, 0) == -1)
return NULL; //Couldn't init semaphore
if(server->server_socket == -1)
return NULL; //Couldn't create socket
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr (SERVER_IP);
server_addr.sin_port = htons (SERVER_PORT);
if(bind (server->server_socket, (struct sockaddr *) &server_addr, sizeof (server_addr)) == -1)
return NULL; //Couldn't bind addrress
if(listen(server->server_socket, LISTEN_QUEUE) == -1)
return NULL; //Could't Listen for incoming connections
server->num_users_connected = 0;
server->user_idle_time_max = 1800; //30 mins
//server->clients = (CLIENT_OBJ *)malloc(sizeof(CLIENT_OBJ) * 11); //Make room for 10 clients
memset(server->clients, 0, sizeof(CLIENT_OBJ));
pthread_mutex_lock(&mutex);
fill_queue(server, messages);
pthread_mutex_unlock(&mutex);
if(pthread_create(&server->listen_thread_id, NULL, listen_thread, server) == -1)
return NULL; //Unable to spawn the thread to accept clients
return server;
}
/*
* This function is called each time a the kernel finds a virtio device
* that we are associated with.
*/
static int __devinit virtcons_probe(struct virtio_device *vdev)
{
int err;
struct crypto_device *crdev;
unsigned int nr_added_bufs;
debug("Entering\n");
crdev = kzalloc(sizeof(*crdev), GFP_KERNEL);
if (!crdev) {
err = -ENOMEM;
goto fail;
}
crdev->vdev = vdev;
vdev->priv = crdev;
/* Since the open from the host will return -1 we
initiaate this to -13 to indicate no open try yet. */
crdev->fd = -13;
spin_lock_irq(&crdrvdata_lock);
crdev->minor = crdrvdata.next_minor++;
spin_unlock_irq(&crdrvdata_lock);
/* Find the virtqueues that the device will user. */
err = find_vqs(crdev);
if (err < 0) {
printk(KERN_WARNING "Error %d initializing vqs\n", err);
goto fail;
}
init_waitqueue_head(&crdev->c_wq);
init_waitqueue_head(&crdev->i_wq);
/* Initialize all locks. */
/* Do i need any lock? */
/* ? */
/* Fill the in_vq with buffers so the host can send us data. */
nr_added_bufs = fill_queue(crdev->ivq, NULL);
if (!nr_added_bufs) {
printk(KERN_WARNING "Error allocating inbufs\n");
err = -ENOMEM;
goto fail;
}
/* Fill the c_ivq with buffers so the host can send us data. */
nr_added_bufs = fill_queue(crdev->c_ivq, NULL);
if (!nr_added_bufs) {
printk(KERN_WARNING "Error allocating buffers for control queue\n");
err = -ENOMEM;
goto fail;
}
/* Finally add the device to the driver list. */
spin_lock_irq(&crdrvdata_lock);
list_add_tail(&crdev->list, &crdrvdata.devs);
spin_unlock_irq(&crdrvdata_lock);
debug("Leaving\n");
return 0;
fail:
return err;
}
int
w32_console_read_socket (struct terminal *terminal,
struct input_event *hold_quit)
{
int nev, add;
int isdead;
block_input ();
for (;;)
{
int nfnotify = handle_file_notifications (hold_quit);
nev = fill_queue (0);
if (nev <= 0)
{
/* If nev == -1, there was some kind of error
If nev == 0 then no events were available
so return. */
if (nfnotify)
nev = 0;
break;
}
while (nev > 0)
{
struct input_event inev;
EVENT_INIT (inev);
inev.kind = NO_EVENT;
inev.arg = Qnil;
switch (queue_ptr->EventType)
{
case KEY_EVENT:
add = key_event (&queue_ptr->Event.KeyEvent, &inev, &isdead);
if (add == -1) /* 95.7.25 by himi */
{
queue_ptr--;
add = 1;
}
if (add)
kbd_buffer_store_event_hold (&inev, hold_quit);
break;
case MOUSE_EVENT:
add = do_mouse_event (&queue_ptr->Event.MouseEvent, &inev);
if (add)
kbd_buffer_store_event_hold (&inev, hold_quit);
break;
case WINDOW_BUFFER_SIZE_EVENT:
if (w32_use_full_screen_buffer)
resize_event (&queue_ptr->Event.WindowBufferSizeEvent);
break;
case MENU_EVENT:
case FOCUS_EVENT:
/* Internal event types, ignored. */
break;
}
queue_ptr++;
nev--;
}
}
/* We don't get told about changes in the window size (only the buffer
size, which we no longer care about), so we have to check it
periodically. */
if (!w32_use_full_screen_buffer)
maybe_generate_resize_event ();
unblock_input ();
return nev;
}
// Filter data through filter
static af_data_t* play(struct af_instance_s* af, af_data_t* data)
{
af_scaletempo_t* s = af->setup;
int offset_in;
int max_bytes_out;
int8_t* pout;
if (s->scale == 1.0) {
return data;
}
// RESIZE_LOCAL_BUFFER - can't use macro
max_bytes_out = ((int)(data->len / s->bytes_stride_scaled) + 1) * s->bytes_stride;
if (max_bytes_out > af->data->len) {
mp_msg(MSGT_AFILTER, MSGL_V, "[libaf] Reallocating memory in module %s, "
"old len = %i, new len = %i\n",af->info->name,af->data->len,max_bytes_out);
af->data->audio = realloc(af->data->audio, max_bytes_out);
if (!af->data->audio) {
mp_msg(MSGT_AFILTER, MSGL_FATAL, "[libaf] Could not allocate memory\n");
return NULL;
}
af->data->len = max_bytes_out;
}
offset_in = fill_queue(af, data, 0);
pout = af->data->audio;
while (s->bytes_queued >= s->bytes_queue) {
int ti;
float tf;
int bytes_off = 0;
// output stride
if (s->output_overlap) {
if (s->best_overlap_offset)
bytes_off = s->best_overlap_offset(s);
s->output_overlap(s, pout, bytes_off);
}
memcpy(pout + s->bytes_overlap,
s->buf_queue + bytes_off + s->bytes_overlap,
s->bytes_standing);
pout += s->bytes_stride;
// input stride
memcpy(s->buf_overlap,
s->buf_queue + bytes_off + s->bytes_stride,
s->bytes_overlap);
tf = s->frames_stride_scaled + s->frames_stride_error;
ti = (int)tf;
s->frames_stride_error = tf - ti;
s->bytes_to_slide = ti * s->bytes_per_frame;
offset_in += fill_queue(af, data, offset_in);
}
// This filter can have a negative delay when scale > 1:
// output corresponding to some length of input can be decided and written
// after receiving only a part of that input.
af->delay = s->bytes_queued - s->bytes_to_slide;
data->audio = af->data->audio;
data->len = pout - (int8_t *)af->data->audio;
return data;
}
int
w32_console_read_socket (struct terminal *terminal,
int expected,
struct input_event *hold_quit)
{
BOOL no_events = TRUE;
int nev, ret = 0, add;
int isdead;
if (interrupt_input_blocked)
{
interrupt_input_pending = 1;
return -1;
}
interrupt_input_pending = 0;
BLOCK_INPUT;
for (;;)
{
nev = fill_queue (0);
if (nev <= 0)
{
/* If nev == -1, there was some kind of error
If nev == 0 then waitp must be zero and no events were available
so return. */
UNBLOCK_INPUT;
return nev;
}
while (nev > 0)
{
struct input_event inev;
EVENT_INIT (inev);
inev.kind = NO_EVENT;
inev.arg = Qnil;
switch (queue_ptr->EventType)
{
case KEY_EVENT:
add = key_event (&queue_ptr->Event.KeyEvent, &inev, &isdead);
if (add == -1) /* 95.7.25 by himi */
{
queue_ptr--;
add = 1;
}
if (add)
kbd_buffer_store_event_hold (&inev, hold_quit);
break;
case MOUSE_EVENT:
add = do_mouse_event (&queue_ptr->Event.MouseEvent, &inev);
if (add)
kbd_buffer_store_event_hold (&inev, hold_quit);
break;
case WINDOW_BUFFER_SIZE_EVENT:
if (w32_use_full_screen_buffer)
resize_event (&queue_ptr->Event.WindowBufferSizeEvent);
break;
case MENU_EVENT:
case FOCUS_EVENT:
/* Internal event types, ignored. */
break;
}
queue_ptr++;
nev--;
}
if (ret > 0 || expected == 0)
break;
}
/* We don't get told about changes in the window size (only the buffer
size, which we no longer care about), so we have to check it
periodically. */
if (!w32_use_full_screen_buffer)
maybe_generate_resize_event ();
UNBLOCK_INPUT;
return ret;
}
static int filter(struct af_instance *af, struct mp_audio *data)
{
af_scaletempo_t *s = af->priv;
if (s->scale == 1.0) {
af->delay = 0;
af_add_output_frame(af, data);
return 0;
}
int in_samples = data ? data->samples : 0;
struct mp_audio *out = mp_audio_pool_get(af->out_pool, af->data,
((int)(in_samples / s->frames_stride_scaled) + 1) * s->frames_stride);
if (!out) {
talloc_free(data);
return -1;
}
if (data)
mp_audio_copy_attributes(out, data);
int offset_in = fill_queue(af, data, 0);
int8_t *pout = out->planes[0];
while (s->bytes_queued >= s->bytes_queue) {
int ti;
float tf;
int bytes_off = 0;
// output stride
if (s->output_overlap) {
if (s->best_overlap_offset)
bytes_off = s->best_overlap_offset(s);
s->output_overlap(s, pout, bytes_off);
}
memcpy(pout + s->bytes_overlap,
s->buf_queue + bytes_off + s->bytes_overlap,
s->bytes_standing);
pout += s->bytes_stride;
// input stride
memcpy(s->buf_overlap,
s->buf_queue + bytes_off + s->bytes_stride,
s->bytes_overlap);
tf = s->frames_stride_scaled + s->frames_stride_error;
ti = (int)tf;
s->frames_stride_error = tf - ti;
s->bytes_to_slide = ti * s->bytes_per_frame;
offset_in += fill_queue(af, data, offset_in);
}
// This filter can have a negative delay when scale > 1:
// output corresponding to some length of input can be decided and written
// after receiving only a part of that input.
af->delay = (s->bytes_queued - s->bytes_to_slide) / s->scale
/ out->sstride / out->rate;
out->samples = (pout - (int8_t *)out->planes[0]) / out->sstride;
talloc_free(data);
if (out->samples) {
af_add_output_frame(af, out);
} else {
talloc_free(out);
}
return 0;
}
