bool Converter::can_open(Speakers new_spk) const { if ((FORMAT_MASK(new_spk.format) & converter_formats) == 0) return false; if (new_spk.format == format) return true; if (new_spk.nch() == 0) return false; if (find_conversion(format, new_spk) == 0) return false; return true; }
char *recode_out(const SERVER_REC *server, const char *str, const char *target) { char *recoded = NULL; const char *from = NULL; const char *to = NULL; char *translit_to = NULL; gboolean translit, term_is_utf8, recode; int len; if (!str) return NULL; recode = settings_get_bool("recode"); if (!recode) return g_strdup(str); len = strlen(str); translit = settings_get_bool("recode_transliterate"); to = find_conversion(server, target); if (to == NULL) /* default outgoing charset if set */ to = settings_get_str("recode_out_default_charset"); if (to && *to != '\0') { if (translit && !is_translit(to)) to = translit_to = g_strconcat(to ,"//TRANSLIT", NULL); term_is_utf8 = recode_get_charset(&from); recoded = g_convert(str, len, to, from, NULL, NULL, NULL); } g_free(translit_to); if (!recoded) recoded = g_strdup(str); return recoded; }
bool Converter::init() { ///////////////////////////////////////////////////////// // Initialize convertor: // * find conversion function // * allocate buffer // * reset filter state if (spk.format == format) // no conversion required; no buffer required return true; convert = find_conversion(format, spk); if (convert == 0) return false; buf.allocate(spk.nch() * nsamples * sample_size(format)); if (format == FORMAT_LINEAR) { // set channel pointers out_samples[0] = (sample_t *)buf.begin(); for (int ch = 1; ch < spk.nch(); ch++) out_samples[ch] = out_samples[ch-1] + nsamples; out_rawdata = 0; } else { // set rawdata pointer out_rawdata = buf.begin(); out_samples.zero(); } reset(); return true; }
char *recode_in(const SERVER_REC *server, const char *str, const char *target) { const char *from = NULL; const char *to = NULL; char *translit_to = NULL; char *recoded = NULL; gboolean term_is_utf8, str_is_utf8, translit, recode, autodetect; int len; int i; if (!str) return NULL; recode = settings_get_bool("recode"); if (!recode) return g_strdup(str); len = strlen(str); /* Only validate for UTF-8 if an 8-bit encoding. */ str_is_utf8 = 0; for (i = 0; i < len; ++i) { if (str[i] & 0x80) { str_is_utf8 = g_utf8_validate(str, len, NULL); break; } } translit = settings_get_bool("recode_transliterate"); autodetect = settings_get_bool("recode_autodetect_utf8"); term_is_utf8 = recode_get_charset(&to); if (autodetect && str_is_utf8) if (term_is_utf8) return g_strdup(str); else from = "UTF-8"; else { from = find_conversion(server, target); } if (translit && !is_translit(to)) to = translit_to = g_strconcat(to, "//TRANSLIT", NULL); if (from) recoded = g_convert_with_fallback(str, len, to, from, NULL, NULL, NULL, NULL); if (!recoded) { if (term_is_utf8) { if (!str_is_utf8) from = settings_get_str("recode_fallback"); } else if (str_is_utf8) from = "UTF-8"; if (from) recoded = g_convert_with_fallback(str, len, to, from, NULL, NULL, NULL, NULL); if (!recoded) recoded = g_strdup(str); } g_free(translit_to); return recoded; }
/** * tracker_sparql_escape_uri_vprintf: * @format: a standard printf() format string, but notice * <link linkend="string-precision">string precision pitfalls</link> documented in g_strdup_printf() * @args: the list of parameters to insert into the format string * * Similar to the standard C vsprintf() function but safer, since it * calculates the maximum space required and allocates memory to hold * the result. * * The result is escaped using g_uri_escape_string(). * * Returns: a newly-allocated string holding the result. The returned string * should be freed with g_free() when no longer needed. * * Since: 0.10 */ gchar * tracker_sparql_escape_uri_vprintf (const gchar *format, va_list args) { GString *format1; GString *format2; GString *result = NULL; gchar *output1 = NULL; gchar *output2 = NULL; const char *p; gchar *op1, *op2; va_list args2; format1 = g_string_new (NULL); format2 = g_string_new (NULL); p = format; while (TRUE) { const char *after; const char *conv = find_conversion (p, &after); if (!conv) break; g_string_append_len (format1, conv, after - conv); g_string_append_c (format1, 'X'); g_string_append_len (format2, conv, after - conv); g_string_append_c (format2, 'Y'); p = after; } /* Use them to format the arguments */ G_VA_COPY (args2, args); output1 = g_strdup_vprintf (format1->str, args); va_end (args); if (!output1) { va_end (args2); goto cleanup; } output2 = g_strdup_vprintf (format2->str, args2); va_end (args2); if (!output2) goto cleanup; result = g_string_new (NULL); op1 = output1; op2 = output2; p = format; while (TRUE) { const char *after; const char *output_start; const char *conv = find_conversion (p, &after); char *escaped; if (!conv) { g_string_append_len (result, p, after - p); break; } g_string_append_len (result, p, conv - p); output_start = op1; while (*op1 == *op2) { op1++; op2++; } *op1 = '\0'; escaped = g_uri_escape_string (output_start, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH_ELEMENT, FALSE); g_string_append (result, escaped); g_free (escaped); p = after; op1++; op2++; } cleanup: g_string_free (format1, TRUE); g_string_free (format2, TRUE); g_free (output1); g_free (output2); if (result) return g_string_free (result, FALSE); else return NULL; }