Esempio n. 1
0
int himd_add_track_info(struct himd * himd, struct trackinfo * t, struct himderrinfo * status)
{
    int idx_freeslot;
    unsigned char * linkbuffer;
    unsigned char * trackbuffer;
    unsigned char * play_order_table = himd->tifdata+0x100;

    status = status;

    g_return_val_if_fail(himd != NULL, -1);
    g_return_val_if_fail(t != NULL, -1);

    /* get track[0] - the free-chain index */
    linkbuffer   = get_track(himd, 0);
    idx_freeslot = beword16(&linkbuffer[38]);

    /* allocate slot idx_freeslot for the new track*/
    trackbuffer  = get_track(himd, idx_freeslot);
    t->tracknum  = idx_freeslot;

    /* update track[] - free-chain index */
    setbeword16(&linkbuffer[38], beword16(&trackbuffer[38]));

    /* copy trackinfo to slot */
    settrack(t, trackbuffer);

    /* increase track count */
    setbeword16(play_order_table, himd_track_count(himd)+1);

    /* add entry for new track in play order table */
    setbeword16(play_order_table+2*idx_freeslot, t->tracknum);
    return idx_freeslot;
}
Esempio n. 2
0
static void print_tracking(struct kmem_cache *s, void *object)
{
	if (!(s->flags & SLAB_STORE_USER))
		return;

	print_track("Allocated", get_track(s, object, TRACK_ALLOC));
	print_track("Freed", get_track(s, object, TRACK_FREE));
}
Esempio n. 3
0
static void set_track(struct kmem_cache *s, void *object,
			enum track_item alloc, unsigned long addr)
{
	struct track *p = get_track(s, object, alloc);

	if (addr) {
#ifdef CONFIG_STACKTRACE
		struct stack_trace trace;
		int i;

		trace.nr_entries = 0;
		trace.max_entries = TRACK_ADDRS_COUNT;
		trace.entries = p->addrs;
		trace.skip = 3;
		save_stack_trace(&trace);

		/* See rant in lockdep.c */
		if (trace.nr_entries != 0 &&
		    trace.entries[trace.nr_entries - 1] == ULONG_MAX)
			trace.nr_entries--;

		for (i = trace.nr_entries; i < TRACK_ADDRS_COUNT; i++)
			p->addrs[i] = 0;
#endif
		p->addr = addr;
		p->cpu = smp_processor_id();
		p->pid = current->pid;
		p->when = jiffies;
	} else
		memset(p, 0, sizeof(struct track));
}
Esempio n. 4
0
/* Function to estimate the location of a competitor. */
int estimate_location(event_ptr event, competitor* competitor) {
    node* nodeA;
    node* nodeB;
    node* next_node;
    int next_node_number;
    int node_index;
    int est_arrival_time = 0;
    int current_competitor_time;
    int event_time;
    track* track;

    if (competitor->status == NS) {
        return NS;
    } else {
        node_index = competitor->last_checkpoint_index;
        nodeA = get_node(event->node_head, competitor->course_ptr->course_nodes[node_index]->number);
        node_index += 1;
        next_node_number = competitor->course_ptr->course_nodes[node_index]->number; /* Gets node number of the next node on the course. */
        nodeB = get_node(event->node_head, next_node_number);
        track = get_track(event->track_head, nodeA->number, nodeB->number); /* Retrieves track that lies between nodeA and nodeB. */

        current_competitor_time = (competitor->last_time_recored.hours * 60) + competitor->last_time_recored.minutes;
        event_time = (event->current_time.hours * 60) + event->current_time.minutes;
        est_arrival_time = current_competitor_time;

        if (nodeB->type == JN) { /* While the second node is a junction node. */
            track = track_estimation(event, competitor, nodeA, nodeB, node_index, next_node_number, event_time, est_arrival_time);
        }
        return track->number;
    }
}
Esempio n. 5
0
int himd_get_free_trackindex(struct himd * himd)
{
    int idx_freeslot;
    unsigned char * linkbuffer;

    linkbuffer   = get_track(himd, 0);
    idx_freeslot = beword16(&linkbuffer[38]);

    return idx_freeslot;
}
Esempio n. 6
0
void XplodifyPlaylist::flush() {

    boost::shared_ptr<XplodifySession> sess(m_session.lock());
    track_cache_by_rand& t_r = m_track_cache.get<0>();
    std::size_t sz = t_r.size();

    for(std::size_t i=0 ; i<sz ; i++) {
        boost::shared_ptr<XplodifyTrack> tr = get_track(0, true);
        tr.reset();
    }
    sess->update_state_ts();
}
Esempio n. 7
0
/**
 * @param  search   The search result
 */
static void get_search(sp_search *search)
{
        int i;
        json_t *json = json_object();

        json_t *tracks = json_array();
        json_object_set_new(json, "tracks", tracks);
        for (i = 0; i < sp_search_num_tracks(search); ++i){
            json_array_append_new(tracks, get_track(sp_search_track(search, i)));
        }
        json_object_set_new_nocheck(json, "query", json_string_nocheck(sp_search_query(search)));
        cmd_sendresponse(json, 200);
}
Esempio n. 8
0
/* Recursive function that estimates what track the competitor could currently be on.
 * Recursively calls if the next node is a junction node and the time difference allows for the next track to be considered. */
track* track_estimation(event_ptr event, competitor* competitor, node* nodeA, node* nodeB, int node_index, int next_node_number, int event_time, int est_arrival_time) {
    node* next_node;
    track* track;

    track = get_track(event->track_head, nodeA->number, nodeB->number); /* Obtain track. */
    est_arrival_time += track->max_time; /* Increase estimated arrival time for competitor at end of track. */

    if (event_time > est_arrival_time) {
        node_index += 1;
        next_node_number = competitor->course_ptr->course_nodes[node_index]->number; /* Gets node number of the next node on the course. */
        next_node = get_node(event->node_head, next_node_number);
        nodeA = nodeB;
        nodeB = next_node;

        if (nodeB->type == JN) {
            track = track_estimation(event, competitor, nodeA, nodeB, node_index, next_node_number, event_time, est_arrival_time);
        } else { /* If the new nodeB is not a junction node. */
            track = get_track(event->track_head, nodeA->number, nodeB->number);
        }
    }

    return track;
}
Esempio n. 9
0
int himd_get_track_info(struct himd * himd, unsigned int idx, struct trackinfo * t, struct himderrinfo * status)
{
    unsigned char * trackbuffer;
    unsigned int firstpart;

    g_return_val_if_fail(himd != NULL, -1);
    g_return_val_if_fail(idx >= HIMD_FIRST_TRACK, -1);
    g_return_val_if_fail(idx <= HIMD_LAST_TRACK, -1);
    g_return_val_if_fail(t != NULL, -1);

    trackbuffer = get_track(himd, idx);
    firstpart = beword16(trackbuffer+36);

    if(firstpart == 0)
    {
        set_status_printf(status, HIMD_ERROR_NO_SUCH_TRACK,
                          _("Track %d is not present on disc"), idx);
        return -1;
    }
    get_dostime(&t->recordingtime,trackbuffer+0);
    t->ekbnum = beword32(trackbuffer+4);
    t->title = beword16(trackbuffer+8);
    t->artist = beword16(trackbuffer+10);
    t->album = beword16(trackbuffer+12);
    t->trackinalbum = trackbuffer[14];
    memcpy(t->key, trackbuffer+16,8);
    memcpy(t->mac, trackbuffer+24,8);
    t->codec_id = trackbuffer[32];
    memcpy(t->codecinfo,trackbuffer+33,3);
    memcpy(t->codecinfo+3,trackbuffer+44,2);
    t->firstfrag = firstpart;
    t->tracknum = beword16(trackbuffer+38);
    t->seconds = beword16(trackbuffer+40);
    memcpy(t->contentid,trackbuffer+48,20);
    get_dostime(&t->starttime,trackbuffer+68);
    get_dostime(&t->endtime,trackbuffer+72);
    return 0;
}
Esempio n. 10
0
static gint
parse_track_list_data(GString *data, GList **list)
{
	gint result = 1;
	xmlDocPtr doc = NULL;

	doc = xmlReadMemory(data->str, data->len, NULL, NULL,
				XML_PARSE_RECOVER | XML_PARSE_NOERROR);

	if (doc == NULL)
		return result;

	do
	{
		xmlNodePtr root;
		xmlNodePtr track_list;
		xmlNodePtr p;

		root = xmlDocGetRootElement(doc);
		if (root == NULL)
			break;

		track_list = xml_first_child(root, BAD_CAST "trackList");
		if (track_list == NULL)
			break;

		for(p = xmlFirstElementChild(track_list); p ; p = xmlNextElementSibling(p))
			get_track(p, list);

		result = 0;
	}
	while(0);

	xmlFreeDoc(doc);

	return result;
}
Esempio n. 11
0
/**
 * Callback for libspotify
 *
 * @param result    The toplist result object that is now done
 * @param userdata  The opaque pointer given to sp_toplistbrowse_create()
 */
static void got_toplist(sp_toplistbrowse *result, void *userdata)
{
	int i;
        json_t *json = json_object();
        json_t *toplist = json_object();

        json_object_set_new(json, "toplist", toplist);
        json_t *results = json_array();
        json_object_set_new(toplist, "result", results);
        // We print from all types. Only one of the loops will acually yield anything.

        for(i = 0; i < sp_toplistbrowse_num_artists(result); i++)
            json_array_append_new(results, get_artist(sp_toplistbrowse_artist(result, i)));

        for(i = 0; i < sp_toplistbrowse_num_albums(result); i++)
            json_array_append_new(results, get_album(sp_toplistbrowse_album(result, i)));

        for(i = 0; i < sp_toplistbrowse_num_tracks(result); i++)
            json_array_append_new(results, get_track(sp_toplistbrowse_track(result, i)));

        cmd_sendresponse(json, 200);
        sp_toplistbrowse_release(result);
        cmd_done();
}
Esempio n. 12
0
long rread(Rfile tpf, void *buf, long count)
/* Read a buffer from an open ram-disk file. */
{
char ***platter;
char **track;
char *data;
int i;
int ssize, so;
int flags;
long filept;
long  readin;
long fsize;

flags = tpf->flags;
if (!(flags&TF_OPEN))
	{
	rerr = Err_file_not_open;
	return(0);
	}
if (!(flags&TF_READ))
	{
	rerr = Err_read;
	return(0);
	}
data = buf;
readin = 0;
filept = tpf->filep;
fsize  = tpf->size;
if ((tpf->filep = filept+count) > fsize)
	{
	rerr = Err_eof;
	if ((count = fsize-filept) <= 0)
		return(0);
	}
platter = tpf->platters + get_platter(filept);
for (;;)
	{
	i = get_track(filept);
	track = *platter  +  i;
	for ( ; i< TRD_TRACK; i++)
		{
		so = get_sector(filept);
		ssize = TRD_SECTOR - so;
		if (count > ssize)
			{
			memcpy(data, *track + so, ssize);
			readin += ssize;
			data +=  ssize;
			count -= ssize;
			filept += ssize;
			}
		else
			{
			memcpy(data,  *track + so, (size_t)count);
			return(readin+count);
			}
		track++;
		}
	platter++;
	}
}
Esempio n. 13
0
long rwrite(Rfile tpf, void *buf, long count)
/* Write a buffer to an open ram-disk file. */
{
char ***platter;
char **track;
char *data;
int i;
int ssize, so;
int flags;
long filept;
long  written;
long new_size;

flags = tpf->flags;
if (!(flags&TF_OPEN))
	{
	rerr = Err_file_not_open;
	return(0);
	}
if (!(flags&TF_WRITE))
	{
	rerr = Err_write;
	return(0);
	}
if (count <= 0)
	return(0);

	data = buf;
	written = 0;
	filept = tpf->filep;
	new_size = filept + count;
	platter = tpf->platters + get_platter(filept);

	for (;;)
	{
		if ((track = *platter) == NULL)
			if ((*platter = track = tget_clear()) == NULL)
				goto OUT;
		i = get_track(filept);
		track += i;
		for ( ; i< TRD_TRACK; i++)
		{
			if (*track == NULL)
				if ((*track = tget_sector()) == NULL)
					goto OUT;
			so = get_sector(filept);
			ssize = TRD_SECTOR - so;
			if (count > ssize)
			{
				memcpy(*track + so, data, ssize);
				written += ssize;
				data +=  ssize;
				count -= ssize;
				filept += ssize;
			}
			else
			{
				memcpy(*track + so, data, (size_t)count);
				written += count;
				filept += count;
				goto OUT;
			}
			track++;
		}
		platter++;
	}
OUT:
	if (tpf->size < (tpf->filep = filept))
		tpf->size = filept;
	return(written);
}