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

static void mlp_hook_playback_begin(gpointer hook_data, gpointer user_data){	gint playlist = mlp_playlist_get_playing();	gint pos = mlp_playlist_get_position(playlist);	if (mlp_playlist_entry_get_length (playlist, pos, FALSE) < 30)	{		AUDDBG(" *** not submitting due to entry->length < 30");		return;	}	gchar * filename = mlp_playlist_entry_get_filename (playlist, pos);	if (ishttp (filename))	{		AUDDBG(" *** not submitting due to HTTP source");		str_unref (filename);		return;	}	str_unref (filename);	sc_idle(m_scrobbler);	if (submit_tuple)		tuple_unref (submit_tuple);	submit_tuple = mlp_playlist_entry_get_tuple (playlist, pos, FALSE);	if (! submit_tuple)		return;	sc_addentry(m_scrobbler, submit_tuple, tuple_get_int(submit_tuple, FIELD_LENGTH, NULL) / 1000);	if (!track_timeout)		track_timeout = g_timeout_add_seconds(1, sc_timeout, NULL);}

static void pulse_drain(void) {    pa_operation *o = NULL;    int success = 0;    CHECK_CONNECTED();    pa_threaded_mainloop_lock(mainloop);    CHECK_DEAD_GOTO(fail, 0);    if (!(o = pa_stream_drain(stream, stream_success_cb, &success))) {        AUDDBG("pa_stream_drain() failed: %s", pa_strerror(pa_context_errno(context)));        goto fail;    }    while (pa_operation_get_state(o) != PA_OPERATION_DONE) {        CHECK_DEAD_GOTO(fail, 1);        pa_threaded_mainloop_wait(mainloop);    }    if (!success)        AUDDBG("pa_stream_drain() failed: %s", pa_strerror(pa_context_errno(context)));fail:    if (o)        pa_operation_unref(o);    pa_threaded_mainloop_unlock(mainloop);}

void metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data){    callback_info *info = (callback_info*) client_data;    gsize size;    if (metadata->type == FLAC__METADATA_TYPE_STREAMINFO)    {        info->stream.samples = metadata->data.stream_info.total_samples;        AUDDBG("total_samples=%lld/n", (long long) metadata->data.stream_info.total_samples);        info->stream.bits_per_sample = metadata->data.stream_info.bits_per_sample;        AUDDBG("bits_per_sample=%d/n", metadata->data.stream_info.bits_per_sample);        info->stream.channels = metadata->data.stream_info.channels;        AUDDBG("channels=%d/n", metadata->data.stream_info.channels);        info->stream.samplerate = metadata->data.stream_info.sample_rate;        AUDDBG("sample_rate=%d/n", metadata->data.stream_info.sample_rate);        size = vfs_fsize(info->fd);        if (size == -1 || info->stream.samples == 0)            info->bitrate = 0;        else            info->bitrate = 8 * size * (gint64) info->stream.samplerate / info->stream.samples;        AUDDBG("bitrate=%d/n", info->bitrate);        info->metadata_changed = TRUE;    }}

static AVInputFormat * get_format_by_extension (const gchar * name){    const gchar * ext0, * sub;    uri_parse (name, NULL, & ext0, & sub, NULL);    if (ext0 == sub)        return NULL;    gchar * ext = g_ascii_strdown (ext0 + 1, sub - ext0 - 1);    AUDDBG ("Get format by extension: %s/n", name);    pthread_mutex_lock (& data_mutex);    if (! extension_dict)        extension_dict = create_extension_dict ();    AVInputFormat * f = g_hash_table_lookup (extension_dict, ext);    pthread_mutex_unlock (& data_mutex);    if (f)        AUDDBG ("Format %s./n", f->name);    else        AUDDBG ("Format unknown./n");    g_free (ext);    return f;}

static void start_single (int type){    PluginHandle * p;    if ((p = find_enabled (type)) != NULL)    {        AUDDBG ("Starting selected %s plugin %s./n", table[type].name,         plugin_get_name (p));        if (table[type].u.s.set_current (p))            return;        AUDDBG ("%s failed to start./n", plugin_get_name (p));        plugin_set_enabled (p, FALSE);    }    AUDDBG ("Probing for %s plugin./n", table[type].name);    if ((p = table[type].u.s.probe ()) == NULL)    {        fprintf (stderr, "FATAL: No %s plugin found./n", table[type].name);        exit (EXIT_FAILURE);    }    AUDDBG ("Starting %s./n", plugin_get_name (p));    plugin_set_enabled (p, TRUE);    if (! table[type].u.s.set_current (p))    {        fprintf (stderr, "FATAL: %s failed to start./n", plugin_get_name (p));        plugin_set_enabled (p, FALSE);        exit (EXIT_FAILURE);    }}

static bool_t set_format(int format, int rate, int channels){    int param;    AUDDBG("Audio format: %s, sample rate: %dHz, number of channels: %d./n", oss_format_to_text(format), rate, channels);    /* Enable/disable format conversions made by the OSS software */    param = aud_get_bool("oss4", "cookedmode");    CHECK(ioctl, oss_data->fd, SNDCTL_DSP_COOKEDMODE, &param);    AUDDBG("%s format conversions made by the OSS software./n", param ? "Enabled" : "Disabled");    param = format;    CHECK_NOISY(ioctl, oss_data->fd, SNDCTL_DSP_SETFMT, &param);    CHECK_VAL(param == format, ERROR_NOISY, "Selected audio format is not supported by the device./n");    param = rate;    CHECK_NOISY(ioctl, oss_data->fd, SNDCTL_DSP_SPEED, &param);    CHECK_VAL(param >= rate * 9 / 10 && param <= rate * 11 / 10, ERROR_NOISY,     "Selected sample rate is not supported by the device./n");    param = channels;    CHECK_NOISY(ioctl, oss_data->fd, SNDCTL_DSP_CHANNELS, &param);    CHECK_VAL(param == channels, ERROR_NOISY, "Selected number of channels is not supported by the device./n");    oss_data->format = format;    oss_data->rate = rate;    oss_data->channels = channels;    oss_data->bits_per_sample = oss_format_to_bits(oss_data->format);    return TRUE;FAILED:    return FALSE;}

//called from scrobbler_init() @ scrobbler.cbool_t scrobbler_communication_init() {    CURLcode curl_requests_result = curl_global_init(CURL_GLOBAL_DEFAULT);    if (curl_requests_result != CURLE_OK) {        AUDDBG("Could not initialize libCURL: %s./n", curl_easy_strerror(curl_requests_result));        return FALSE;    }    curlHandle = curl_easy_init();    if (curlHandle == NULL) {        AUDDBG("Could not initialize libCURL./n");        return FALSE;    }    curl_requests_result = curl_easy_setopt(curlHandle, CURLOPT_URL, SCROBBLER_URL);    if (curl_requests_result != CURLE_OK) {        AUDDBG("Could not define scrobbler destination URL: %s./n", curl_easy_strerror(curl_requests_result));        return FALSE;    }    curl_requests_result = curl_easy_setopt(curlHandle, CURLOPT_WRITEFUNCTION, result_callback);    if (curl_requests_result != CURLE_OK) {        AUDDBG("Could not register scrobbler callback function: %s./n", curl_easy_strerror(curl_requests_result));        return FALSE;    }    return TRUE;}

static void general_load (PluginHandle * plugin){    GList * node = g_list_find_custom (loaded_general_plugins, plugin,     (GCompareFunc) general_find_cb);    if (node != NULL)        return;    AUDDBG ("Loading %s./n", plugin_get_name (plugin));    GeneralPlugin * gp = plugin_get_header (plugin);    g_return_if_fail (gp != NULL);    LoadedGeneral * general = g_slice_new (LoadedGeneral);    general->plugin = plugin;    general->gp = gp;    general->widget = NULL;    if (gp->get_widget != NULL)        general->widget = gp->get_widget ();    if (general->widget != NULL)    {        AUDDBG ("Adding %s to interface./n", plugin_get_name (plugin));        g_signal_connect (general->widget, "destroy", (GCallback)         gtk_widget_destroyed, & general->widget);        interface_add_plugin_widget (plugin, general->widget);    }    loaded_general_plugins = g_list_prepend (loaded_general_plugins, general);}

static Tuple *wv_probe_for_tuple(const char * filename, VFSFile * fd){    WavpackContext *ctx;    Tuple *tu;    char error[1024];    ctx = WavpackOpenFileInputEx(&wv_readers, fd, NULL, error, OPEN_TAGS, 0);    if (ctx == NULL)        return NULL;    AUDDBG("starting probe of %p/n", (void *) fd);    vfs_rewind(fd);    tu = tuple_new_from_filename(filename);    vfs_rewind(fd);    tag_tuple_read(tu, fd);    tuple_set_int(tu, FIELD_LENGTH, NULL,        ((uint64_t) WavpackGetNumSamples(ctx) * 1000) / (uint64_t) WavpackGetSampleRate(ctx));    tuple_set_str(tu, FIELD_CODEC, NULL, "WavPack");    char * quality = wv_get_quality (ctx);    tuple_set_str (tu, FIELD_QUALITY, NULL, quality);    str_unref (quality);    WavpackCloseFile(ctx);    AUDDBG("returning tuple %p for file %p/n", (void *) tu, (void *) fd);    return tu;}

void start(void) {	sc_going = 1;	gchar * username = mlp_get_string ("audioscrobbler", "username");	gchar * password = mlp_get_string ("audioscrobbler", "password");	gchar * sc_url = mlp_get_string ("audioscrobbler", "sc_url");	if ((!username || !password) || (!*username || !*password))	{		AUDDBG("username/password not found - not starting last.fm support");		sc_going = 0;	}	else		sc_init(username, password, sc_url);	g_free (username);	g_free (password);	g_free (sc_url);	m_scrobbler = g_mutex_new();	hook_associate("playback begin", mlp_hook_playback_begin, NULL);	hook_associate("playback stop", mlp_hook_playback_end, NULL);	AUDDBG("plugin started");	sc_idle(m_scrobbler);}

static void pulse_flush(int time) {    pa_operation *o = NULL;    int success = 0;    CHECK_CONNECTED();    pa_threaded_mainloop_lock(mainloop);    CHECK_DEAD_GOTO(fail, 1);    written = time * (int64_t) bytes_per_second / 1000;    flush_time = time;    if (!(o = pa_stream_flush(stream, stream_success_cb, &success))) {        AUDDBG("pa_stream_flush() failed: %s", pa_strerror(pa_context_errno(context)));        goto fail;    }    while (pa_operation_get_state(o) != PA_OPERATION_DONE) {        CHECK_DEAD_GOTO(fail, 1);        pa_threaded_mainloop_wait(mainloop);    }    if (!success)        AUDDBG("pa_stream_flush() failed: %s", pa_strerror(pa_context_errno(context)));fail:    if (o)        pa_operation_unref(o);    pa_threaded_mainloop_unlock(mainloop);}

static void delete_lines_from_scrobble_log (GSList **lines_to_remove_ptr, gchar *queuepath) {    GSList *lines_to_remove = *lines_to_remove_ptr;    gchar *contents = NULL;    gchar **lines = NULL;    gchar **finallines = g_malloc_n(1, sizeof(gchar *));    int n_finallines;    if (lines_to_remove == NULL) {        return;    }    lines_to_remove = g_slist_reverse(lines_to_remove);    pthread_mutex_lock(&log_access_mutex);    gboolean success = g_file_get_contents(queuepath, &contents, NULL, NULL);    if (!success) {        AUDDBG("Could not read scrobbler.log contents./n");    } else {        lines = g_strsplit(contents, "/n", 0);        n_finallines = 0;        for (int i = 0 ; lines[i] != NULL && strlen(lines[i]) > 0; i++) {            if (lines_to_remove != NULL && *((int *) (lines_to_remove->data)) == i) {                //this line is to remove                lines_to_remove = g_slist_next(lines_to_remove);            } else {                //keep this line                n_finallines++;                finallines = g_realloc_n(finallines, n_finallines, sizeof(gchar *));                finallines[n_finallines-1] = g_strdup(lines[i]);            }        }        finallines = g_realloc_n(finallines, n_finallines+2, sizeof(gchar *));        finallines[n_finallines] = g_strdup("");        finallines[n_finallines+1] = NULL;        g_free(contents);        contents = g_strjoinv("/n", finallines);        success = g_file_set_contents(queuepath, contents, -1, NULL);        if (!success) {            AUDDBG("Could not write to scrobbler.log!/n");        }    }    pthread_mutex_unlock(&log_access_mutex);    g_strfreev(finallines);    g_strfreev(lines);    g_free(contents);}

//returns:// FALSE if there was a network problem.// TRUE otherwise (scrobbling_enabled must be checked)//sets scrobbling_enabled to TRUE if the session is OK//sets session_key to NULL if it is invalidstatic bool_t scrobbler_test_connection() {    if (session_key == NULL || strlen(session_key) == 0) {        scrobbling_enabled = FALSE;        return TRUE;    }    gchar *testmsg = create_message_to_lastfm("user.getRecommendedArtists",                                              3,                                              "limit", "1",                                              "api_key", SCROBBLER_API_KEY,                                              "sk", session_key                                             );    bool_t success = send_message_to_lastfm(testmsg);    g_free(testmsg);    if (success == FALSE) {        AUDDBG("Network problems. Will not scrobble any tracks./n");        scrobbling_enabled = FALSE;        if (permission_check_requested) {            perm_result = PERMISSION_NONET;        }        return FALSE;    }    gchar *error_code = NULL;    gchar *error_detail = NULL;    if (read_authentication_test_result(&error_code, &error_detail) == FALSE) {        AUDDBG("Error code: %s. Detail: %s./n", error_code, error_detail);        if (error_code != NULL && (                g_strcmp0(error_code, "4") == 0 || //error code 4: Authentication Failed - You do not have permissions to access the service                g_strcmp0(error_code, "9") == 0    //error code 9: Invalid session key - Please re-authenticate            )) {            g_free(error_code);            g_free(error_detail);            g_free(session_key);            session_key = NULL;            aud_set_string("scrobbler", "session_key", "");            scrobbling_enabled = FALSE;            return TRUE;        } else {            //network problem.            scrobbling_enabled = FALSE;            AUDDBG("Connection NOT OK. Scrobbling disabled/n");            return FALSE;        }    } else {        //THIS IS THE ONLY PLACE WHERE SCROBBLING IS SET TO ENABLED IN RUN-TIME        scrobbling_enabled = TRUE;        AUDDBG("Connection OK. Scrobbling enabled./n");        return TRUE;    }}

static bool_t start_multi_cb (PluginHandle * p, void * type){    AUDDBG ("Starting %s./n", plugin_get_name (p));    if (! table[GPOINTER_TO_INT (type)].u.m.start (p))    {        AUDDBG ("%s failed to start; disabling./n", plugin_get_name (p));        plugin_set_enabled (p, FALSE);    }    return TRUE;}

static bool_t send_message_to_lastfm(gchar *data) {    AUDDBG("This message will be sent to last.fm:/n%s/n%%%%End of message%%%%/n", data);//Enter?/n", data);    curl_easy_setopt(curlHandle, CURLOPT_POSTFIELDS, data);    CURLcode curl_requests_result = curl_easy_perform(curlHandle);    if (curl_requests_result != CURLE_OK) {        AUDDBG("Could not communicate with last.fm: %s./n", curl_easy_strerror(curl_requests_result));        return FALSE;    }    return TRUE;}

gchar *archive_decompress(const gchar *filename){    gchar *tmpdir, *cmd, *escaped_filename;    ArchiveType type;#ifndef HAVE_MKDTEMP#ifdef S_IRGRP    mode_t mode755 = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;#else    mode_t mode755 = S_IRWXU;#endif#endif    if ((type = archive_get_type(filename)) <= ARCHIVE_DIR)        return NULL;#ifdef HAVE_MKDTEMP    tmpdir = g_build_filename(g_get_tmp_dir(), "audacious.XXXXXXXX", NULL);    if (!mkdtemp(tmpdir))    {        g_free(tmpdir);        AUDDBG("Unable to load skin: Failed to create temporary "               "directory: %s/n", g_strerror(errno));        return NULL;    }#else    tmpdir = g_strdup_printf("%s/audacious.%ld", g_get_tmp_dir(), (long)rand());    make_directory(tmpdir, mode755);#endif    escaped_filename = escape_shell_chars(filename);    cmd = archive_extract_funcs[type] (escaped_filename, tmpdir);    g_free(escaped_filename);    if (!cmd)    {        AUDDBG("extraction function is NULL!/n");        g_free(tmpdir);        return NULL;    }    AUDDBG("Attempt to execute /"%s/"/n", cmd);    if (system(cmd) != 0)    {        AUDDBG("could not execute cmd %s/n", cmd);        g_free(cmd);        return NULL;    }    g_free(cmd);    return tmpdir;}

bool_t flac_get_image(const char *filename, VFSFile *fd, void **data, int64_t *length){    AUDDBG("Probe for song image./n");    FLAC__Metadata_Iterator *iter;    FLAC__Metadata_Chain *chain;    FLAC__StreamMetadata *metadata = NULL;    FLAC__Metadata_ChainStatus status;    bool_t has_image = FALSE;    chain = FLAC__metadata_chain_new();    if (!FLAC__metadata_chain_read_with_callbacks(chain, fd, io_callbacks))        goto ERR;    iter = FLAC__metadata_iterator_new();    FLAC__metadata_iterator_init(iter, chain);    while (FLAC__metadata_iterator_next(iter))        if (FLAC__metadata_iterator_get_block_type(iter) == FLAC__METADATA_TYPE_PICTURE)            break;    if (FLAC__metadata_iterator_get_block_type(iter) == FLAC__METADATA_TYPE_PICTURE)    {        metadata = FLAC__metadata_iterator_get_block(iter);        if (metadata->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER)        {            AUDDBG("FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER found.");            * data = malloc (metadata->data.picture.data_length);            * length = metadata->data.picture.data_length;            memcpy (* data, metadata->data.picture.data, * length);            has_image = TRUE;        }    }    FLAC__metadata_iterator_delete(iter);    FLAC__metadata_chain_delete(chain);    return has_image;ERR:    status = FLAC__metadata_chain_status(chain);    FLAC__metadata_chain_delete(chain);    FLACNG_ERROR("An error occured: %s/n", FLAC__Metadata_ChainStatusString[status]);    return FALSE;}

static void mp3_close(void){    if (output_file) {        int imp3, encout;        /* write remaining mp3 data */        encout = lame_encode_flush_nogap(gfp, encbuffer, LAME_MAXMP3BUFFER);        write_output(encbuffer, encout);        /* set gfp->num_samples for valid TLEN tag */        lame_set_num_samples(gfp, numsamples);        /* append v1 tag */        imp3 = lame_get_id3v1_tag(gfp, encbuffer, sizeof(encbuffer));        if (imp3 > 0)            write_output(encbuffer, imp3);        /* update v2 tag */        imp3 = lame_get_id3v2_tag(gfp, encbuffer, sizeof(encbuffer));        if (imp3 > 0) {            if (vfs_fseek(output_file, 0, SEEK_SET) != 0) {                AUDDBG("can't rewind/n");            }            else {                write_output(encbuffer, imp3);            }        }        /* update lame tag */        if (id3v2_size) {            if (vfs_fseek(output_file, id3v2_size, SEEK_SET) != 0) {                AUDDBG("fatal error: can't update LAME-tag frame!/n");            }            else {                imp3 = lame_get_lametag_frame(gfp, encbuffer, sizeof(encbuffer));                write_output(encbuffer, imp3);            }        }    }    g_free (write_buffer);    lame_close(gfp);    AUDDBG("lame_close() done/n");    free_lameid3(&lameid3);    numsamples = 0;}

int sdlout_open_audio (int format, int rate, int chan){    if (format != FMT_S16_NE)    {        sdlout_error ("Only signed 16-bit, native endian audio is supported./n");        return 0;    }    AUDDBG ("Opening audio for %d channels, %d Hz./n", chan, rate);    sdlout_chan = chan;    sdlout_rate = rate;    buffer_size = 2 * chan * (aud_get_int (NULL, "output_buffer_size") * rate / 1000);    buffer = g_malloc (buffer_size);    buffer_data_start = 0;    buffer_data_len = 0;    frames_written = 0;    prebuffer_flag = 1;    paused_flag = 0;    SDL_AudioSpec spec = {     .freq = rate,     .format = AUDIO_S16,     .channels = chan,     .samples = 4096,     .callback = callback,     .userdata = NULL};    if (SDL_OpenAudio (& spec, NULL) < 0)    {        sdlout_error ("Failed to open audio stream: %s./n", SDL_GetError ());        g_free (buffer);        buffer = NULL;        return 0;    }    return 1;}void sdlout_close_audio (void){    AUDDBG ("Closing audio./n");    SDL_CloseAudio ();    g_free (buffer);    buffer = NULL;}

static size_t read_cb(void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle){    size_t read;    if (handle == NULL)    {        FLACNG_ERROR("Trying to read data from an uninitialized file!/n");        return -1;    }    read = vfs_fread(ptr, size, nmemb, handle);    switch (read)    {        case -1:            FLACNG_ERROR("Error while reading from stream!/n");            return -1;        case 0:            AUDDBG("Stream reached EOF/n");            return 0;        default:            return read;    }}

bool_t read_metadata(FLAC__StreamDecoder *decoder, callback_info *info){    FLAC__StreamDecoderState ret;    reset_info(info);    /* Reset the decoder */    if (FLAC__stream_decoder_reset(decoder) == false)    {        FLACNG_ERROR("Could not reset the decoder!/n");        return FALSE;    }    /* Try to decode the metadata */    if (FLAC__stream_decoder_process_until_end_of_metadata(decoder) == false)    {        ret = FLAC__stream_decoder_get_state(decoder);        AUDDBG("Could not read the metadata: %s(%d)!/n",            FLAC__StreamDecoderStateString[ret], ret);        reset_info(info);        return FALSE;    }    return TRUE;}

callback_info *init_callback_info(void){    callback_info *info;    if ((info = malloc (sizeof (callback_info))) == NULL)    {        FLACNG_ERROR("Could not allocate memory for callback structure!");        return NULL;    }    memset (info, 0, sizeof (callback_info));    if ((info->output_buffer = malloc (BUFFER_SIZE_BYTE)) == NULL)    {        FLACNG_ERROR("Could not allocate memory for output buffer!");        free (info);        return NULL;    }    reset_info(info);    AUDDBG("Playback buffer allocated for %d samples, %d bytes/n", BUFFER_SIZE_SAMP, BUFFER_SIZE_BYTE);    return info;}

static GHashTable * dictionary_from_vorbis_comment (vorbis_comment * vc){    gint i;    GHashTable * dict = g_hash_table_new_full (g_str_hash, g_str_equal,     (GDestroyNotify) str_unref, (GDestroyNotify) str_unref);    for (i = 0; i < vc->comments; i++) {        gchar **frags;        AUDDBG("%s/n", vc->user_comments[i]);        frags = g_strsplit(vc->user_comments[i], "=", 2);        if (frags[0] && frags[1])        {            gchar * key = g_ascii_strdown (frags[0], -1);            g_hash_table_insert (dict, str_get (key), str_get (frags[1]));            g_free (key);        }        g_strfreev(frags); /* Don't use g_free() for string lists! --eugene */    }    return dict;}

void init_dbus(){    GError *error = NULL;    DBusConnection *local_conn;    main_thread = g_thread_self();    info_mutex = g_mutex_new();    info_cond = g_cond_new();    AUDDBG ("Trying to initialize D-Bus./n");    dbus_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);    if (dbus_conn == NULL)    {        g_warning("Unable to connect to dbus: %s", error->message);        g_error_free(error);        return;    }    g_type_init();    g_object_new(audacious_rc_get_type(), NULL);    g_object_new(mpris_root_get_type(), NULL);    mpris = g_object_new(mpris_player_get_type(), NULL);    g_object_new(mpris_tracklist_get_type(), NULL);    local_conn = dbus_g_connection_get_connection(dbus_conn);    dbus_connection_set_exit_on_disconnect(local_conn, FALSE);}

//returns:// FALSE if there was a network problem// TRUE otherwise (request_token must be checked)static bool_t scrobbler_request_token() {    gchar *tokenmsg = create_message_to_lastfm("auth.getToken",                                              1,                                              "api_key", SCROBBLER_API_KEY                                             );    if (send_message_to_lastfm(tokenmsg) == FALSE) {        AUDDBG("Could not send token request to last.fm./n");        g_free(tokenmsg);        return FALSE;    }    gchar *error_code = NULL;    gchar *error_detail = NULL;    if (read_token(&error_code, &error_detail) == FALSE) {        if (error_code != NULL && g_strcmp0(error_code, "8")) {            //error code 8: There was an error granting the request token. Please try again later            request_token = NULL;            return FALSE;        }        return FALSE;    }    return TRUE;}

void plugin_load (const char * filename){    GModule *module;    Plugin * (* func) (AudAPITable * table);    AUDDBG ("Loading plugin: %s./n", filename);    if (!(module = g_module_open(filename, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL)))    {        printf("Failed to load plugin (%s): %s/n", filename, g_module_error());        return;    }    /* v2 plugin loading */    if (g_module_symbol (module, "get_plugin_info", (void *) & func))    {        Plugin * header = func (& api_table);        g_return_if_fail (header != NULL);        plugin2_process(header, module, filename);        return;    }    printf("Invalid plugin (%s)/n", filename);    g_module_close(module);}

static bool_t update_session_key() {    bool_t result = TRUE;    gchar *error_code = NULL;    gchar *error_detail = NULL;    if (read_session_key(&error_code, &error_detail) == FALSE) {        if (error_code != NULL && (                g_strcmp0(error_code,  "4") == 0 || //invalid token                g_strcmp0(error_code, "14") == 0 || //token not authorized                g_strcmp0(error_code, "15") == 0    //token expired            )) {            AUDDBG("error code CAUGHT: %s/n", error_code);            g_free(session_key);            session_key = NULL;            result = TRUE;        } else {            result= FALSE;        }    }    if (session_key == NULL) {        aud_set_string("scrobbler", "session_key", "");    } else {        aud_set_string("scrobbler", "session_key", session_key);    }    return result;}

static int open_device(void){    int res = -1;    int flags = O_WRONLY;    char *device = aud_get_string("oss4", "device");    char *alt_device = aud_get_string("oss4", "alt_device");    if (aud_get_bool("oss4", "exclusive"))    {        AUDDBG("Enabled exclusive mode./n");        flags |= O_EXCL;    }    if (aud_get_bool("oss4", "use_alt_device") && alt_device != NULL)        res = open(alt_device, flags);    else if (device != NULL)        res = open(device, flags);    else        res = open(DEFAULT_DSP, flags);    free(device);    free(alt_device);    return res;}

EXPORT void audgui_simple_message (GtkWidget * * widget, GtkMessageType type, const char * title, const char * text){    AUDDBG ("%s/n", text);    if (* widget)    {        const char * old = NULL;        g_object_get ((GObject *) * widget, "text", & old, NULL);        g_return_if_fail (old);        int messages = GPOINTER_TO_INT (g_object_get_data ((GObject *) * widget, "messages"));        if (messages > 10)            text = _("/n(Further messages have been hidden.)");        if (! strstr (old, text))        {            SCONCAT3 (both, old, "/n", text);            g_object_set ((GObject *) * widget, "text", both, NULL);            g_object_set_data ((GObject *) * widget, "messages", GINT_TO_POINTER (messages + 1));        }        gtk_window_present ((GtkWindow *) * widget);    }    else    {        GtkWidget * button = audgui_button_new (_("Close"), "window-close", NULL, NULL);        * widget = audgui_dialog_new (type, title, text, button, NULL);        g_object_set_data ((GObject *) * widget, "messages", GINT_TO_POINTER (1));        g_signal_connect (* widget, "destroy", (GCallback) gtk_widget_destroyed, widget);        gtk_widget_show_all (* widget);    }}

static void pulse_write(void* ptr, int length) {    int writeoffs, remain, writable;    CHECK_CONNECTED();    pa_threaded_mainloop_lock(mainloop);    CHECK_DEAD_GOTO(fail, 1);    /* break large fragments into smaller fragments. --nenolod */    for (writeoffs = 0, remain = length;         writeoffs < length;         writeoffs += writable, remain -= writable)    {         void * pptr = (char *) ptr + writeoffs;         writable = length - writeoffs;         size_t fragsize = pa_stream_writable_size(stream);         /* don't write more than what PA is willing to handle right now. */         if (writable > fragsize)             writable = fragsize;         if (pa_stream_write(stream, pptr, writable, NULL, PA_SEEK_RELATIVE, 0) < 0) {             AUDDBG("pa_stream_write() failed: %s", pa_strerror(pa_context_errno(context)));             goto fail;         }    }    do_trigger = 0;    written += length;fail:    pa_threaded_mainloop_unlock(mainloop);}