自学教程：C++ DSFYDEBUG函数代码示例

unsigned int cache_get_meta_playlist_revision(){    unsigned int revision;    /* Build cache filename. */    snprintf(cache_filename, PATH_MAX, "%s/meta_playlist_revision", cache_directory);    /* Try to open file for reading. */    FILE *file = fopen(cache_filename, "r");    if(!file){        DSFYDEBUG("Error opening file in read-mode./n");        return 0;    }    /* Write data to file. */    if(fread(&revision, sizeof(unsigned int), 1, file) != 1){        DSFYDEBUG("Error reading meta playlist revision./n");        return 0;    }    fclose(file);    return revision;}

int read_server_auth_response (SESSION * session){	unsigned char buf[256];	unsigned char payload_len;	int ret;	ret = block_read(session->ap_sock, buf, 2);	if (ret != 2) {		DSFYDEBUG("Failed to read 'status' + length byte, got %d bytes/n", ret);		return -1;	}	if (buf[0] != 0x00) {		DSFYDEBUG("Authentication failed with error 0x%02x, bad password?/n", buf[1]);		return -1;	}	/* Payload length + this byte must not be zero(?) */	assert (buf[1] > 0);	payload_len = buf[1];	ret = block_read (session->ap_sock, buf, payload_len);	if (ret != payload_len) {		DSFYDEBUG("Failed to read 'payload', got %d of %u bytes/n",				ret, payload_len);		return -1;	}#ifdef DEBUG_LOGIN	hexdump8x32 ("read_server_auth_response, payload", buf, payload_len);#endif	return 0;}

int handle_secret_block (SESSION * session, unsigned char *payload, int len){	unsigned int *t;	if (len != 336) {		DSFYDEBUG ("Got cmd=0x02 with len %d, expected 336!/n", len);		return -1;	}	t = (unsigned int *) payload;	DSFYDEBUG ("Initial time %u (%ld seconds from now)/n",		 ntohl (*t), time (NULL) - ntohl (*t));	t++;	DSFYDEBUG ("Future time %u (%ld seconds in the future)/n",		 ntohl (*t), ntohl (*t) - time (NULL));	t++;	DSFYDEBUG ("Next value is %u/n", ntohl (*t));	t++;	DSFYDEBUG ("Next value is %u/n", ntohl (*t));	assert (memcmp (session->rsa_pub_exp, payload + 16, 128) == 0);	/* At payload+16+128 is a  144 bytes (1536-bit) RSA signature */	/*	 * Actually the cache hash is sent before the server has sent any	 * packets. It's just put here out of convenience, because this is	 * one of the first packets ever by the server, and also not	 * repeated during a session.	 *	 */	return cmd_send_cache_hash (session);}

/* Initialize sound session, called once */bool snd_init(struct despotify_session *ds){	DSFYDEBUG ("Initializing sound FIFO etc (happens once)/n");	DSFYDEBUG("Setting state to DL_FILLING/n");	ds->dlstate = DL_FILLING;	/* This is the fifo that will hold fragments of compressed audio */        ds->fifo = calloc(1, sizeof(struct ds_snd_fifo));        if (!ds->fifo)		return false;        ds->fifo->maxbytes = 1024 * 1024; /* 1 MB default buffer size */        ds->fifo->watermark = 200 * 1024; /* 200 KB default watermark */        if (pthread_mutex_init (&ds->fifo->lock, NULL)) {            DSFYfree (ds->fifo);            return NULL;	}	if (pthread_cond_init (&ds->fifo->cs, NULL)) {            DSFYfree (ds->fifo);		pthread_mutex_destroy (&ds->fifo->lock);		return NULL;	}        return true;}

static void snd_fill_fifo(struct despotify_session* ds){    if (ds->dlabort) {        while (ds->dlstate == DL_FILLING_BUSY) {            DSFYDEBUG("dlstate = %d. waiting.../n", ds->dlstate);            shortsleep();        }        ds->dlstate = DL_DRAINING;        return;    }    switch (ds->dlstate) {        case DL_DRAINING:            if (ds->fifo->totbytes < ds->fifo->watermark ) {                DSFYDEBUG("Low on data (%d / %d), fetching another channel/n",                          ds->fifo->totbytes, ds->fifo->maxbytes);                DSFYDEBUG("dlstate = DL_FILLING_BUSY/n");                ds->dlstate = DL_FILLING_BUSY;                despotify_snd_read_stream(ds);            }            break;        case DL_FILLING:            if (ds->fifo->totbytes < (ds->fifo->maxbytes - SUBSTREAM_SIZE)) {                DSFYDEBUG("dlstate = DL_FILLING_BUSY/n");                ds->dlstate = DL_FILLING_BUSY;                despotify_snd_read_stream(ds);            }            else {                DSFYDEBUG("buffer filled. setting dlstate DL_DRAINING/n");                ds->dlstate = DL_DRAINING;            }            break;    }}

/* Free a login context */void login_release(struct login_ctx *l) {	/* Only close the socket if an error occurred */	if(l->error != SP_LOGIN_ERROR_OK && l->sock != -1) {		DSFYDEBUG("Closing open socket %d, login error was %d/n",			l->sock, l->error);#ifdef _WIN32		closesocket(l->sock);#else		close(l->sock);#endif	}	if(l->service_records)		dns_free_list(l->service_records);	if(l->server_ai != NULL)		freeaddrinfo(l->server_ai);	RSA_free(l->rsa);	DH_free(l->dh);	if(l->client_parameters)		buf_free(l->client_parameters);	if(l->server_parameters)		buf_free(l->server_parameters);	free(l);	DSFYDEBUG("Done free'ing login context/n");}

DWORD __stdcall openspotify_thread(LPVOID *arg) {	MSG msg;	WNDCLASS wcOpenspotify;	ATOM wc;	hwndLibraryParent = (HWND)arg;	DSFYDEBUG("Ping from thread/n");	/* Create a window to communicate with the plugin, playlist view and Winamp */	memset(&wcOpenspotify, 0, sizeof(WNDCLASS));	wcOpenspotify.lpszClassName = L"ml_openspotify";	wcOpenspotify.lpfnWndProc = wndproc;	wc = RegisterClass(&wcOpenspotify);	m_hWnd = CreateWindow(szAppName, L"ml_openspotify message sink", 0, 0, 0, 0, 0, hwndLibraryParent, NULL, 0, 0);	DSFYDEBUG("Created window at %p/n", m_hWnd);	if(openspotify_init() < 0) {		DSFYDEBUG("Failed to initialize libopenspotify/n");		PostQuitMessage(0);	}	DSFYDEBUG("Openspotify initialized, now dispatching messages/n");	while(GetMessage(&msg, 0, 0, 0) == TRUE) {		TranslateMessage(&msg);		DispatchMessage(&msg);	}	return msg.wParam;}

static void event_loop(sp_session *session) {	int timeout = -1;#ifndef _WIN32	sigset_t sigset;	sigemptyset(&sigset);	sigaddset(&sigset, SIGIO);#endif	while (g_exit_code < 0) {#ifndef _WIN32		pthread_sigmask(SIG_BLOCK, &sigset, NULL);#endif		DSFYDEBUG("Calling sp_session_process_events()/n");		sp_session_process_events(session, &timeout);		if(test_run() < 0) {			DSFYDEBUG("Done running test, existing event loop/n");			break;		}#ifdef _WIN32		WaitForSingleObject(g_notify_event, timeout);#else		pthread_sigmask(SIG_UNBLOCK, &sigset, NULL);		usleep(timeout * 1000);#endif	}	DSFYDEBUG("Exiting from loop()/n");}

int send_client_auth (SESSION * session){	int ret;	struct buf* buf = buf_new();	buf_append_data(buf, session->auth_hmac, 20);	buf_append_u8(buf, 0); /* random data length */	buf_append_u8(buf, 0); /* unknown */	buf_append_u16(buf, 8); /* puzzle solution length */	buf_append_u32(buf, 0);	/* <-- random data would go here */	buf_append_data (buf, session->puzzle_solution, 8);#ifdef DEBUG_LOGIN	hexdump8x32 ("send_client_auth, second client packet", buf->ptr,			buf->len);#endif	ret = send(session->ap_sock, buf->ptr, buf->len, 0);	if (ret <= 0) {		DSFYDEBUG("send_client_auth(): connection lost/n");		buf_free(buf);		return -1;	}	else if (ret != buf->len) {		DSFYDEBUG("send_client_auth(): only wrote %d of %d bytes/n",				ret, buf->len);		buf_free(buf);		return -1;	}	buf_free(buf);	return 0;}

int send_client_initial_packet (SESSION * session){	int ret;	unsigned int len_idx;		struct buf* b = buf_new();	buf_append_u16 (b, 3); /* protocol version */	len_idx = b->len;	buf_append_u16(b, 0); /* packet length - updated later */	buf_append_u32(b, 0x00000300); /* unknown */	buf_append_u32(b, 0x00030c00); /* unknown */	buf_append_u32(b, session->client_revision);	buf_append_u32(b, 0); /* unknown */	buf_append_u32(b, 0x01000000); /* unknown */	buf_append_data(b, session->client_id, 4);	buf_append_u32(b, 0); /* unknown */	buf_append_data (b, session->client_random_16, 16);	buf_append_data (b, session->my_pub_key, 96);	BN_bn2bin (session->rsa->n, session->rsa_pub_exp);	buf_append_data (b, session->rsa_pub_exp, sizeof(session->rsa_pub_exp));	buf_append_u8 (b, 0); /* length of random data */	buf_append_u8 (b, session->username_len);	buf_append_u16(b, 0x0100); /* unknown */        /* <-- random data would go here */	buf_append_data (b, (unsigned char *) session->username,			   session->username_len);	buf_append_u8 (b, 0x40); /* unknown */	/*	 * Update length bytes	 *	 */	b->ptr[len_idx] = (b->len >> 8) & 0xff;	b->ptr[len_idx+1] = b->len & 0xff;#ifdef DEBUG_LOGIN	hexdump8x32 ("initial client packet", b->ptr, b->len);#endif        ret = send (session->ap_sock, b->ptr, b->len, 0);	if (ret <= 0) {		DSFYDEBUG("connection lost/n");		buf_free(b);		return -1;	}	else if (ret != b->len) {                DSFYDEBUG("only wrote %d of %d bytes/n", ret, b->len);		buf_free(b);		return -1;	}        /* save initial server packet for auth hmac generation */        session->init_client_packet = b;		return 0;}

static int osfy_artistbrowse_browse_callback(struct browse_callback_ctx *brctx) {	sp_artistbrowse *arb;	int i;	struct buf *xml;	ezxml_t root;	for(i = 0; i < brctx->num_in_request; i++) {		arb = brctx->data.artistbrowses[brctx->num_browsed + i];		/* Set defaults */		arb->is_loaded = 0;		arb->error = SP_ERROR_OTHER_TRANSIENT;	}	/* Might happen because of a channel error */	if(brctx->buf == NULL)		return 0;	xml = despotify_inflate(brctx->buf->ptr, brctx->buf->len);#ifdef DEBUG	{		FILE *fd;		DSFYDEBUG("Decompresed %d bytes data, xml=%p/n",			  brctx->buf->len, xml);		fd = fopen("browse-artistbrowse.xml", "w");		if(fd) {			fwrite(xml->ptr, xml->len, 1, fd);			fclose(fd);		}	}#endif	root = ezxml_parse_str((char *) xml->ptr, xml->len);	if(root == NULL) {		DSFYDEBUG("Failed to parse XML/n");		buf_free(xml);		return -1;	}	for(i = 0; i < brctx->num_in_request; i++) {		arb = brctx->data.artistbrowses[brctx->num_browsed + i];		osfy_artistbrowse_load_from_xml(brctx->session, arb, root);		arb->is_loaded = 1;		arb->error = SP_ERROR_OK;	}	ezxml_free(root);	buf_free(xml);	/* Release references made in sp_artistbrowse_create() */	for(i = 0; i < brctx->num_in_request; i++)		sp_artistbrowse_release(brctx->data.artistbrowses[brctx->num_browsed + i]);	return 0;}

int packet_read (SESSION * session, PHEADER * h, unsigned char **payload){	int ret;	int packet_len;	unsigned char nonce[4];	unsigned char *ptr;	packet_len = 0;	if ((ret = block_read (session->ap_sock, h, 3)) != 3) {		DSFYDEBUG			("packet_read(): read short count %d, expected 3 (header)/n",			 ret);		return -1;	}	*(unsigned int *) nonce = htonl (session->key_recv_IV);	shn_nonce (&session->shn_recv, nonce, 4);	shn_decrypt (&session->shn_recv, (unsigned char *) h, 3);#ifdef DEBUG_PACKETS	DSFYDEBUG ("packet_read(): cmd=%d [0x%02x], len=%d [0x%04x]/n",		   h->cmd, h->cmd, ntohs (h->len), ntohs (h->len));	logdata ("recv-hdr", session->key_recv_IV, (unsigned char *) h, 3);#endif	/* Length of payload */	h->len = ntohs (h->len);	packet_len = h->len;	/* Account for MAC */	packet_len += 4;	ptr = (unsigned char *) malloc (packet_len);	if ((*payload = ptr) == NULL)		return -1;	if ((ret =	     block_read (session->ap_sock, ptr, packet_len)) != packet_len) {		DSFYDEBUG			("packet_read(cmd=0x%02x): read short count %d, expected %d/n",			 h->cmd, ret, packet_len);		return -1;	}	shn_decrypt (&session->shn_recv, *payload, packet_len);#ifdef DEBUG_PACKETS	logdata ("recv-dec", session->key_recv_IV, *payload, h->len);#endif	/* Increment IV */	session->key_recv_IV++;	return 0;}

int session_connect (SESSION * session){	struct sockaddr_in sin;	char host[1025 + 1], *service_list, *service;	int port;	/* Lookup service hosts in DNS */        service_list = dns_srv_list ("_spotify-client._tcp.spotify.com");	if (!service_list) {            DSFYDEBUG("service lookup failed. falling back to ap.spotify.com/n");            service_list = malloc(200);            strcpy(service_list, "ap.spotify.com:4070/n");        }	for (service = service_list; *service;) {		if (sscanf (service, "%[^:]:%d/n", host, &port) != 2)			return -1;		service += strlen (host) + 7;		DSFYDEBUG ("session_connect(): Connecting to %s:%d/n", host,			   port);		memset (&sin, 0, sizeof (sin));		sin.sin_family = PF_INET;		sin.sin_port = htons (port);		sin.sin_addr.s_addr = dns_resolve_name (host);		if (sin.sin_addr.s_addr == INADDR_NONE)			continue;		session->ap_sock = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);		if (connect (session->ap_sock, (struct sockaddr *) &sin,			     sizeof (sin)) != -1)			break;		sock_close (session->ap_sock);		session->ap_sock = -1;	}	free (service_list);	if (sin.sin_addr.s_addr == INADDR_NONE)		return -1;	/*	 * Save for later use in ConnectionInfo message	 * (too lazy to do getpeername() later ;)	 */	DSFYstrncpy (session->server_host, host, sizeof session->server_host);	session->server_port = port;	DSFYstrncpy (session->user_info.server_host, host,		     sizeof session->user_info.server_host);	session->user_info.server_port = port;	return 0;}

int packet_write (SESSION * session, unsigned char cmd,		  unsigned char *payload, unsigned short len){	unsigned char nonce[4];	unsigned char *buf, *ptr;	PHEADER *h;	int ret;	*(unsigned int *) nonce = htonl (session->key_send_IV);	shn_nonce (&session->shn_send, nonce, 4);	buf = (unsigned char *) malloc (3 + len + 4);	h = (PHEADER *) buf;	h->cmd = cmd;	h->len = htons (len);	ptr = buf + 3;	if (payload != NULL)	{ 		memcpy (ptr, payload, len);	}	#ifdef DEBUG_PACKETS	DSFYDEBUG		("packet_write(): Sending packet with command 0x%02x, length %d/n",		 h->cmd, ntohs (h->len));	logdata ("send-hdr", session->key_send_IV, (unsigned char *) h, 3);	if (payload != NULL) logdata ("send-payload", session->key_send_IV, payload, len);#endif	shn_encrypt (&session->shn_send, buf, 3 + len);	ptr += len;	shn_finish (&session->shn_send, ptr, 4);	ret = block_write (session->ap_sock, buf, 3 + len + 4);	free(buf);	session->key_send_IV++;	if(ret != 3 + len + 4) {#ifdef DEBUG_PACKETS		DSFYDEBUG ("packet_write(): only wrote %d of %d bytes/n", ret,			   3 + len + 4);#endif		return -1;	}	return 0;}

static void  SP_CALLCONV logged_in(sp_session *session, sp_error error) {	DSFYDEBUG("SESSION CALLBACK/n");	if (SP_ERROR_OK != error) {		fprintf(stderr, "failed to log in to Spotify: %s/n",		                sp_error_message(error));		g_exit_code = 4;		return;	}	DSFYDEBUG("Running session_ready()/n");	session_ready(session);}

static LRESULT CALLBACK wndproc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {	static char *username, *password;	switch(uMsg) {		case WM_TIMER:			DSFYDEBUG("uMsg=%u (%s), wParam=%u, lParam=%u/n", uMsg, WM2STR(uMsg), wParam, lParam);			if(session) {				int timeout;				KillTimer(hwnd, TIMERID);				sp_session_process_events(session, &timeout);				SetTimer(hwnd, TIMERID, timeout, NULL);			}			break;		case WM_USER:			switch(LOWORD(wParam)) {			case 1: // Set tree root ID				m_TreeRootId = (UINT_PTR)lParam;				break;			case 2: // Set username				username = (char *)lParam;				DSFYDEBUG("Got username '%s'/n", username);				break;			case 3: // Set password				password = (char *)lParam;				DSFYDEBUG("Got password '%s'/n", password);				break;			case 4: // Login if not yet logged in				if(sp_session_connectionstate(session) != SP_CONNECTION_STATE_LOGGED_IN)					sp_session_login(session, username, password);				break;			case 5: // Get connection status				if(!session)					return -1;				else if(sp_session_connectionstate(session) != SP_CONNECTION_STATE_LOGGED_IN)					return -1;				return 0;			}			break;	}	return DefWindowProc(hwnd, uMsg, wParam, lParam);}

static void SP_CALLCONV pc_playlist_added(sp_playlistcontainer *pc, sp_playlist *playlist, int position, void *userdata) {	static sp_playlist_callbacks *callbacks;	MLTREEITEM item;	if(callbacks == NULL) {		callbacks = (sp_playlist_callbacks *)malloc(sizeof(sp_playlist_callbacks));		memset(callbacks, 0, sizeof(sp_playlist_callbacks));		callbacks->tracks_added = pl_tracks_added;		callbacks->playlist_renamed = playlist_renamed;	}	/* Snoop on the playlist to know when it's named and tracks are added */	sp_playlist_add_callbacks(playlist, callbacks, NULL);	/* Add playlist to our Media Library tree */	item.size = sizeof(MLTREEITEM);	item.parentId		= m_TreeRootId;	item.hasChildren	= 0;	item.id				= 0;	item.imageIndex		= 0;	item.title			= "(Loading...)";		/* Create a new entry in under our tree in the Media Library pane */	SendMessage(hwndLibraryParent, WM_ML_IPC, (WPARAM) &item, ML_IPC_TREEITEM_ADD);	DSFYDEBUG("New id of entry '%s' is '%u'/n", item.title, item.id);	/* Add mapping between tree ID and playlist position in playlist container */	tpAdd(item.id, position);}

void SP_CALLCONV playlist_renamed(sp_playlist *pl, void *userdata) {	sp_playlistcontainer *pc = sp_session_playlistcontainer(session);	int num = sp_playlistcontainer_num_playlists(pc);	int pos;	MLTREEITEMINFO treeItemInfo;	UINT_PTR treeId, treeHandle;	/* Find position of renamed playlist in the playlist container */	for(pos = 0; pos < num; pos++)		if(sp_playlistcontainer_playlist(pc, pos) == pl)			break;	if(pos == num) {		DSFYDEBUG("WTF, did not find playlist %p in container!/n", pl);		return;	}	/* Get tree ID so we can get the handle */	treeId = tpGetTreeId(pos);	treeHandle = SendMessage(hwndLibraryParent, WM_ML_IPC, (WPARAM)treeId, ML_IPC_TREEITEM_GETHANDLE);	/* Create request to update the item */	memset(&treeItemInfo, 0, sizeof(MLTREEITEMINFO));	treeItemInfo.handle = treeHandle;	treeItemInfo.mask = MLTI_TEXT;	treeItemInfo.item.size = sizeof(MLTREEITEM);	treeItemInfo.item.title = (char *)sp_playlist_name(pl);	/* Submit request */	SendMessage(hwndLibraryParent, WM_ML_IPC, (WPARAM)&treeItemInfo, ML_IPC_TREEITEM_SETINFO);}

/* Reset for new song */void snd_reset(struct despotify_session* ds){	DSFYDEBUG("Setting state to DL_DRAINING/n");	ds->fifo->totbytes = 0;	ds->dlstate = DL_DRAINING;	snd_reset_codec(ds);}

/* * Initialize the Spotify session object, called by openspotify_thread() * */static int openspotify_init(void) {	sp_session_config config;	sp_error error;	sp_session_callbacks callbacks = {		&logged_in,		&logged_out,		&metadata_updated,		&connection_error,		NULL,		&notify_main_thread,		NULL,		NULL,		&log_message	};	memset(&config, 0, sizeof(config));	config.api_version = SPOTIFY_API_VERSION;	config.cache_location = "tmp";	config.settings_location = "tmp";	config.application_key = g_appkey;	config.application_key_size = g_appkey_size;	config.user_agent = "ml_openspotify";	config.callbacks = &callbacks;	error = sp_session_init(&config, &session);	if(error != SP_ERROR_OK) {		DSFYDEBUG("sp_session_init() failed with error '%s'/n", sp_error_message(error));		return -1;	}	return 0;}

static int osfy_image_callback(CHANNEL *ch, unsigned char *payload, unsigned short len) {    struct image_ctx *image_ctx = (struct image_ctx *)ch->private;    switch(ch->state) {    case CHANNEL_DATA:        buf_append_data(image_ctx->image->data, payload, len);        break;    case CHANNEL_ERROR:        DSFYDEBUG("Got a channel ERROR, retrying within %d seconds/n", IMAGE_RETRY_TIMEOUT);        buf_free(image_ctx->image->data);        image_ctx->image->data = NULL;        /* Reset timeout so the request can be retried */        image_ctx->req->next_timeout = get_millisecs() + IMAGE_RETRY_TIMEOUT*1000;        break;    case CHANNEL_END:        /* We simply assume we're always getting a JPEG image back */        image_ctx->image->format = SP_IMAGE_FORMAT_JPEG;        image_ctx->image->is_loaded = 1;        image_ctx->image->error = SP_ERROR_OK;        request_set_result(image_ctx->session, image_ctx->req, SP_ERROR_OK, image_ctx->image);        free(image_ctx);        break;    default:        break;    }    return 0;}

SP_LIBEXPORT(sp_error) sp_session_logout (sp_session *session) {	DSFYDEBUG("Posting REQ_TYPE_LOGOUT/n");	request_post(session, REQ_TYPE_LOGOUT, NULL);	return SP_ERROR_OK;}

sp_image *osfy_image_create(sp_session *session, const byte image_id[20]) {    sp_image *image;    image = (sp_image *)hashtable_find(session->hashtable_images, image_id);    if(image) {        {            char buf[41];            hex_bytes_to_ascii(image->id, buf, 20);            DSFYDEBUG("Returning existing image '%s'/n", buf);        }        return image;    }    image = malloc(sizeof(sp_image));    memcpy(image->id, image_id, sizeof(image->id));    image->format = SP_IMAGE_FORMAT_UNKNOWN;    image->data = NULL;    image->error = SP_ERROR_RESOURCE_NOT_LOADED;    image->callback = NULL;    image->userdata = NULL;    image->is_loaded = 0;    image->ref_count = 0;    image->hashtable = session->hashtable_images;    hashtable_insert(image->hashtable, image->id, image);    return image;}

/* Destroy a sound session */void snd_destroy (snd_SESSION * session){	int ret = 0;	oggBUFF *b;	DSFYDEBUG ("Destroying sound FIFO etc/n");	/* This will stop any playing sound too */	if (session->actx)		ret = audio_context_free (session->actx);	/* Free the FIFO */	if (session->fifo) {		pthread_mutex_lock(&session->fifo->lock); /*rKA*/		/* free oggBuffs */		while (session->fifo->start) {			b = session->fifo->start;			session->fifo->start = session->fifo->start->next;			DSFYfree (b);		}		pthread_mutex_unlock(&session->fifo->lock); /*rKA*/		DSFYfree (session->fifo);		pthread_cond_destroy (&session->fifo->cs);		pthread_mutex_destroy (&session->fifo->lock);	}	pthread_mutex_destroy (&session->lock);	DSFYfree (session);}

/* Reset for new song */void snd_reset (snd_SESSION * session){	DSFYDEBUG ("snd_reset(): Setting state to DL_IDLE/n");	session->fifo->totbytes = 0;	session->dlstate = DL_IDLE;	session->buffer_threshold = BUFFER_THRESHOLD;}

int do_auth (SESSION * session){	/*	 * !! cr4zy 0pp3rtun1ty 2 s4v3 s0m3 pr3c10uz 3n3rgy [email
C++ DSI_HDR_DATA2函数代码示例
C++ DSET_load函数代码示例