/*
* Convert a numeric-string to its locale-specific appearance.
* The string must have one of these forms:
*
* 1) [sign] digits [exponent-part]
* 2) [sign] digits '.' [digits] [exponent-part]
*
* Not allowed, since _mpd_to_string() never returns this form:
*
* 3) [sign] '.' digits [exponent-part]
*
* Input: result->data := original numeric string (ASCII)
* result->bytes := strlen(result->data)
* result->nchars := strlen(result->data)
*
* Output: result->data := modified or original string
* result->bytes := strlen(result->data)
* result->nchars := number of characters (possibly UTF-8)
*/
static int
_mpd_apply_lconv(mpd_mbstr_t *result, const mpd_spec_t *spec, uint32_t *status)
{
const char *sign = NULL, *intpart = NULL, *dot = NULL;
const char *rest, *dp;
char *decstring;
mpd_ssize_t n_int, n_rest;
/* original numeric string */
dp = result->data;
/* sign */
if (*dp == '+' || *dp == '-' || *dp == ' ') {
sign = dp++;
}
/* integer part */
assert(isdigit((uchar)*dp));
intpart = dp++;
while (isdigit((uchar)*dp)) {
dp++;
}
n_int = (mpd_ssize_t)(dp-intpart);
/* decimal point */
if (*dp == '.') {
dp++; dot = spec->dot;
}
/* rest */
rest = dp;
n_rest = result->nbytes - (mpd_ssize_t)(dp-result->data);
if (dot == NULL && (*spec->sep == '\0' || *spec->grouping == '\0')) {
/* _mpd_add_sep_dot() would not change anything */
return 1;
}
/* Determine the size of the new decimal string after inserting the
* decimal point, optional separators and optional padding. */
decstring = result->data;
result->data = NULL;
_mpd_add_sep_dot(result, sign, intpart, n_int, dot,
rest, n_rest, spec);
result->data = mpd_alloc(result->nbytes+1, 1);
if (result->data == NULL) {
*status |= MPD_Malloc_error;
mpd_free(decstring);
return 0;
}
/* Perform actual writes. */
_mpd_add_sep_dot(result, sign, intpart, n_int, dot,
rest, n_rest, spec);
mpd_free(decstring);
return 1;
}
int main(int argc, char **argv) {
int iport = 6600;
char *hostname = getenv("MPD_HOST");
char *port = getenv("MPD_PORT");
char *password = getenv("MPD_PASSWORD");
MpdObj *obj = NULL;
if(!hostname) {
hostname = "localhost";
}
if(port){
iport = atoi(port);
}
/* Create mpd object */
obj = mpd_new(hostname, iport,password);
/* Connect signals */
mpd_signal_connect_error(obj,(ErrorCallback)error_callback, NULL);
mpd_signal_connect_status_changed(obj,(StatusChangedCallback)status_changed, NULL);
/* Set timeout */
mpd_set_connection_timeout(obj, 10);
if(!mpd_connect(obj))
{
mpd_send_password(obj);
do{
mpd_status_update(obj);
} while(!usleep(300000));
}
mpd_free(obj);
return 0;
}
bool
gimmix_connect (void)
{
char *host = NULL;
char *pass = NULL;
int port;
host = cfg_get_key_value (conf, "mpd_hostname");
pass = cfg_get_key_value (conf, "mpd_password");
port = atoi (cfg_get_key_value (conf, "mpd_port"));
gmo = mpd_new (host, port, pass);
mpd_signal_connect_error (gmo, (ErrorCallback)gimmix_mpd_connection_error_callback, NULL);
if (mpd_connect(gmo) == MPD_OK)
{
mpd_send_password (gmo);
printf ("connected to mpd\n");
mpd_signal_connect_connection_changed (gmo, (ConnectionChangedCallback)gimmix_mpd_connection_changed_callback, NULL);
return true;
}
else
{
mpd_free (gmo);
gmo = NULL;
}
return false;
}
int
main(int argc, char **argv)
{
mpd_context_t ctx;
mpd_t *a, *b;
mpd_t *q, *r;
char *qs, *rs;
char status_str[MPD_MAX_FLAG_STRING];
clock_t start_clock, end_clock;
if (argc != 3) {
fprintf(stderr, "divmod: usage: ./divmod x y\n");
exit(1);
}
mpd_init(&ctx, 38);
ctx.traps = 0;
q = mpd_new(&ctx);
r = mpd_new(&ctx);
a = mpd_new(&ctx);
b = mpd_new(&ctx);
mpd_set_string(a, argv[1], &ctx);
mpd_set_string(b, argv[2], &ctx);
start_clock = clock();
mpd_divmod(q, r, a, b, &ctx);
end_clock = clock();
fprintf(stderr, "time: %f\n\n",
(double)(end_clock-start_clock)/(double)CLOCKS_PER_SEC);
qs = mpd_to_sci(q, 1);
rs = mpd_to_sci(r, 1);
mpd_snprint_flags(status_str, MPD_MAX_FLAG_STRING, ctx.status);
printf("%s %s %s\n", qs, rs, status_str);
mpd_del(q);
mpd_del(r);
mpd_del(a);
mpd_del(b);
mpd_free(qs);
mpd_free(rs);
return 0;
}
void tidyUp() {
if(fd) {
close(fd);
}
if(obj != NULL) {
mpd_free(obj);
}
}
void
gimmix_disconnect (MpdObj *mo)
{
if (mo != NULL || mpd_check_connected(mo))
{
mpd_free (mo);
}
return;
}
static void __async_handler_function(GSimpleAsyncResult * simple, GObject * object, GCancellable * cancel)
{
MpdAsyncData *data = g_simple_async_result_get_op_res_gpointer(G_SIMPLE_ASYNC_RESULT(simple));
g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Start async function\n");
if (mpd_connect(data->mi) == MPD_OK)
{
g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "call function\n");
data->result = (data->function(data->mi, data->function_data));
g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Got result: %p\n", data->result);
}
mpd_free(data->mi);
}
static void
gimmix_mpd_error (MpdObj *mo, int id, char *msg, void *userdata)
{
if (id&MPD_STATUS_FAILED || id&MPD_STATS_FAILED || id&MPD_SERVER_ERROR || id&MPD_FATAL_ERROR)
{
mpd_free (gmo);
gmo = gimmix_mpd_connect ();
mpd_signal_connect_status_changed (gmo, (StatusChangedCallback)gimmix_status_changed, NULL);
mpd_signal_connect_error (gmo, (ErrorCallback)gimmix_mpd_error, NULL);
}
return;
}
void
mpd_print(const mpd_t *dec)
{
char *decstring;
decstring = mpd_to_sci(dec, 1);
if (decstring != NULL) {
printf("%s\n", decstring);
mpd_free(decstring);
}
else {
fputs("mpd_fprint: output error\n", stderr); /* GCOV_NOT_REACHED */
}
}
/* The following two functions are mainly intended for debugging. */
void
mpd_fprint(FILE *file, const mpd_t *dec)
{
char *decstring;
decstring = mpd_to_sci(dec, 1);
if (decstring != NULL) {
fprintf(file, "%s\n", decstring);
mpd_free(decstring);
}
else {
fputs("mpd_fprint: output error\n", file); /* GCOV_NOT_REACHED */
}
}
int
main(int argc, char **argv)
{
mpd_context_t ctx;
mpd_t *a, *b;
mpd_t *result;
char *rstring;
char status_str[MPD_MAX_FLAG_STRING];
clock_t start_clock, end_clock;
if (argc != 3) {
fprintf(stderr, "shift: usage: ./shift x y\n");
exit(1);
}
mpd_init(&ctx, 38);
ctx.traps = 0;
result = mpd_new(&ctx);
a = mpd_new(&ctx);
b = mpd_new(&ctx);
mpd_set_string(a, argv[1], &ctx);
mpd_set_string(b, argv[2], &ctx);
start_clock = clock();
mpd_shift(result, a, b, &ctx);
end_clock = clock();
fprintf(stderr, "time: %f\n\n",
(double)(end_clock-start_clock)/(double)CLOCKS_PER_SEC);
rstring = mpd_to_sci(result, 1);
mpd_snprint_flags(status_str, MPD_MAX_FLAG_STRING, ctx.status);
printf("%s %s\n", rstring, status_str);
mpd_del(a);
mpd_del(b);
mpd_del(result);
mpd_free(rstring);
return 0;
}
/* -------------------------------------------------------------------------- */
static bool mpd_start_connection(struct lcd_stuff_mpd *mpd)
{
int err;
mpd->error = false;
/* create the current song */
mpd_song_delete(mpd->current_song);
mpd->current_song = mpd_song_new("", "");
/* create the object */
if (mpd->mpd) {
mpd_free(mpd->mpd);
mpd->mpd = NULL;
}
mpd->mpd = mpd_new(mpd->connection->host, mpd->connection->port, mpd->connection->password);
/* connect signal handlers */
mpd_signal_connect_error(mpd->mpd, mpd_error_handler, mpd);
mpd_signal_connect_status_changed(mpd->mpd, mpd_state_changed_handler, mpd);
mpd_signal_connect_connection_changed(mpd->mpd, mpd_connection_changed_handler, mpd);
/* set timeout */
mpd_set_connection_timeout(mpd->mpd, mpd->timeout);
if (mpd->error) {
mpd_disconnect(mpd->mpd);
return false;
}
/* connect */
err = mpd_connect(mpd->mpd);
if (err != MPD_OK || mpd->error) {
report(RPT_ERR, "Failed to connect: %d", err);
return false;
}
return true;
}
/* -------------------------------------------------------------------------- */
void *mpd_run(void *cookie)
{
time_t next_update, current;
gboolean result;
int retry_count = RETRY_INTERVAL;
struct lcd_stuff_mpd mpd;
/* default values */
mpd.lcd = (struct lcd_stuff *)cookie;
mpd.mpd = NULL;
mpd.error = 0;
mpd.current_state = 0;
mpd.song_displayed = false;
mpd.current_song = NULL;
mpd.stop_time = UINT_MAX;
mpd.current_list = NULL;
mpd.connection = NULL;
mpd.timeout = 0;
result = key_file_has_group(MODULE_NAME);
if (!result) {
report(RPT_INFO, "mpd disabled");
conf_dec_count();
return NULL;
}
if (!mpd_init(&mpd))
goto out;
if (!mpd_init_connection(&mpd))
goto out_screen;
if (!mpd_start_connection(&mpd))
goto out_screen;
/* do first update instantly */
next_update = time(NULL);
conf_dec_count();
/* dispatcher */
while (!g_exit) {
/* if we are in error state, try to retrieve a connection first */
if (mpd.error) {
if (retry_count-- <= 0) { /* each minute */
if (mpd_start_connection(&mpd)) {
mpd.error = false;
} else {
retry_count = RETRY_INTERVAL;
}
}
if (mpd.error) {
g_usleep(1000000);
continue;
}
}
current = time(NULL);
g_usleep(1000000);
mpd_status_queue_update(mpd.mpd);
mpd_status_check(mpd.mpd);
mpd_update_status_time(&mpd);
/* check playlists ? */
if (current > next_update) {
mpd_update_playlist_menu(&mpd);
next_update = time(NULL) + 60;
} if (current > mpd.stop_time) {
mpd_player_stop(mpd.mpd);
mpd.stop_time = UINT_MAX;
service_thread_command(mpd.lcd->service_thread,
"menu_set_item \"\" mpd_standby -value 0\n");
}
}
out_screen:
mpd_deinit(&mpd);
out:
if (mpd.mpd)
mpd_free(mpd.mpd);
if (mpd.current_list)
mpd_free_playlist(mpd.current_list);
service_thread_unregister_client(mpd.lcd->service_thread, MODULE_NAME);
mpd_song_delete(mpd.current_song);
connection_delete(mpd.connection);
return NULL;
}
/* forward transform with sign = -1 */
int
six_step_fnt(mpd_uint_t *a, mpd_size_t n, int modnum)
{
struct fnt_params *tparams;
mpd_size_t log2n, C, R;
mpd_uint_t kernel;
mpd_uint_t umod;
#ifdef PPRO
double dmod;
uint32_t dinvmod[3];
#endif
mpd_uint_t *x, w0, w1, wstep;
mpd_size_t i, k;
assert(ispower2(n));
assert(n >= 16);
assert(n <= MPD_MAXTRANSFORM_2N);
log2n = mpd_bsr(n);
C = ((mpd_size_t)1) << (log2n / 2); /* number of columns */
R = ((mpd_size_t)1) << (log2n - (log2n / 2)); /* number of rows */
/* Transpose the matrix. */
if (!transpose_pow2(a, R, C)) {
return 0;
}
/* Length R transform on the rows. */
if ((tparams = _mpd_init_fnt_params(R, -1, modnum)) == NULL) {
return 0;
}
for (x = a; x < a+n; x += R) {
fnt_dif2(x, R, tparams);
}
/* Transpose the matrix. */
if (!transpose_pow2(a, C, R)) {
mpd_free(tparams);
return 0;
}
/* Multiply each matrix element (addressed by i*C+k) by r**(i*k). */
SETMODULUS(modnum);
kernel = _mpd_getkernel(n, -1, modnum);
for (i = 1; i < R; i++) {
w0 = 1; /* r**(i*0): initial value for k=0 */
w1 = POWMOD(kernel, i); /* r**(i*1): initial value for k=1 */
wstep = MULMOD(w1, w1); /* r**(2*i) */
for (k = 0; k < C; k += 2) {
mpd_uint_t x0 = a[i*C+k];
mpd_uint_t x1 = a[i*C+k+1];
MULMOD2(&x0, w0, &x1, w1);
MULMOD2C(&w0, &w1, wstep); /* r**(i*(k+2)) = r**(i*k) * r**(2*i) */
a[i*C+k] = x0;
a[i*C+k+1] = x1;
}
}
/* Length C transform on the rows. */
if (C != R) {
mpd_free(tparams);
if ((tparams = _mpd_init_fnt_params(C, -1, modnum)) == NULL) {
return 0;
}
}
for (x = a; x < a+n; x += C) {
fnt_dif2(x, C, tparams);
}
mpd_free(tparams);
#if 0
/* An unordered transform is sufficient for convolution. */
/* Transpose the matrix. */
if (!transpose_pow2(a, R, C)) {
return 0;
}
#endif
return 1;
}
/* Add padding to the formatted string if necessary. */
static int
_mpd_add_pad(mpd_mbstr_t *result, const mpd_spec_t *spec, uint32_t *status)
{
if (result->nchars < spec->min_width) {
mpd_ssize_t add_chars, add_bytes;
size_t lpad = 0, rpad = 0;
size_t n_fill, len, i, j;
char align = spec->align;
uint8_t err = 0;
char *cp;
n_fill = strlen(spec->fill);
add_chars = (spec->min_width - result->nchars);
/* max value: MPD_MAX_PREC * 4 */
add_bytes = add_chars * (mpd_ssize_t)n_fill;
cp = result->data = mpd_realloc(result->data,
result->nbytes+add_bytes+1,
sizeof *result->data, &err);
if (err) {
*status |= MPD_Malloc_error;
mpd_free(result->data);
return 0;
}
if (align == 'z') {
align = '=';
}
if (align == '<') {
rpad = add_chars;
}
else if (align == '>' || align == '=') {
lpad = add_chars;
}
else { /* align == '^' */
lpad = add_chars/2;
rpad = add_chars-lpad;
}
len = result->nbytes;
if (align == '=' && (*cp == '-' || *cp == '+' || *cp == ' ')) {
/* leave sign in the leading position */
cp++; len--;
}
memmove(cp+n_fill*lpad, cp, len);
for (i = 0; i < lpad; i++) {
for (j = 0; j < n_fill; j++) {
cp[i*n_fill+j] = spec->fill[j];
}
}
cp += (n_fill*lpad + len);
for (i = 0; i < rpad; i++) {
for (j = 0; j < n_fill; j++) {
cp[i*n_fill+j] = spec->fill[j];
}
}
result->nbytes += add_bytes;
result->nchars += add_chars;
result->data[result->nbytes] = '\0';
}
return 1;
}
/*
* Knuth, TAOCP Volume 2, 4.3.1:
* q, r := quotient and remainder of uconst (len nplusm)
* divided by vconst (len n)
* nplusm >= n
*
* If r is not NULL, r will contain the remainder. If r is NULL, the
* return value indicates if there is a remainder: 1 for true, 0 for
* false. A return value of -1 indicates an error.
*/
int
_mpd_basedivmod(mpd_uint_t *q, mpd_uint_t *r,
const mpd_uint_t *uconst, const mpd_uint_t *vconst,
mpd_size_t nplusm, mpd_size_t n)
{
mpd_uint_t ustatic[MPD_MINALLOC_MAX];
mpd_uint_t vstatic[MPD_MINALLOC_MAX];
mpd_uint_t *u = ustatic;
mpd_uint_t *v = vstatic;
mpd_uint_t d, qhat, rhat, w2[2];
mpd_uint_t hi, lo, x;
mpd_uint_t carry;
mpd_size_t i, j, m;
int retval = 0;
assert(n > 1 && nplusm >= n);
m = sub_size_t(nplusm, n);
/* D1: normalize */
d = MPD_RADIX / (vconst[n-1] + 1);
if (nplusm >= MPD_MINALLOC_MAX) {
if ((u = mpd_alloc(nplusm+1, sizeof *u)) == NULL) {
return -1;
}
}
if (n >= MPD_MINALLOC_MAX) {
if ((v = mpd_alloc(n+1, sizeof *v)) == NULL) {
mpd_free(u);
return -1;
}
}
_mpd_shortmul(u, uconst, nplusm, d);
_mpd_shortmul(v, vconst, n, d);
/* D2: loop */
for (j=m; j != MPD_SIZE_MAX; j--) {
/* D3: calculate qhat and rhat */
rhat = _mpd_shortdiv(w2, u+j+n-1, 2, v[n-1]);
qhat = w2[1] * MPD_RADIX + w2[0];
while (1) {
if (qhat < MPD_RADIX) {
_mpd_singlemul(w2, qhat, v[n-2]);
if (w2[1] <= rhat) {
if (w2[1] != rhat || w2[0] <= u[j+n-2]) {
break;
}
}
}
qhat -= 1;
rhat += v[n-1];
if (rhat < v[n-1] || rhat >= MPD_RADIX) {
break;
}
}
/* D4: multiply and subtract */
carry = 0;
for (i=0; i <= n; i++) {
_mpd_mul_words(&hi, &lo, qhat, v[i]);
lo = carry + lo;
if (lo < carry) hi++;
_mpd_div_words_r(&hi, &lo, hi, lo);
x = u[i+j] - lo;
carry = (u[i+j] < x);
u[i+j] = carry ? x+MPD_RADIX : x;
carry += hi;
}
q[j] = qhat;
/* D5: test remainder */
if (carry) {
q[j] -= 1;
/* D6: add back */
(void)_mpd_baseadd(u+j, u+j, v, n+1, n);
}
}
/* D8: unnormalize */
if (r != NULL) {
_mpd_shortdiv(r, u, n, d);
/* we are not interested in the return value here */
retval = 0;
}
else {
retval = !_mpd_isallzero(u, n);
}
if (u != ustatic) mpd_free(u);
if (v != vstatic) mpd_free(v);
return retval;
}
void EigenLib_cplx_mpType_Print(const char * Title, mpCplxMatrixPtr xPtr)
{
int mRows = xPtr->rows();
int mCols = xPtr->cols();
cplx_mpType x;
printf ("\n");
printf (Title);
printf ("\n");
#if defined (Use_Mpfi)
mpfr_t real_fL;
mpfr_init(real_fL);
mpfr_t real_fR;
mpfr_init(real_fR);
mpfr_t imag_fL;
mpfr_init(imag_fL);
mpfr_t imag_fR;
mpfr_init(imag_fR);
#endif // defined (Use_Mpfi)
for (int i=1; i<=mRows; i++)
{
for (int j=1; j<=mCols; j++)
{
EigenLib_cplx_mpType_GetCoeff(&x, i-1, j-1, xPtr);
#if defined (Use_Float)
__mingw_printf("(%.8E,%.8E) ", real(x), imag(x));
#endif
#if defined (Use_Double)
__mingw_printf("(%.16E,%.16E) ", real(x), imag(x));
#endif
#if defined (Use_LongDouble)
__mingw_printf("(%.20LE,%.20LE) ", real(x), imag(x));
#endif
#if defined (Use_Mpfr)
mpfr_printf("(%.RE,%.RE) ", real(x).mpfr_ptr(), imag(x).mpfr_ptr());
#endif
#if defined (Use_Mpfi)
mpfi_get_left(real_fL, real(x).mpfi_ptr());
mpfi_get_right(real_fR, real(x).mpfi_ptr());
mpfi_get_left(imag_fL, imag(x).mpfi_ptr());
mpfi_get_right(imag_fR, imag(x).mpfi_ptr());
mpfr_printf("([%.RE,%.RE] [%.RE,%.RE]) ", real_fL, real_fR, imag_fL, imag_fR);
#endif
#if defined (Use_Mpdec)
char *s1 = mpd_to_sci(real(x).mpd_ptr(), 1);
char *s2 = mpd_to_sci(imag(x).mpd_ptr(), 1);
printf("(%s,%s)", s1, s2);
mpd_free(s1);
mpd_free(s2);
#endif
}
printf("\n");
}
#if defined (Use_Mpfi)
mpfr_clear(real_fL);
mpfr_clear(real_fR);
mpfr_clear(imag_fL);
mpfr_clear(imag_fR);
#endif // defined (Use_Mpfi)
}
int
main(int argc, char **argv)
{
mpd_uint_t *a, *b;
mpd_uint_t *fntresult, *kresult;
mpd_size_t alen, blen, k;
double total = (WORDS-1)*(WORDS)-12;
double counter = 0;
mpd_size_t rsize;
time_t seed;
int verbose;
verbose = !(argc > 1 && strcmp(argv[1], "-q") == 0);
a = malloc(WORDS * (sizeof *a));
b = malloc(WORDS * (sizeof *b));
for (k = 0; k < WORDS; k++) {
a[k] = MPD_RADIX-1;
}
for (k = 0; k < WORDS; k++) {
b[k] = MPD_RADIX-1;
}
if (!verbose) {
fprintf(stderr, "%s ... ", argv[0]);
}
/* test with all digits 9 */
for (alen = 4; alen < WORDS; alen++) {
if (verbose) {
fprintf(stderr, "\r%s: progress: %2.4f%%",
argv[0], (counter/total*100));
}
for (blen = 1; blen <= alen; blen++) {
counter++;
fntresult = _mpd_fntmul(a, b, alen, blen, &rsize);
kresult = _mpd_kmul(a, b, alen, blen, &rsize);
for (k = 0; k < alen+blen; k++) {
if (kresult[k] != fntresult[k]) {
fprintf(stderr, " FAIL\n");
exit(1);
}
}
mpd_free(fntresult);
mpd_free(kresult);
}
}
/* random test */
seed = time(NULL);
srandom((unsigned int)seed);
for (alen = 4; alen < WORDS; alen++) {
if (verbose) {
fprintf(stderr, "\r%s: progress: %2.4f%%", argv[0],
(counter/total*100));
}
for (k = 0; k < alen; k++) {
a[k] = random()%MPD_RADIX;
}
for (blen = 1; blen <= alen; blen++) {
counter++;
for (k = 0; k < blen; k++) {
b[k] = random()%MPD_RADIX;
}
fntresult = _mpd_fntmul(a, b, alen, blen, &rsize);
kresult = _mpd_kmul(a, b, alen, blen, &rsize);
for (k = 0; k < alen+blen; k++) {
if (kresult[k] != fntresult[k]) {
fprintf(stderr, " FAIL: seed = %"PRI_time_t"\n", seed);
exit(1);
}
}
mpd_free(fntresult);
mpd_free(kresult);
}
}
if (verbose) {
fprintf(stderr, "\r%s: progress: %2.4f%%", argv[0], 100.0);
}
fprintf(stderr, " PASS\n");
mpd_free(a);
mpd_free(b);
return 0;
}
/*
* Swap half-rows of 2^n * (2*2^n) matrix.
* FORWARD_CYCLE: even/odd permutation of the halfrows.
* BACKWARD_CYCLE: reverse the even/odd permutation.
*/
static int
swap_halfrows_pow2(mpd_uint_t *matrix, mpd_size_t rows, mpd_size_t cols, int dir)
{
mpd_uint_t buf1[BUFSIZE];
mpd_uint_t buf2[BUFSIZE];
mpd_uint_t *readbuf, *writebuf, *hp;
mpd_size_t *done, dbits;
mpd_size_t b = BUFSIZE, stride;
mpd_size_t hn, hmax; /* halfrow number */
mpd_size_t m, r=0;
mpd_size_t offset;
mpd_size_t next;
assert(cols == mul_size_t(2, rows));
if (dir == FORWARD_CYCLE) {
r = rows;
}
else if (dir == BACKWARD_CYCLE) {
r = 2;
}
else {
abort(); /* GCOV_NOT_REACHED */
}
m = cols - 1;
hmax = rows; /* cycles start at odd halfrows */
dbits = 8 * sizeof *done;
if ((done = mpd_calloc(hmax/(sizeof *done) + 1, sizeof *done)) == NULL) {
return 0;
}
for (hn = 1; hn <= hmax; hn += 2) {
if (done[hn/dbits] & mpd_bits[hn%dbits]) {
continue;
}
readbuf = buf1; writebuf = buf2;
for (offset = 0; offset < cols/2; offset += b) {
stride = (offset + b < cols/2) ? b : cols/2-offset;
hp = matrix + hn*cols/2;
memcpy(readbuf, hp+offset, stride*(sizeof *readbuf));
pointerswap(&readbuf, &writebuf);
next = mulmod_size_t(hn, r, m);
hp = matrix + next*cols/2;
while (next != hn) {
memcpy(readbuf, hp+offset, stride*(sizeof *readbuf));
memcpy(hp+offset, writebuf, stride*(sizeof *writebuf));
pointerswap(&readbuf, &writebuf);
done[next/dbits] |= mpd_bits[next%dbits];
next = mulmod_size_t(next, r, m);
hp = matrix + next*cols/2;
}
memcpy(hp+offset, writebuf, stride*(sizeof *writebuf));
done[hn/dbits] |= mpd_bits[hn%dbits];
}
}
mpd_free(done);
return 1;
}
/*
* Return the string representation of an mpd_t, formatted according to 'spec'.
* The format specification is assumed to be valid. Memory errors are indicated
* as usual. This function is quiet.
*/
char *
mpd_qformat_spec(const mpd_t *dec, const mpd_spec_t *spec,
const mpd_context_t *ctx, uint32_t *status)
{
mpd_uint_t dt[MPD_MINALLOC_MAX];
mpd_t tmp = {MPD_STATIC|MPD_STATIC_DATA,0,0,0,MPD_MINALLOC_MAX,dt};
mpd_ssize_t dplace = MPD_DEFAULT_DOTPLACE;
mpd_mbstr_t result;
mpd_spec_t stackspec;
char type = spec->type;
int flags = 0;
if (spec->min_width > MPD_MAX_PREC) {
*status |= MPD_Invalid_operation;
return NULL;
}
if (isupper((uchar)type)) {
type = tolower((uchar)type);
flags |= MPD_FMT_UPPER;
}
if (spec->sign == ' ') {
flags |= MPD_FMT_SIGN_SPACE;
}
else if (spec->sign == '+') {
flags |= MPD_FMT_SIGN_PLUS;
}
if (mpd_isspecial(dec)) {
if (spec->align == 'z') {
stackspec = *spec;
stackspec.fill[0] = ' ';
stackspec.fill[1] = '\0';
stackspec.align = '>';
spec = &stackspec;
}
}
else {
uint32_t workstatus = 0;
mpd_ssize_t prec;
switch (type) {
case 'g': flags |= MPD_FMT_TOSCI; break;
case 'e': flags |= MPD_FMT_EXP; break;
case '%': flags |= MPD_FMT_PERCENT;
if (!mpd_qcopy(&tmp, dec, status)) {
return NULL;
}
tmp.exp += 2;
dec = &tmp;
type = 'f'; /* fall through */
case 'f': flags |= MPD_FMT_FIXED; break;
default: abort(); /* debug: GCOV_NOT_REACHED */
}
if (spec->prec >= 0) {
if (spec->prec > MPD_MAX_PREC) {
*status |= MPD_Invalid_operation;
goto error;
}
switch (type) {
case 'g':
prec = (spec->prec == 0) ? 1 : spec->prec;
if (dec->digits > prec) {
_mpd_round(&tmp, dec, prec, ctx,
&workstatus);
dec = &tmp;
}
break;
case 'e':
if (mpd_iszero(dec)) {
dplace = 1-spec->prec;
}
else {
_mpd_round(&tmp, dec, spec->prec+1, ctx,
&workstatus);
dec = &tmp;
}
break;
case 'f':
mpd_qrescale(&tmp, dec, -spec->prec, ctx,
&workstatus);
dec = &tmp;
break;
}
}
if (type == 'f') {
if (mpd_iszero(dec) && dec->exp > 0) {
mpd_qrescale(&tmp, dec, 0, ctx, &workstatus);
dec = &tmp;
}
}
if (workstatus&MPD_Errors) {
*status |= (workstatus&MPD_Errors);
goto error;
}
}
/*
* At this point, for all scaled or non-scaled decimals:
* 1) 1 <= digits <= MAX_PREC+1
* 2) adjexp(scaled) = adjexp(orig) [+1]
* 3) case 'g': MIN_ETINY <= exp <= MAX_EMAX+1
* case 'e': MIN_ETINY-MAX_PREC <= exp <= MAX_EMAX+1
* case 'f': MIN_ETINY <= exp <= MAX_EMAX+1
* 4) max memory alloc in _mpd_to_string:
* case 'g': MAX_PREC+36
* case 'e': MAX_PREC+36
* case 'f': 2*MPD_MAX_PREC+30
*/
result.nbytes = _mpd_to_string(&result.data, dec, flags, dplace);
result.nchars = result.nbytes;
if (result.nbytes < 0) {
*status |= MPD_Malloc_error;
goto error;
}
if (*spec->dot != '\0' && !mpd_isspecial(dec)) {
if (result.nchars > MPD_MAX_PREC+36) {
/* Since a group length of one is not explicitly
* disallowed, ensure that it is always possible to
* insert a four byte separator after each digit. */
*status |= MPD_Invalid_operation;
mpd_free(result.data);
goto error;
}
if (!_mpd_apply_lconv(&result, spec, status)) {
goto error;
}
}
if (spec->min_width) {
if (!_mpd_add_pad(&result, spec, status)) {
goto error;
}
}
mpd_del(&tmp);
return result.data;
error:
mpd_del(&tmp);
return NULL;
}
void *main_mpd_cli(void *data )
{
blockQueue char_queue; // kolejka polecen
thread_data *my_data;
my_data = (thread_data*)data;
////////////////////////////// LCD PART ///////////////////////
my_data->mainLCD->set_print_song_state(0);
///////////////////////////////////////////////////////////////////
int iport = 6600, button_counter =0;
char *hostname = getenv("MPD_HOST");
char *port = getenv("MPD_PORT");
char *password = getenv("MPD_PASSWORD");
MpdObj *obj = NULL;
std::cout << " adres hosta to " << hostname << std::endl;
if(!hostname) {
std::cout << " ip mpd to " << my_data->server_settings->MPD_IP << " ! \n";
hostname = (char*)my_data->server_settings->MPD_IP.c_str();
}
if(port){
iport = std::stoi(port);
}
/* Create mpd object */
obj = mpd_new(hostname, iport,password);
/* Connect signals */
mpd_signal_connect_error(obj,(ErrorCallback)error_callback, NULL);
mpd_signal_connect_status_changed(obj,(StatusChangedCallback)status_changed , my_data );
/* Set timeout */
mpd_set_connection_timeout(obj, 10);
int work;
work = mpd_connect(obj);
while (work){
log_file_mutex.mutex_lock();
log_file_cout << ERROR << "nie udalo sie polaczyc z MPD "<< std::endl;
log_file_mutex.mutex_unlock();
system("service mpd stop");
sleep(1);
system("service mpd start");
log_file_mutex.mutex_lock();
log_file_cout << INFO << "restart MPD "<< std::endl;
log_file_cout << INFO << "nawiazuje nowe polaczenie z MPD "<< std::endl;
log_file_mutex.mutex_unlock();
my_data->myEventHandler.run("mpd")->addEvent("restart MPD");
work = mpd_connect(obj);
}
std::cout << " stop "<<std::endl;
if(!work)
{
char buffer;
do{
if(char_queue._size() > 0)
{
//digitalWrite(LED7,1);
buffer = char_queue._get();
switch(buffer)
{
case '\n':
break;
case 'D':
mpd_player_next(obj);
break;
case 'U':
mpd_player_prev(obj);
break;
case 't':
mpd_player_play(obj);
break;
case 'A':
mpd_player_pause(obj);
break;
case 'P':
mpd_player_pause(obj);
mpd_player_stop(obj);
break;
case 'q':
printf("Quitting....\n");
break;
case 'R':
mpd_player_set_repeat(obj, !mpd_player_get_repeat(obj));
break;
case 's':
mpd_player_set_random(obj, !mpd_player_get_random(obj));
break;
case 'p':
/*if(char_queue._size() > 0)
{
buffer = char_queue._get();
int id = atoi(buffer);
printf(GREEN"Playing:"RESET" %i\n", id);
mpd_player_play_id(obj,id);
}
break;*/
case '+':
mpd_status_set_volume(obj, mpd_status_get_volume(obj)+1);
break;
case '-':
mpd_status_set_volume(obj, mpd_status_get_volume(obj)-1);
break;
case '%':
mpd_status_set_volume(obj, my_data->ptr_MPD_info->volume);
break;
case '2':
debug_level = (debug_level > 0)?0:3;
printf( "Debug:"" %s\n", (debug_level >0)? "Enabled":"Disabled");
break;
case 'I':
mpd_player_play_id(obj,my_data->currentSongID);
break;
case 'h':
printf("\th:\t\tHelp\n"\
"\td:\t\tToggle debug on/off\n"\
"\t+:\t\tIncrease volume\n"\
"\t-:\t\tDecrease volume\n"\
"\ta <pass>:\t Authentificate with pass\n"\
"\tp <id>:\t Play song with id\n"\
"\tl:\t\tList the playlist\n"\
"\ts:\t\tToggle shuffle mode\n"\
"\tr:\t\tToggle repeat\n"\
"\tq:\t\tQuit\n"\
"\tv:\t\tStop\n"\
"\tc:\t\tPause\n"\
"\tx:\t\tPlay\n"\
"\tz:\t\tPrevious\n"\
"\tb:\t\tNext\n");
break;
default:
printf("buffer: %c\n", buffer);
}
}
if (!mpd_check_connected(obj))
{
log_file_mutex.mutex_lock();
log_file_cout << WARNING << "utracono polacznie z MPD "<< std::endl;
log_file_cout << INFO << "restart MPD" << std::endl;
log_file_mutex.mutex_unlock();
system ("service mpd restart");
mpd_connect(obj);
}
mpd_status_update(obj);
my_data->mainLCD->checkState();
if ( digitalRead(BUTTON_PIN) == HIGH )
{
std::cout << " wcisnieta pin !" << std::endl;
if (check_title_song_to == true && button_counter ==4)
{
char_queue._add('P');
std::cout << " \n\ngasze !" << std::endl;
}
else if (check_title_song_to == false && button_counter ==4)
{
char_queue._add('t');
std::cout << " \n\n\n zapalam !" << std::endl;
}
else if (check_title_song_to == false && button_counter ==10)
{
std::cout << " \n\n\n koniec programu z przyciska !" << std::endl;
go_while = false;
}
std::cout << " \n\n\n licznik guzika wskazuje "<< button_counter << std::endl;
++button_counter;
}
else
{
button_counter =0;
}
} while(!usleep(500000) && go_while);
mpd_player_stop(obj);
sleep (3);
}
else{
std::cout << " NIE UDALO SIE POłączyć "<<std::endl;
}
mpd_free(obj);
log_file_mutex.mutex_lock();
log_file_cout << INFO << " koniec watku klient MPD "<< std::endl;
log_file_mutex.mutex_unlock();
return 0;
}
int main(int argc, char **argv)
{
int fdstdin = 0;
pthread_t Lkeys;
pthread_t g15display;
pthread_t EKeys;
int volume;
int volume_new;
char devname[256] = "Unknown";
int iport = 6600;
char *hostname = getenv("MPD_HOST");
char *port = getenv("MPD_PORT");
char *password = getenv("MPD_PASSWORD");
int eventdev;
char evdev_name[128];
pthread_mutex_init(&lockit,NULL);
pthread_mutex_init(&daemon_mutex,NULL);
int i;
for (i=0;i<argc;i++) {
char argument[20];
memset(argument,0,20);
strncpy(argument,argv[i],19);
if (!strncmp(argument, "-q",2) || !strncmp(argument, "--quickscroll",13)) {
quickscroll=1;
}
if (!strncmp(argument, "-h",2) || !strncmp(argument, "--help",6)) {
printf(" %s version %s\n (c)2006-2007 Mike Lampard\n\n",argv[0],VERSION);
printf("%s -q or --quickscroll Use volume control to scroll through the playlist\n",argv[0]);
printf("%s -v or --version Show program version\n",argv[0]);
printf("%s -h or --help This help text\n\n",argv[0]);
exit(0);
}
if (!strncmp(argument, "-v",2) || !strncmp(argument, "--version",9)) {
printf("%s version %s\n",argv[0],VERSION);
exit(0);
}
}
for(eventdev=0;eventdev<127;eventdev++) {
snprintf(evdev_name,127,"/dev/input/event%i",eventdev);
if ((mmedia_fd = open(evdev_name, O_NONBLOCK|O_RDONLY)) < 0) {
// ignore errors when opening devices
//printf("error opening interface %i\n",eventdev);
} else {
ioctl(mmedia_fd, EVIOCGNAME(sizeof(devname)), devname);
printf("Device Name %s on %s\n", devname, evdev_name);
if(0==strncmp(devname,"Logitech Logitech Gaming Keyboard",256)){
printf("Found device: \"%s\" on %s ", devname,evdev_name);
break;
} else if(0==strncmp(devname,"G15 Gaming Keyboard",256)){
printf("Found device: \"%s\" on %s ", devname,evdev_name);
break;
}else
close(mmedia_fd);
}
}
if (mmedia_fd) { // we assume that the next event device is the multimedia keys
close(mmedia_fd);
snprintf(evdev_name,127,"/dev/input/event%i",++eventdev);
printf("and %s\n",evdev_name);
if ((mmedia_fd = open(evdev_name, O_NONBLOCK|O_RDONLY)) < 0) {
printf("error opening interface %i",eventdev);
}
}else {
printf("Unable to find Keyboard via EVENT interface... is /dev/input/event[0-9] readable??\n");
}
/* set correct hostname */
if(!hostname) {
hostname = "localhost";
}
if(port){
iport = atoi(port);
}
if((g15screen_fd = new_g15_screen(G15_G15RBUF))<0){
printf("Sorry, cant connect to the G15daemon\n");
return 1;
}
canvas = (g15canvas *) malloc (sizeof (g15canvas));
if (canvas != NULL) {
memset(canvas->buffer, 0, G15_BUFFER_LEN);
canvas->mode_cache = 0;
canvas->mode_reverse = 0;
canvas->mode_xor = 0;
}
/* Create mpd object */
obj = mpd_new(hostname, iport,password);
/* Connect signals */
mpd_signal_connect_error(obj,(ErrorCallback)error_callback, NULL);
mpd_signal_connect_status_changed(obj,(StatusChangedCallback)status_changed, NULL);
/* Set timeout */
mpd_set_connection_timeout(obj, 10);
if(0==mpd_connect(obj))
{
char buffer[20];
pthread_attr_t attr;
mpd_send_password(obj);
memset(buffer, '\0', 20);
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr,32*1024); /* set stack to 64k - dont need 8Mb !! */
pthread_create(&Lkeys, &attr, Lkeys_thread, NULL);
pthread_create(&EKeys, &attr,event_key_thread, NULL);
pthread_create(&g15display, &attr, g15display_thread, NULL);
do{
pthread_mutex_lock(&daemon_mutex);
if(voltimeout)
--voltimeout;
if(mute){
volume_adjust = 0;
mute = 0;
if (muted_volume == 0) {
//printf("mute\n");
muted_volume = mpd_status_get_volume(obj);
mpd_status_set_volume (obj,0);
} else {
//printf("unmute\n");
if (mpd_status_get_volume(obj) == 0) { /* if no other client has set volume up */
mpd_status_set_volume (obj,muted_volume);
}
muted_volume = 0;
}
}
if(volume_adjust != 0){
if (muted_volume != 0) {
volume=muted_volume;
} else {
volume=mpd_status_get_volume(obj);
}
volume_new = volume + volume_adjust;
volume_adjust = 0;
if(volume_new < 0)
volume_new = 0;
if(volume_new > 100)
volume_new = 100;
if(volume != volume_new || muted_volume){
//printf("volume %d -> %d\n", volume, volume_new);
mpd_status_set_volume (obj,volume_new);
}
voltimeout=100;
muted_volume=0;
}
mpd_status_update(obj);
pthread_mutex_unlock(&daemon_mutex);
}while(!usleep(5000) && !leaving);
leaving = 1;
pthread_join(Lkeys,NULL);
pthread_join(g15display,NULL);
}else
printf("Unable to connect to MPD server. Exiting\n");
if(obj)
mpd_free(obj);
close(fdstdin);
if(canvas!=NULL)
free(canvas);
close(g15screen_fd);
close(mmedia_fd);
pthread_mutex_destroy(&lockit);
return 1;
}
int main ( int argc, char* argv[] )
{
// We have to be told where MPD is running.
char* host = "guanaco"; // Well, that's mine. Maybe this should be localhost.
int port = 6600; // The standard MPD port.
// Default database.
char* database = "album_art.sqlite3";
bool bad_argument = false;
int c;
// Start the logger.
main_data.logger = log_init();
while ( 1 ) {
int option_index = 0;
static struct option long_options[] = {
{ "host", required_argument, 0, 'h' },
{ "port", required_argument, 0, 'p' },
{ "database", required_argument, 0, 'd' },
{ 0, 0, 0, 0 }
};
c = getopt_long( argc, argv, "h:p:d:", long_options, &option_index );
if ( c == -1 ) {
break;
}
switch ( c ) {
case 'h':
if ( *optarg == '\0' ) {
bad_argument = true;
printf( "--host argument must be non-empty\n" );
}
host = optarg;
break;
case 'p':
#if 0
port = optarg;
{
int port_n = convert_int( optarg );
if ( errno != 0 ) {
bad_argument = true;
printf( "--port argument was not a valid integer: '%s' (%s)\n",
optarg, strerror( errno ) );
}
if ( port_n <= 0 ) {
bad_argument = true;
printf( "--port argument must be positive (%s)\n", port );
}
}
#else
{
port = convert_int( optarg );
if ( errno != 0 ) {
bad_argument = true;
printf( "--port argument was not a valid integer: '%s' (%s)\n",
optarg, strerror( errno ) );
}
if ( port <= 0 ) {
bad_argument = true;
printf( "--port argument must be positive (%d)\n", port );
}
}
#endif
break;
case 'd':
if ( *optarg == '\0' ) {
bad_argument = true;
printf( "--database argument must be non-empty\n" );
}
database = optarg;
break;
default:
bad_argument = true;
printf( "?? getopt returned character code 0%o ??\n", c );
}
}
if ( bad_argument ) {
printf( USAGE, argv[0] );
return 1;
}
log_message_info( main_data.logger, "MPD host: '%s'", host );
log_message_info( main_data.logger, "MPD port: '%d'", port );
log_message_info( main_data.logger, "Database: '%s'", database );
main_data.mpd = mpd_create( host, port, main_data.logger );
if ( mpd_status( main_data.mpd ) < 0 ) {
printf( USAGE, argv[0] );
return 1;
}
// Try to open the image database connection.
main_data.image_db = image_db_create( database, main_data.logger );
// If we get this far, we can try to initialize the graphics.
main_data.display = display_init( main_data.image_db, main_data.mpd );
if ( display_status( main_data.display ) < 0 ) {
return 1;
}
// Well, after all that, we can now start polling MPD to see what's up.
main_data.loop = g_main_loop_new( NULL, FALSE );
// Poll MPD periodically.
(void)g_timeout_add_seconds( 1, poll_mpd, &main_data );
// Also try to poll the buttons on the Pibrella (if it is configured
// properly).
add_pibrella_button10( &main_data );
add_pibrella_button11( &main_data );
// Mouse or touch screen events.
add_event( &main_data );
g_main_loop_run( main_data.loop );
log_message_info( main_data.logger, "Done with main loop. Cleaning up." );
g_main_loop_unref( main_data.loop );
display_close( main_data.display );
mpd_free( main_data.mpd );
log_close( main_data.logger );
return 0;
}
/* reverse transform, sign = 1 */
int
std_inv_fnt(mpd_uint_t *a, mpd_size_t n, int modnum)
{
struct fnt_params *tparams;
assert(ispower2(n));
assert(n >= 4);
assert(n <= 3*MPD_MAXTRANSFORM_2N);
if ((tparams = _mpd_init_fnt_params(n, 1, modnum)) == NULL) {
return 0;
}
fnt_dif2(a, n, tparams);
mpd_free(tparams);
return 1;
}