static int
save_image(Image *p, UIData *uidata, char *path, char *format)
{
char *outpath;
char *ext;
FILE *fp;
EnflePlugins *eps = get_enfle_plugins();
if ((ext = saver_get_ext(eps, format, uidata->c)) == NULL)
return 0;
if ((outpath = misc_replace_ext(path, ext)) == NULL) {
show_message_fnc("No enough memory.\n");
return 0;
}
free(ext);
if ((fp = fopen(outpath, "wb")) == NULL) {
show_message_fnc("Cannot open %s for writing.\n", outpath);
return 0;
}
if (!saver_save(eps, format, p, fp, uidata->c, NULL)) {
show_message("Save failed.\n");
fclose(fp);
return 0;
}
fclose(fp);
free(outpath);
return 1;
}
static AudioDevice *
open_device(void *data, Config *c)
{
AudioDevice *ad;
char *device = data;
if ((ad = calloc(1, sizeof(AudioDevice))) == NULL)
return NULL;
ad->c = c;
if ((device == NULL) && ((device = config_get(c, "/enfle/plugins/audio/oss/device_path")) == NULL))
/* last resort */
device = (char *)"/dev/dsp";
if ((ad->fd = open(device, O_WRONLY | O_NONBLOCK, 0)) == -1) {
show_message_fnc("in opening device \"%s\"\n", device);
perror("OSS");
free(ad);
return NULL;
}
ioctl(ad->fd, SNDCTL_DSP_RESET);
ad->opened = 1;
return ad;
}
static AudioDevice *
open_device(void *data, Config *c)
{
AudioDevice *ad;
ALSA_data *alsa;
char *device = data;
int err;
if ((ad = calloc(1, sizeof(AudioDevice))) == NULL)
return NULL;
ad->c = c;
if ((alsa = calloc(1, sizeof(ALSA_data))) == NULL) {
free(ad);
return NULL;
}
ad->private_data = alsa;
if ((device == NULL) && ((device = config_get_str(c, "/enfle/plugins/audio/alsa/device")) == NULL))
device = (char *)"default";
err = snd_output_stdio_attach(&alsa->log, stderr, 0);
if ((err = snd_pcm_open(&alsa->fd, device, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)) < 0) {
show_message_fnc("error in opening device \"%s\"\n", device);
return NULL;
}
ad->bytes_written = 0;
ad->opened = 1;
debug_message_fnc("opened device %s successfully.\n", device);
return ad;
}
static int
set_params(AudioDevice *ad, AudioFormat *format_p, int *ch_p, unsigned int *rate_p)
{
int c, f, r;
AudioFormat format = *format_p;
int ch = *ch_p;
unsigned int rate = *rate_p;
/* format part */
switch (format) {
case _AUDIO_FORMAT_MU_LAW:
f = AFMT_MU_LAW;
break;
case _AUDIO_FORMAT_A_LAW:
f = AFMT_A_LAW;
break;
case _AUDIO_FORMAT_ADPCM:
f = AFMT_IMA_ADPCM;
break;
case _AUDIO_FORMAT_U8:
f = AFMT_U8;
break;
case _AUDIO_FORMAT_S8:
f = AFMT_S8;
break;
case _AUDIO_FORMAT_U16_LE:
f = AFMT_U16_LE;
break;
case _AUDIO_FORMAT_U16_BE:
f = AFMT_U16_BE;
break;
case _AUDIO_FORMAT_S16_LE:
f = AFMT_S16_LE;
break;
case _AUDIO_FORMAT_S16_BE:
f = AFMT_S16_BE;
break;
#if 0
case _AUDIO_FORMAT_S32_LE:
f = AFMT_S32_LE;
break;
case _AUDIO_FORMAT_S32_BE:
f = AFMT_S32_BE;
break;
#endif
default:
show_message_fnc("format %d is invalid.\n", format);
ad->format = _AUDIO_FORMAT_UNSET;
*format_p = _AUDIO_FORMAT_UNSET;
return 0;
}
if (ioctl(ad->fd, SNDCTL_DSP_SETFMT, &f) == -1) {
show_message_fnc("in setting format as %d(to ioctl %d).\n", format, f);
perror("OSS");
ad->format = _AUDIO_FORMAT_UNSET;
return 0;
}
ad->bytes_per_sample = 2;
switch (f) {
case AFMT_MU_LAW:
ad->format = _AUDIO_FORMAT_MU_LAW;
break;
case AFMT_A_LAW:
ad->format = _AUDIO_FORMAT_A_LAW;
break;
case AFMT_IMA_ADPCM:
ad->format = _AUDIO_FORMAT_ADPCM;
break;
case AFMT_U8:
ad->format = _AUDIO_FORMAT_U8;
ad->bytes_per_sample = 1;
break;
case AFMT_S8:
ad->format = _AUDIO_FORMAT_S8;
ad->bytes_per_sample = 1;
break;
case AFMT_U16_LE:
ad->format = _AUDIO_FORMAT_U16_LE;
ad->bytes_per_sample = 2;
break;
case AFMT_U16_BE:
ad->format = _AUDIO_FORMAT_U16_BE;
ad->bytes_per_sample = 2;
break;
case AFMT_S16_LE:
ad->format = _AUDIO_FORMAT_S16_LE;
ad->bytes_per_sample = 2;
break;
case AFMT_S16_BE:
ad->format = _AUDIO_FORMAT_S16_BE;
ad->bytes_per_sample = 2;
break;
#if 0
case AFMT_S32_LE:
ad->format = _AUDIO_FORMAT_S32_LE;
ad->bytes_per_sample = 4;
break;
case AFMT_S32_BE:
ad->format = _AUDIO_FORMAT_S32_BE;
ad->bytes_per_sample = 4;
break;
#endif
case AFMT_MPEG:
ad->format = _AUDIO_FORMAT_UNSET;
show_message_fnc("unsupported AFMT_MPEG\n");
break;
}
*format_p = ad->format;
/* channel part */
c = ch;
if (ioctl(ad->fd, SNDCTL_DSP_CHANNELS, &c) == -1) {
show_message_fnc("in setting channels to %d.\n", ch);
perror("OSS");
*ch_p = 0;
return 0;
}
debug_message_fnc("set to %d ch\n", c);
*ch_p = c;
/* rate part */
r = rate;
if (ioctl(ad->fd, SNDCTL_DSP_SPEED, &r) == -1) {
show_message_fnc("in setting speed to %d.\n", rate);
perror("OSS");
*rate_p = 0;
return 0;
}
debug_message_fnc("set to %d Hz\n", r);
*rate_p = r;
ad->channels = ch;
ad->speed = rate;
return 1;
}
static int
load_image(Image *p, Stream *st)
{
unsigned char buf[BUFSIZE], *pp, *d;
unsigned int file_size, header_size, image_size, offset_to_image;
unsigned short int biPlanes;
unsigned int bytes_per_pal;
int i, c, c2, y, compress_method;
if (stream_read(st, buf, 12) != 12)
return 0;
file_size = utils_get_little_uint32(&buf[0]);
offset_to_image = utils_get_little_uint32(&buf[8]);
if (file_size < offset_to_image)
return 0;
if (!stream_read_little_uint32(st, &header_size))
return 0;
if (header_size > 64)
return 0;
if (stream_read(st, buf, header_size - 4) != (int)(header_size - 4))
return 0;
if (header_size >= WIN_BMP_HEADER_SIZE) {
image_width(p) = utils_get_little_uint32(&buf[0]);
image_height(p) = utils_get_little_uint32(&buf[4]);
biPlanes = utils_get_little_uint16(&buf[8]);
p->bits_per_pixel = utils_get_little_uint16(&buf[10]);
} else {
image_width(p) = utils_get_little_uint16(&buf[0]);
image_height(p) = utils_get_little_uint16(&buf[2]);
biPlanes = utils_get_little_uint16(&buf[4]);
p->bits_per_pixel = utils_get_little_uint16(&buf[6]);
}
if (biPlanes != 1)
return 0;
if (image_width(p) > 10000 || image_height(p) > 10000)
return 0;
switch (p->bits_per_pixel) {
case 1:
p->type = _BITMAP_MSBFirst; /* XXX: check order */
p->depth = p->bits_per_pixel;
break;
case 4:
p->type = _INDEX44;
p->depth = 4;
break;
case 8:
p->type = _INDEX;
p->depth = 8;
break;
case 16:
p->type = _RGB555;
p->depth = 16;
break;
case 24:
p->type = _BGR24;
p->depth = 24;
break;
case 32:
p->type = _BGRA32;
p->depth = 24;
break;
default:
show_message("bmp: read_header: unknown bpp %d detected.\n", p->bits_per_pixel);
return 0;
}
compress_method = 0;
if (header_size >= WIN_BMP_HEADER_SIZE) {
compress_method = utils_get_little_uint16(&buf[12]);
image_size = utils_get_little_uint32(&buf[16]);
image_size = image_size; // dummy
}
/* other header informations are intentionally ignored */
if (p->depth <= 8) {
p->ncolors = 1 << p->depth;
bytes_per_pal = (header_size >= WIN_BMP_HEADER_SIZE) ? 4 : 3;
if (p->ncolors * bytes_per_pal > BUFSIZE) {
err_message_fnc("BUFSIZE is too small. It must be greater than %d.\n", p->ncolors * bytes_per_pal);
return 0;
}
if (stream_read(st, buf, p->ncolors * bytes_per_pal) != (int)(p->ncolors * bytes_per_pal))
return 0;
for (i = 0; i < (int)p->ncolors; i++) {
p->colormap[i][0] = buf[bytes_per_pal * i + 2];
p->colormap[i][1] = buf[bytes_per_pal * i + 1];
p->colormap[i][2] = buf[bytes_per_pal * i + 0];
}
} else if (p->depth == 16 && compress_method == 3) {
/* Read bitmasks */
if (stream_read(st, buf, 3 * 4) != 3 * 4)
return 0;
unsigned int rm = utils_get_little_uint32(buf);
unsigned int gm = utils_get_little_uint32(buf + 4);
unsigned int bm = utils_get_little_uint32(buf + 8);
if (rm == 0xf800)
p->type = _RGB565;
else if (rm == 0x7c00)
p->type = _RGB555;
else
warning_fnc("Mask: R %X G %X B %X is not supported\n", rm, gm, bm);
compress_method = 0;
}
image_bpl(p) = (image_width(p) * p->bits_per_pixel) >> 3;
image_bpl(p) += (4 - (image_bpl(p) % 4)) % 4;
debug_message_fnc("(%d, %d): bpp %d depth %d compress %d\n", image_width(p), image_height(p), p->bits_per_pixel, p->depth, compress_method);
if ((d = memory_alloc(image_image(p), image_bpl(p) * image_height(p))) == NULL)
return 0;
stream_seek(st, offset_to_image, _SET);
pp = d + image_bpl(p) * (image_height(p) - 1);
switch (compress_method) {
case BI_RGB:
for (i = (int)(image_height(p) - 1); i >= 0; i--) {
stream_read(st, pp, image_bpl(p));
pp -= image_bpl(p);
}
break;
case BI_RLE4:
if (p->depth != 4)
show_message("Compressed RI_BLE4 bitmap with depth %d != 4.\n", p->depth);
/* RLE compressed data */
/* Not complete. */
y = image_height(p);
while ((c = stream_getc(st)) != -1 && y >= 0) {
if (c != 0) {
/* code mode */
c2 = stream_getc(st);
show_message_fnc("len %d data %d\n", c, c2);
for (i = 0; i < c; i += 2) {
*pp++ = (unsigned char)c2;
}
} else {
if ((c = stream_getc(st)) == 0) {
/* line end */
show_message_fnc("line end %d\n", y);
pp = d + image_bpl(p) * (y - 1);
y--;
} else if (c == 1) {
/* image end */
break;
} else if (c == 2) {
/* offset */
c = stream_getc(st);
c2 = stream_getc(st);
show_message_fnc("offset %d, %d\n", c, c2);
pp += (c - c2 * image_width(p)) / 2;
} else {
/* absolute mode */
show_message_fnc("abs len %d\n", c);
for (i = 0; i < c; i += 2)
*pp++ = (unsigned char)stream_getc(st);
if (c % 2 != 0)
/* read dummy */
c = stream_getc(st);
}
}
}
break;
case BI_RLE8:
if (p->depth != 8)
show_message("Compressed RI_BLE8 bitmap with depth %d != 8.\n", p->depth);
/* RLE compressed data */
y = image_height(p);
while ((c = stream_getc(st)) != -1 && y >= 0) {
if (c != 0) {
/* code mode */
c2 = stream_getc(st);
for (i = 0; i < c; i++) {
*pp++ = (unsigned char)c2;
}
} else {
if ((c = stream_getc(st)) == 0) {
/* line end */
pp = d + image_bpl(p) * (y - 1);
y--;
} else if (c == 1) {
/* image end */
break;
} else if (c == 2) {
/* offset */
c = stream_getc(st);
c2 = stream_getc(st);
pp += (c - c2 * image_width(p));
} else {
/* absolute mode */
for (i = 0; i < c; i++)
*pp++ = (unsigned char)stream_getc(st);
if (c % 2 != 0)
/* read dummy */
c = stream_getc(st);
}
}
}
break;
default:
show_message("Compressed bitmap (method = %d) not supported.\n", compress_method);
return 0;
}
return 1;
}
static int
set_params(AudioDevice *ad, AudioFormat *format_p, int *ch_p, unsigned int *rate_p)
{
ALSA_data *alsa = (ALSA_data *)ad->private_data;
int r, err;
snd_pcm_format_t f;
AudioFormat format = *format_p;
snd_pcm_hw_params_t *hwparams;
snd_pcm_sw_params_t *swparams;
int ch = *ch_p;
unsigned int rate = *rate_p;
unsigned int buffer, period;
snd_pcm_hw_params_alloca(&hwparams);
snd_pcm_sw_params_alloca(&swparams);
ad->format = _AUDIO_FORMAT_UNSET;
*format_p = _AUDIO_FORMAT_UNSET;
*ch_p = 0;
*rate_p = 0;
/* format part */
switch (format) {
case _AUDIO_FORMAT_MU_LAW:
f = SND_PCM_FORMAT_MU_LAW;
break;
case _AUDIO_FORMAT_A_LAW:
f = SND_PCM_FORMAT_A_LAW;
break;
case _AUDIO_FORMAT_ADPCM:
f = SND_PCM_FORMAT_IMA_ADPCM;
break;
case _AUDIO_FORMAT_U8:
f = SND_PCM_FORMAT_U8;
break;
case _AUDIO_FORMAT_S8:
f = SND_PCM_FORMAT_S8;
break;
case _AUDIO_FORMAT_U16_LE:
f = SND_PCM_FORMAT_U16_LE;
break;
case _AUDIO_FORMAT_U16_BE:
f = SND_PCM_FORMAT_U16_BE;
break;
case _AUDIO_FORMAT_S16_LE:
f = SND_PCM_FORMAT_S16_LE;
break;
case _AUDIO_FORMAT_S16_BE:
f = SND_PCM_FORMAT_S16_BE;
break;
#if 0
case _AUDIO_FORMAT_S32_LE:
f = SND_PCM_FORMAT_U32_LE;
break;
case _AUDIO_FORMAT_S32_BE:
f = SND_PCM_FORMAT_S32_BE;
break;
#endif
default:
show_message_fnc("format %d is invalid.\n", format);
return 0;
}
if ((err = snd_pcm_hw_params_any(alsa->fd, hwparams)) < 0) {
show_message_fnc("snd_pcm_hw_params_any() failed.\n");
return 0;
}
if ((err = snd_pcm_hw_params_set_access(alsa->fd, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
show_message_fnc("snd_pcm_hw_params_set_access() failed.\n");
return 0;
}
if ((err = snd_pcm_hw_params_set_format(alsa->fd, hwparams, f)) < 0) {
show_message_fnc("snd_pcm_hw_params_set_format() failed.\n");
return 0;
}
ad->format = format;
*format_p = format;
/* channel part */
if ((err = snd_pcm_hw_params_set_channels(alsa->fd, hwparams, ch)) < 0) {
show_message_fnc("snd_pcm_hw_params_set_channels() failed.\n");
return 0;
}
*ch_p = ch;
/* rate part */
if ((err = snd_pcm_hw_params_set_rate_near(alsa->fd, hwparams, &rate, 0)) < 0) {
show_message_fnc("snd_pcm_hw_params_set_rate_near() failed.\n");
return 0;
}
*rate_p = rate;
/* buffer & period */
buffer = 500000;
period = 500000 / 4;
if ((err = snd_pcm_hw_params_set_buffer_time_near(alsa->fd, hwparams, &buffer, 0)) < 0) {
show_message_fnc("snd_pcm_hw_params_set_buffer_near() failed.\n");
return 0;
}
r = snd_pcm_hw_params_get_buffer_size(hwparams, &alsa->buffer_size);
if ((err = snd_pcm_hw_params_set_period_time_near(alsa->fd, hwparams, &period, 0)) < 0) {
show_message_fnc("snd_pcm_hw_params_set_period_near() failed.\n");
return 0;
}
r = snd_pcm_hw_params_get_period_size(hwparams, &alsa->period_size, 0);
if ((err = snd_pcm_hw_params(alsa->fd, hwparams)) < 0) {
perror("snd_pcm_hw_params");
err_message_fnc("snd_pcm_hw_params() failed.\n");
snd_pcm_hw_params_dump(hwparams, alsa->log);
return 0;
}
r = snd_pcm_hw_params_get_channels(hwparams, &ad->channels);
r = snd_pcm_hw_params_get_rate(hwparams, &ad->speed, 0);
r = r; // dummy
#ifdef DEBUG
{
snd_pcm_format_t form;
debug_message_fnc("format ");
r = snd_pcm_hw_params_get_format(hwparams, &form);
switch (form) {
case SND_PCM_FORMAT_MU_LAW: debug_message("MU_LAW "); break;
case SND_PCM_FORMAT_A_LAW: debug_message("A_LAW "); break;
case SND_PCM_FORMAT_IMA_ADPCM: debug_message("ADPCM "); break;
case SND_PCM_FORMAT_U8: debug_message("U8 "); break;
case SND_PCM_FORMAT_S8: debug_message("S8 "); break;
case SND_PCM_FORMAT_U16_LE: debug_message("U16LE "); break;
case SND_PCM_FORMAT_U16_BE: debug_message("U16BE "); break;
case SND_PCM_FORMAT_S16_LE: debug_message("S16LE "); break;
case SND_PCM_FORMAT_S16_BE: debug_message("S16BE "); break;
#if 0
case SND_PCM_FORMAT_U32_LE: debug_message("U32LE "); break;
case SND_PCM_FORMAT_S32_BE: debug_message("S32BE "); break;
#endif
default: debug_message("UNKNOWN "); break;
}
debug_message("%d ch %d Hz buffer %ld period %ld OK\n", ad->channels, ad->speed, alsa->buffer_size, alsa->period_size);
}
#endif
/* sw_params */
if ((err = snd_pcm_sw_params_current(alsa->fd, swparams)) < 0) {
show_message_fnc("snd_pcm_sw_params_any() failed.\n");
return 0;
}
if ((err = snd_pcm_sw_params(alsa->fd, swparams)) < 0) {
show_message_fnc("snd_pcm_sw_params() failed.\n");
return 0;
}
debug_message_fnc("1 sample -> %ld bytes\n", snd_pcm_samples_to_bytes(alsa->fd, 1));
return 1;
}
