forked from enlightenment/efl
edje-multisense: Get rid of the old files
Signed-off-by: Daniel Willmann <d.willmann@samsung.com> SVN revision: 83382
This commit is contained in:
Daniel Willmann
Daniel Willmann
parent
ed92993aab
commit
d2f926a449
|
|
@ -1,405 +0,0 @@
|
|||
/*
|
||||
* Remix ALSA Player: ALSA audio output
|
||||
*
|
||||
* Govindaraju SM <govi.sm@samsung.com>, October 2011
|
||||
* Prince Kumar Dubey <prince.dubey@samsung.com>, October 2011
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
#include <stdio.h>
|
||||
#include <remix/remix.h>
|
||||
#include <alsa/asoundlib.h>
|
||||
#include <Eina.h>
|
||||
#ifdef HAVE_LIBSNDFILE
|
||||
#include <sndfile.h>
|
||||
#endif
|
||||
|
||||
#define ALSA_PLAYER_BUFFERLEN 2048
|
||||
|
||||
typedef struct _Alsa_Player_Data Alsa_Player_Data;
|
||||
typedef short PLAYER_PCM;
|
||||
|
||||
struct _Alsa_Player_Data
|
||||
{
|
||||
RemixPCM databuffer[ALSA_PLAYER_BUFFERLEN];
|
||||
snd_pcm_t *alsa_dev;
|
||||
unsigned int stereo;
|
||||
unsigned channels;
|
||||
unsigned int frequency;
|
||||
};
|
||||
|
||||
static int _log_dom = -1;
|
||||
static int init_count = 0;
|
||||
|
||||
#ifdef WRN
|
||||
# undef WRN
|
||||
#endif
|
||||
#define WRN(...) EINA_LOG_DOM_WARN(_log_dom, __VA_ARGS__)
|
||||
|
||||
//#define MIXDBG 1
|
||||
|
||||
/* Optimisation dependencies: none */
|
||||
static RemixBase *alsa_player_optimise(RemixEnv *env, RemixBase *base);
|
||||
|
||||
static snd_pcm_t *
|
||||
alsa_open(int channels, unsigned int samplerate, unsigned int *real_samplerate)
|
||||
{
|
||||
const char *device = "default";
|
||||
snd_pcm_t *alsa_dev = NULL;
|
||||
snd_pcm_hw_params_t *hw_params;
|
||||
snd_pcm_uframes_t alsa_buffer_frames;
|
||||
snd_pcm_uframes_t alsa_period_size;
|
||||
unsigned int samplerate_ret = 0;
|
||||
int err;
|
||||
|
||||
alsa_buffer_frames = ALSA_PLAYER_BUFFERLEN;
|
||||
alsa_period_size = ALSA_PLAYER_BUFFERLEN / 4;
|
||||
|
||||
if ((err = snd_pcm_open(&alsa_dev, device, SND_PCM_STREAM_PLAYBACK, 0)) < 0)
|
||||
{
|
||||
WRN("cannot open alsa playback stream (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
snd_pcm_hw_params_alloca(&hw_params);
|
||||
if ((err = snd_pcm_hw_params_any(alsa_dev, hw_params)) < 0)
|
||||
{
|
||||
WRN("cannot initialize snd hw params (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
if ((err = snd_pcm_hw_params_set_access(alsa_dev, hw_params,
|
||||
SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
|
||||
{
|
||||
WRN("cannot set interleaved access (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
if ((err = snd_pcm_hw_params_set_format(alsa_dev, hw_params,
|
||||
SND_PCM_FORMAT_FLOAT)) < 0)
|
||||
{
|
||||
WRN("cannot set float sample format (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
#ifdef MIXDBG // testing/debugging by making output samplerate be 48khz
|
||||
samplerate_ret = 48000;
|
||||
if ((err = snd_pcm_hw_params_set_rate_near(alsa_dev, hw_params,
|
||||
&samplerate_ret, 0)) < 0)
|
||||
{
|
||||
WRN("cannot set sample rate (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
#else
|
||||
if ((err = snd_pcm_hw_params_set_rate_near(alsa_dev, hw_params,
|
||||
&samplerate, 0)) < 0)
|
||||
{
|
||||
WRN("cannot set sample rate (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
#endif
|
||||
if ((err = snd_pcm_hw_params_set_channels(alsa_dev, hw_params, channels)) < 0)
|
||||
{
|
||||
WRN("cannot set channel count (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
if ((err = snd_pcm_hw_params_set_buffer_size_near(alsa_dev, hw_params,
|
||||
&alsa_buffer_frames)) < 0)
|
||||
{
|
||||
WRN("cannot set buffer size (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
if ((err = snd_pcm_hw_params_set_period_size_near(alsa_dev, hw_params,
|
||||
&alsa_period_size, 0)) < 0)
|
||||
{
|
||||
WRN("cannot set period size (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
if ((err = snd_pcm_hw_params(alsa_dev, hw_params)) < 0)
|
||||
{
|
||||
WRN("cannot set parameters (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
if ((err = snd_pcm_hw_params_get_rate(hw_params, &samplerate_ret, 0)) < 0)
|
||||
{
|
||||
WRN("cannot get samplerate (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
if ((err = snd_pcm_prepare(alsa_dev)) < 0)
|
||||
{
|
||||
WRN("cannot prepare audio for use (%s)", snd_strerror(err));
|
||||
goto catch_error;
|
||||
}
|
||||
if (real_samplerate) *real_samplerate = samplerate_ret;
|
||||
|
||||
catch_error:
|
||||
if ((err < 0) && (alsa_dev != NULL))
|
||||
{
|
||||
snd_pcm_close(alsa_dev);
|
||||
return NULL;
|
||||
}
|
||||
return alsa_dev;
|
||||
}
|
||||
|
||||
static RemixBase *
|
||||
alsa_player_reset_device(RemixEnv *env, RemixBase *base)
|
||||
{
|
||||
Alsa_Player_Data *player_data = remix_base_get_instance_data(env, base);
|
||||
unsigned int real_samplerate = 0;
|
||||
|
||||
if (player_data->alsa_dev)
|
||||
{
|
||||
snd_pcm_drain(player_data->alsa_dev);
|
||||
snd_pcm_close(player_data->alsa_dev);
|
||||
}
|
||||
player_data->alsa_dev = alsa_open(player_data->channels,
|
||||
player_data->frequency,
|
||||
&real_samplerate);
|
||||
if (!player_data->alsa_dev)
|
||||
{
|
||||
remix_set_error(env, REMIX_ERROR_SYSTEM);
|
||||
return RemixNone;
|
||||
}
|
||||
// printf("%i != %i\n", real_samplerate, player_data->frequency);
|
||||
if (real_samplerate != player_data->frequency)
|
||||
{
|
||||
player_data->frequency = real_samplerate;
|
||||
remix_set_samplerate(env, player_data->frequency);
|
||||
}
|
||||
return base;
|
||||
}
|
||||
|
||||
static RemixBase *
|
||||
alsa_player_init(RemixEnv *env, RemixBase *base, CDSet *parameters __UNUSED__)
|
||||
{
|
||||
CDSet *channels;
|
||||
Alsa_Player_Data *player_data = calloc(1, sizeof(Alsa_Player_Data));
|
||||
|
||||
if (!player_data)
|
||||
{
|
||||
remix_set_error(env, REMIX_ERROR_SYSTEM);
|
||||
return RemixNone;
|
||||
}
|
||||
|
||||
init_count++;
|
||||
if (init_count == 1)
|
||||
{
|
||||
eina_init();
|
||||
_log_dom = eina_log_domain_register("remix-alsa", EINA_COLOR_CYAN);
|
||||
}
|
||||
|
||||
remix_base_set_instance_data(env, base, player_data);
|
||||
channels = remix_get_channels(env);
|
||||
|
||||
player_data->channels = cd_set_size(env, channels);
|
||||
if (player_data->channels == 1) player_data->stereo = 0;
|
||||
else if (player_data->channels == 2) player_data->stereo = 1;
|
||||
|
||||
player_data->frequency = remix_get_samplerate(env);
|
||||
alsa_player_reset_device(env, base);
|
||||
base = alsa_player_optimise(env, base);
|
||||
return base;
|
||||
}
|
||||
|
||||
static RemixBase *
|
||||
alsa_player_clone(RemixEnv *env, RemixBase *base __UNUSED__)
|
||||
{
|
||||
RemixBase *new_player = remix_base_new(env);
|
||||
alsa_player_init(env, new_player, NULL);
|
||||
return new_player;
|
||||
}
|
||||
|
||||
static int
|
||||
alsa_player_destroy(RemixEnv *env, RemixBase *base)
|
||||
{
|
||||
Alsa_Player_Data *player_data = remix_base_get_instance_data(env, base);
|
||||
|
||||
if (player_data->alsa_dev)
|
||||
{
|
||||
snd_pcm_drain(player_data->alsa_dev);
|
||||
snd_pcm_close(player_data->alsa_dev);
|
||||
}
|
||||
free(player_data);
|
||||
init_count--;
|
||||
if (init_count == 0)
|
||||
{
|
||||
eina_log_domain_unregister(_log_dom);
|
||||
_log_dom = -1;
|
||||
eina_shutdown();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
alsa_player_ready(RemixEnv *env, RemixBase *base)
|
||||
{
|
||||
Alsa_Player_Data *player_data = remix_base_get_instance_data(env, base);
|
||||
RemixCount nr_channels;
|
||||
CDSet *channels;
|
||||
int samplerate;
|
||||
|
||||
channels = remix_get_channels(env);
|
||||
samplerate = (int)remix_get_samplerate(env);
|
||||
nr_channels = cd_set_size(env, channels);
|
||||
return ((samplerate == (int)player_data->frequency) &&
|
||||
(((nr_channels == 1) && (player_data->stereo == 0)) ||
|
||||
((nr_channels > 1) && (player_data->stereo == 1))));
|
||||
}
|
||||
|
||||
static RemixBase *
|
||||
alsa_player_prepare(RemixEnv *env, RemixBase *base)
|
||||
{
|
||||
alsa_player_reset_device(env, base);
|
||||
return base;
|
||||
}
|
||||
|
||||
static RemixCount
|
||||
alsa_player_playbuffer(RemixEnv *env __UNUSED__, Alsa_Player_Data *player, RemixPCM *data, RemixCount count)
|
||||
{
|
||||
#ifdef MIXDBG
|
||||
{
|
||||
static int total = 0;
|
||||
static SNDFILE *sfile = NULL;
|
||||
static SF_INFO sfinfo;
|
||||
|
||||
if (total == 0)
|
||||
{
|
||||
sfinfo.frames = 0;
|
||||
sfinfo.samplerate = player->frequency;
|
||||
sfinfo.channels = 2;
|
||||
sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16 | SF_ENDIAN_LITTLE;
|
||||
sfinfo.sections = 0;
|
||||
sfinfo.seekable = 0;
|
||||
sfile = sf_open("out.wav", SFM_WRITE, &sfinfo);
|
||||
}
|
||||
|
||||
if (sfile)
|
||||
{
|
||||
sf_writef_float(sfile, data, count);
|
||||
total += count;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
return snd_pcm_writei(player->alsa_dev, data, count);
|
||||
}
|
||||
|
||||
static RemixCount
|
||||
alsa_player_chunk(RemixEnv *env, RemixChunk *chunk, RemixCount offset, RemixCount count, int channelname __UNUSED__, void *data)
|
||||
{
|
||||
Alsa_Player_Data *player = data;
|
||||
RemixCount remaining = count, written = 0, n, playcount;
|
||||
RemixPCM *d;
|
||||
|
||||
while (remaining > 0)
|
||||
{
|
||||
playcount = MIN(remaining, ALSA_PLAYER_BUFFERLEN);
|
||||
|
||||
d = &chunk->data[offset];
|
||||
n = alsa_player_playbuffer(env, player, d, playcount);
|
||||
|
||||
if (n == -1) return -1;
|
||||
else n /= sizeof(PLAYER_PCM);
|
||||
|
||||
offset += n;
|
||||
written += n;
|
||||
remaining -= n;
|
||||
}
|
||||
return written;
|
||||
}
|
||||
|
||||
static RemixCount
|
||||
alsa_player_process(RemixEnv *env, RemixBase *base, RemixCount count, RemixStream *input, RemixStream *output __UNUSED__)
|
||||
{
|
||||
Alsa_Player_Data *player_data = remix_base_get_instance_data(env, base);
|
||||
RemixCount nr_channels = remix_stream_nr_channels(env, input);
|
||||
RemixCount remaining = count, processed = 0, n, nn;
|
||||
|
||||
if ((nr_channels == 1) && (player_data->stereo == 0))
|
||||
{ /*MONO*/
|
||||
return remix_stream_chunkfuncify(env, input, count,
|
||||
alsa_player_chunk, player_data);
|
||||
}
|
||||
else if ((nr_channels == 2) && (player_data->stereo == 1))
|
||||
{ /*STEREO*/
|
||||
while (remaining > 0)
|
||||
{
|
||||
n = MIN(remaining, ALSA_PLAYER_BUFFERLEN / 2);
|
||||
n = remix_stream_interleave_2(env, input,
|
||||
REMIX_CHANNEL_LEFT,
|
||||
REMIX_CHANNEL_RIGHT,
|
||||
player_data->databuffer, n);
|
||||
nn = alsa_player_playbuffer(env, player_data,
|
||||
player_data->databuffer, n);
|
||||
processed += n;
|
||||
remaining -= n;
|
||||
}
|
||||
return processed;
|
||||
}
|
||||
WRN("[alsa_player_process] unsupported stream/output channel "
|
||||
"combination %ld / %d", nr_channels, player_data->stereo ? 2 : 1);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static RemixCount
|
||||
alsa_player_length(RemixEnv *env __UNUSED__, RemixBase *base __UNUSED__)
|
||||
{
|
||||
return REMIX_COUNT_INFINITE;
|
||||
}
|
||||
|
||||
static RemixCount
|
||||
alsa_player_seek(RemixEnv *env __UNUSED__, RemixBase *base __UNUSED__, RemixCount count __UNUSED__)
|
||||
{
|
||||
return count;
|
||||
}
|
||||
|
||||
static int
|
||||
alsa_player_flush(RemixEnv *env, RemixBase *base)
|
||||
{
|
||||
alsa_player_reset_device(env, base);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct _RemixMethods _alsa_player_methods =
|
||||
{
|
||||
alsa_player_clone,
|
||||
alsa_player_destroy,
|
||||
alsa_player_ready,
|
||||
alsa_player_prepare,
|
||||
alsa_player_process,
|
||||
alsa_player_length,
|
||||
alsa_player_seek,
|
||||
alsa_player_flush,
|
||||
};
|
||||
|
||||
static RemixBase *
|
||||
alsa_player_optimise(RemixEnv *env, RemixBase *base)
|
||||
{
|
||||
remix_base_set_methods(env, base, &_alsa_player_methods);
|
||||
return base;
|
||||
}
|
||||
|
||||
static struct _RemixMetaText alsa_player_metatext =
|
||||
{
|
||||
"alsa_snd_player",
|
||||
"ALSA sound player for Remix",
|
||||
"Output the audio stream into ALSA Driver",
|
||||
"Copyright (C) 2011, Samsung Electronics Co., Ltd.",
|
||||
"http://www.samsung.com",
|
||||
REMIX_ONE_AUTHOR("Govindaraju SM", "prince.dubey@samsung.com"),
|
||||
};
|
||||
|
||||
static struct _RemixPlugin alsa_player_plugin =
|
||||
{
|
||||
&alsa_player_metatext,
|
||||
REMIX_FLAGS_NONE,
|
||||
CD_EMPTY_SET, /* init scheme */
|
||||
alsa_player_init,
|
||||
CD_EMPTY_SET, /* process scheme */
|
||||
NULL, /* suggests */
|
||||
NULL, /* plugin data */
|
||||
NULL /* destroy */
|
||||
};
|
||||
|
||||
EAPI CDList *
|
||||
remix_load(RemixEnv *env)
|
||||
{
|
||||
CDList *plugins = cd_list_new(env);
|
||||
plugins = cd_list_prepend(env, plugins, CD_POINTER(&alsa_player_plugin));
|
||||
return plugins;
|
||||
}
|
||||
|
|
@ -1,498 +0,0 @@
|
|||
/*
|
||||
* RemixSnd_eetfile: a libsnd EET Virtual file handler
|
||||
*
|
||||
* Govindaraju SM <govi.sm@samsung.com>, August 2011
|
||||
* Prince Kumar Dubey <prince.dubey@samsung.com>, August 2011
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
#include <math.h>
|
||||
#include <sndfile.h>
|
||||
#include <remix/remix.h>
|
||||
#include <Eet.h>
|
||||
|
||||
#define PATH_KEY 1
|
||||
#define SOUND_ID_KEY 2
|
||||
#define SPEED_KEY 3
|
||||
#define BLOCK_FRAMES 8192
|
||||
|
||||
static RemixBase *remix_eet_sndfile_optimise(RemixEnv *env, RemixBase *sndfile);
|
||||
|
||||
typedef struct _VIO_DATA VIO_DATA;
|
||||
typedef struct _SndInstanceData SndInstanceData;
|
||||
|
||||
struct _VIO_DATA
|
||||
{
|
||||
sf_count_t offset, length;
|
||||
const char *data;
|
||||
};
|
||||
|
||||
struct _SndInstanceData
|
||||
{
|
||||
/* plugin parameters */
|
||||
char *path;
|
||||
char *sound_id;
|
||||
double speed;
|
||||
|
||||
/* Edj & Sndfile Reader */
|
||||
Eet_File *efp;
|
||||
SNDFILE *pcm_fp;
|
||||
SF_INFO *snd_info;
|
||||
VIO_DATA *vio_data;
|
||||
|
||||
/* PCM buffers */
|
||||
RemixPCM *readbuf;
|
||||
RemixPCM *inbuf;
|
||||
RemixPCM *outbuf;
|
||||
|
||||
/* Resample stuffs */
|
||||
RemixPCM prevreadbuf[2];
|
||||
int enable_resample;
|
||||
double rs_ratio;
|
||||
RemixCount resample_len;
|
||||
RemixCount in_avail;
|
||||
RemixCount out_generated;
|
||||
RemixCount required_resamples;
|
||||
};
|
||||
|
||||
static sf_count_t
|
||||
eet_snd_file_get_length(void *user_data)
|
||||
{
|
||||
VIO_DATA *vf = user_data;
|
||||
return vf->length;
|
||||
}
|
||||
|
||||
static sf_count_t
|
||||
eet_snd_file_seek(sf_count_t offset, int whence, void *user_data)
|
||||
{
|
||||
VIO_DATA *vf = user_data;
|
||||
|
||||
switch (whence)
|
||||
{
|
||||
case SEEK_SET:
|
||||
vf->offset = offset;
|
||||
break;
|
||||
case SEEK_CUR:
|
||||
vf->offset += offset;
|
||||
break;
|
||||
case SEEK_END:
|
||||
vf->offset = vf->length + offset;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return vf->offset;
|
||||
}
|
||||
|
||||
static sf_count_t
|
||||
eet_snd_file_read(void *ptr, sf_count_t count, void *user_data)
|
||||
{
|
||||
VIO_DATA *vf = user_data;
|
||||
|
||||
if ((vf->offset + count) > vf->length)
|
||||
count = vf->length - vf->offset;
|
||||
memcpy(ptr, vf->data + vf->offset, count);
|
||||
vf->offset += count;
|
||||
return count;
|
||||
}
|
||||
|
||||
static sf_count_t
|
||||
eet_snd_file_tell(void *user_data)
|
||||
{
|
||||
VIO_DATA *vf = user_data;
|
||||
return vf->offset;
|
||||
}
|
||||
|
||||
static int
|
||||
remix_init_resampler_data(RemixEnv *env, RemixBase *base)
|
||||
{
|
||||
SndInstanceData *si = remix_base_get_instance_data(env, base);
|
||||
|
||||
si->rs_ratio = remix_get_samplerate(env) / si->snd_info->samplerate;
|
||||
si->rs_ratio /= si->speed;
|
||||
si->resample_len = (si->snd_info->frames * si->rs_ratio);
|
||||
|
||||
si->outbuf = malloc(sizeof(RemixPCM) * BLOCK_FRAMES * 2);
|
||||
if (!si->outbuf) return 0;
|
||||
if ((si->rs_ratio == 1.0)/* && (si->snd_info->channels == 2)*/)
|
||||
{
|
||||
si->enable_resample = 0;
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
si->enable_resample = 1;
|
||||
|
||||
si->in_avail = 0;
|
||||
si->out_generated = 0;
|
||||
si->inbuf = malloc(sizeof(RemixPCM) * BLOCK_FRAMES *
|
||||
si->snd_info->channels);
|
||||
if (!si->inbuf) return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static RemixBase *
|
||||
remix_eet_sndfile_create(RemixEnv *env, RemixBase *sndfile, const char *path, const char *sound_id, const double speed)
|
||||
{
|
||||
SF_VIRTUAL_IO *eet_vio = NULL;
|
||||
SndInstanceData *si;
|
||||
const void *sound_data;
|
||||
int sound_size;
|
||||
|
||||
if ((!path) || (!sound_id)) return NULL;
|
||||
|
||||
si = calloc(1, sizeof(SndInstanceData));
|
||||
if (!si) goto err;
|
||||
remix_base_set_instance_data(env, sndfile, si);
|
||||
|
||||
si->path = strdup(path);
|
||||
si->sound_id = strdup(sound_id);
|
||||
si->speed = speed;
|
||||
|
||||
si->efp = eet_open(path, EET_FILE_MODE_READ);
|
||||
if (!si->efp) goto err;
|
||||
|
||||
// xxx: eet_read_direct does not work on Threads, using eet_read.
|
||||
sound_data = eet_read(si->efp, sound_id, &(sound_size));
|
||||
eet_close(si->efp);
|
||||
si->efp = NULL;
|
||||
if (sound_data == NULL) goto err;
|
||||
|
||||
eet_vio = calloc(1, sizeof(SF_VIRTUAL_IO));
|
||||
if (!eet_vio) goto err;
|
||||
|
||||
/* Set up func pointers to read snd file directly from EET. */
|
||||
eet_vio->get_filelen = eet_snd_file_get_length;
|
||||
eet_vio->seek = eet_snd_file_seek;
|
||||
eet_vio->read = eet_snd_file_read;
|
||||
eet_vio->tell = eet_snd_file_tell;
|
||||
|
||||
si->vio_data = calloc(1, sizeof(VIO_DATA));
|
||||
if (!si->vio_data) goto err;
|
||||
si->vio_data->offset = 0;
|
||||
si->vio_data->length = sound_size;
|
||||
si->vio_data->data = sound_data;
|
||||
|
||||
si->snd_info = calloc(1, sizeof(SF_INFO));
|
||||
if (!si->snd_info) goto err;
|
||||
|
||||
si->pcm_fp = sf_open_virtual(eet_vio, SFM_READ, si->snd_info, si->vio_data);
|
||||
if (!si->pcm_fp) goto err;
|
||||
free(eet_vio);
|
||||
eet_vio = NULL;
|
||||
|
||||
if (!remix_init_resampler_data(env, sndfile)) goto err;
|
||||
si->out_generated = 0;
|
||||
|
||||
return sndfile;
|
||||
|
||||
err:
|
||||
if (eet_vio) free(eet_vio);
|
||||
remix_set_error(env, REMIX_ERROR_SYSTEM);
|
||||
remix_destroy(env, (RemixBase *)sndfile);
|
||||
return RemixNone;
|
||||
}
|
||||
|
||||
static RemixBase *
|
||||
remix_eet_sndfile_reader_init(RemixEnv *env, RemixBase *base, CDSet *parameters)
|
||||
{
|
||||
char *file_path, *sound_id;
|
||||
double speed;
|
||||
|
||||
file_path = (cd_set_find(env, parameters, PATH_KEY)).s_string;
|
||||
sound_id = (cd_set_find(env, parameters, SOUND_ID_KEY)).s_string;
|
||||
speed = (cd_set_find(env, parameters, SPEED_KEY)).s_double;
|
||||
|
||||
if (!remix_eet_sndfile_create(env, base, file_path, sound_id, speed))
|
||||
return RemixNone;
|
||||
remix_eet_sndfile_optimise (env, base);
|
||||
return base;
|
||||
}
|
||||
|
||||
static RemixBase *
|
||||
remix_eet_sndfile_clone(RemixEnv *env, RemixBase *base)
|
||||
{
|
||||
SndInstanceData *si = remix_base_get_instance_data(env, base);
|
||||
RemixBase *new_sndfile = remix_base_new(env);
|
||||
|
||||
remix_eet_sndfile_create(env, new_sndfile, si->path, si->sound_id, si->speed);
|
||||
remix_eet_sndfile_optimise(env, new_sndfile);
|
||||
return new_sndfile;
|
||||
}
|
||||
|
||||
static int
|
||||
remix_eet_sndfile_destroy(RemixEnv *env, RemixBase *base)
|
||||
{
|
||||
SndInstanceData *si = remix_base_get_instance_data(env, base);
|
||||
if (si)
|
||||
{
|
||||
sf_close (si->pcm_fp);
|
||||
eet_close(si->efp);
|
||||
if (si->path) free(si->path);
|
||||
if (si->sound_id) free(si->sound_id);
|
||||
if (si->snd_info) free(si->snd_info);
|
||||
if (si->efp) eet_close(si->efp);
|
||||
if (si->inbuf) free(si->inbuf);
|
||||
if (si->outbuf) free(si->outbuf);
|
||||
if (si->vio_data) free(si->vio_data);
|
||||
free(si);
|
||||
}
|
||||
if (base) free (base);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
remix_pcm_resample(SndInstanceData *si)
|
||||
{
|
||||
RemixPCM *src, *dst, *srcbase;
|
||||
int i = 0, in_samples, pos, total, chnum, reqsamp, avail;
|
||||
int interp = 1;
|
||||
|
||||
dst = si->outbuf + (si->out_generated * 2);
|
||||
in_samples = (double)si->required_resamples / si->rs_ratio;
|
||||
chnum = si->snd_info->channels;
|
||||
reqsamp = si->required_resamples;
|
||||
avail = si->in_avail;
|
||||
srcbase = si->readbuf;
|
||||
if ((interp) && (si->rs_ratio >= 1.0))
|
||||
{
|
||||
// linear interpolation of resampling for lower quality samples
|
||||
// so they don't get high requency aliasing effects
|
||||
for (i = 0; i < reqsamp; i++)
|
||||
{
|
||||
float fpos, fpos1;
|
||||
RemixPCM psam[2];
|
||||
|
||||
fpos = (float)(i * in_samples) / (float)reqsamp;
|
||||
pos = fpos;
|
||||
if (pos >= avail) break;
|
||||
fpos -= pos;
|
||||
fpos1 = 1.0 - fpos;
|
||||
src = srcbase + (pos * chnum);
|
||||
if (chnum == 2)
|
||||
{
|
||||
if (pos == 0)
|
||||
{
|
||||
psam[0] = si->prevreadbuf[0];
|
||||
psam[1] = si->prevreadbuf[1];
|
||||
}
|
||||
else
|
||||
{
|
||||
psam[0] = src[0 - 2];
|
||||
psam[1] = src[1 - 2];
|
||||
}
|
||||
*dst++ = (src[0] * fpos) + (psam[0] * fpos1);
|
||||
*dst++ = (src[1] * fpos) + (psam[1] * fpos1);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (pos == 0)
|
||||
psam[0] = si->prevreadbuf[0];
|
||||
else
|
||||
psam[0] = src[0 - 1];
|
||||
*dst++ = (src[0] * fpos) + (psam[0] * fpos1);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// simple sample-picking/nearest. faster and simpler
|
||||
for (i = 0; i < reqsamp; i++)
|
||||
{
|
||||
pos = (i * in_samples) / reqsamp;
|
||||
if (pos >= avail) break;
|
||||
src = srcbase + (pos * chnum);
|
||||
if (chnum == 2)
|
||||
{
|
||||
*dst++ = src[0];
|
||||
*dst++ = src[1];
|
||||
}
|
||||
else
|
||||
*dst++ = src[0];
|
||||
}
|
||||
}
|
||||
si->out_generated += i;
|
||||
total = (i * in_samples) / reqsamp;
|
||||
si->readbuf += total * chnum;
|
||||
si->in_avail -= total;
|
||||
return total;
|
||||
}
|
||||
|
||||
/* An RemixChunkFunc for creating sndfile */
|
||||
static RemixCount
|
||||
remix_eet_sndfile_read_update(RemixEnv *env, RemixBase *sndfile, RemixCount count)
|
||||
{
|
||||
SndInstanceData *si = remix_base_get_instance_data(env, sndfile);
|
||||
|
||||
si->out_generated = 0;
|
||||
if (si->enable_resample)
|
||||
{
|
||||
RemixCount gen = 0;
|
||||
|
||||
while (gen < count)
|
||||
{
|
||||
if (si->in_avail <= 0)
|
||||
{
|
||||
si->in_avail = sf_readf_float(si->pcm_fp, si->inbuf, BLOCK_FRAMES);
|
||||
si->readbuf = si->inbuf;
|
||||
}
|
||||
si->required_resamples = (count - gen);
|
||||
remix_pcm_resample(si);
|
||||
if (si->snd_info->channels == 2)
|
||||
{
|
||||
si->prevreadbuf[0] = si->readbuf[-2];
|
||||
si->prevreadbuf[1] = si->readbuf[-1];
|
||||
}
|
||||
else
|
||||
{
|
||||
si->prevreadbuf[0] = si->readbuf[-1];
|
||||
}
|
||||
gen += si->out_generated;
|
||||
}
|
||||
si->out_generated = gen;
|
||||
}
|
||||
else
|
||||
{
|
||||
si->out_generated = sf_readf_float(si->pcm_fp, si->outbuf, count);
|
||||
}
|
||||
return si->out_generated;
|
||||
}
|
||||
|
||||
static RemixCount
|
||||
remix_eet_sndfile_read_into_chunk(RemixEnv *env, RemixChunk *chunk, RemixCount offset, RemixCount count, int channelname, void *data)
|
||||
{
|
||||
RemixBase *sndfile = data;
|
||||
SndInstanceData *si = remix_base_get_instance_data(env, sndfile);
|
||||
RemixPCM *d, *p;
|
||||
RemixCount remaining = count, written = 0, n, i;
|
||||
|
||||
d = &chunk->data[offset];
|
||||
n = MIN(remaining, BLOCK_FRAMES);
|
||||
// Need parameter support to advance the data reading
|
||||
if (channelname == 0)
|
||||
remix_eet_sndfile_read_update(env, sndfile, n);
|
||||
n = MIN(si->out_generated, remaining);
|
||||
p = si->outbuf;
|
||||
if (si->snd_info->channels > 1) p += channelname;
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
*d++ = *p;
|
||||
p += si->snd_info->channels;
|
||||
}
|
||||
if (n == 0) n = _remix_pcm_set(d, 0.0, remaining);
|
||||
remaining -= n;
|
||||
written += n;
|
||||
return written;
|
||||
}
|
||||
|
||||
static RemixCount
|
||||
remix_eet_sndfile_reader_process(RemixEnv *env, RemixBase *base, RemixCount count, RemixStream *input __UNUSED__, RemixStream *output)
|
||||
{
|
||||
return remix_stream_chunkfuncify(env, output, count,
|
||||
remix_eet_sndfile_read_into_chunk,
|
||||
base);
|
||||
}
|
||||
|
||||
static RemixCount
|
||||
remix_eet_sndfile_length(RemixEnv *env, RemixBase *base)
|
||||
{
|
||||
SndInstanceData *si = remix_base_get_instance_data(env, base);
|
||||
return si->resample_len;
|
||||
}
|
||||
|
||||
static RemixCount
|
||||
remix_eet_sndfile_seek(RemixEnv *env, RemixBase *base, RemixCount offset)
|
||||
{
|
||||
SndInstanceData *si = remix_base_get_instance_data(env, base);
|
||||
return sf_seek(si->pcm_fp, offset, SEEK_SET);
|
||||
}
|
||||
|
||||
static struct _RemixMethods _remix_eet_sndfile_reader_methods =
|
||||
{
|
||||
remix_eet_sndfile_clone,
|
||||
remix_eet_sndfile_destroy,
|
||||
NULL, /* ready */
|
||||
NULL, /* prepare */
|
||||
remix_eet_sndfile_reader_process,
|
||||
remix_eet_sndfile_length,
|
||||
remix_eet_sndfile_seek,
|
||||
NULL, /* flush */
|
||||
};
|
||||
|
||||
static RemixBase *
|
||||
remix_eet_sndfile_optimise(RemixEnv *env, RemixBase *sndfile)
|
||||
{
|
||||
remix_base_set_methods(env, sndfile, &_remix_eet_sndfile_reader_methods);
|
||||
return sndfile;
|
||||
}
|
||||
|
||||
static struct _RemixParameterScheme path_scheme =
|
||||
{
|
||||
"path",
|
||||
"Path to sound file",
|
||||
REMIX_TYPE_STRING,
|
||||
REMIX_CONSTRAINT_TYPE_NONE,
|
||||
{NULL},
|
||||
REMIX_HINT_FILENAME,
|
||||
};
|
||||
|
||||
static struct _RemixParameterScheme sound_id_scheme =
|
||||
{
|
||||
"sound_id",
|
||||
"Sound Id (Key) inside EET",
|
||||
REMIX_TYPE_STRING,
|
||||
REMIX_CONSTRAINT_TYPE_NONE,
|
||||
{NULL},
|
||||
REMIX_HINT_DEFAULT,
|
||||
};
|
||||
|
||||
static struct _RemixParameterScheme speed_scheme =
|
||||
{
|
||||
"speed",
|
||||
"Sound Play Speed",
|
||||
REMIX_TYPE_FLOAT,
|
||||
REMIX_CONSTRAINT_TYPE_NONE,
|
||||
{NULL},
|
||||
REMIX_HINT_DEFAULT,
|
||||
};
|
||||
|
||||
static struct _RemixMetaText eet_sndfile_reader_metatext =
|
||||
{
|
||||
"eet_sndfile_reader",
|
||||
"File:: Sound file Reader from EET",
|
||||
"Reads PCM audio files from EET bundle using libsndfile",
|
||||
"Copyright (C) 2011, Samsung Electronics Co., Ltd.",
|
||||
"http://www.samsung.com",
|
||||
REMIX_ONE_AUTHOR ("govi.sm@samsung.com", "prince.dubey@samsung.com"),
|
||||
};
|
||||
|
||||
static struct _RemixPlugin eet_sndfile_reader_plugin =
|
||||
{
|
||||
&eet_sndfile_reader_metatext,
|
||||
REMIX_FLAGS_NONE,
|
||||
CD_EMPTY_SET, /* init scheme */
|
||||
remix_eet_sndfile_reader_init,
|
||||
CD_EMPTY_SET, /* process scheme */
|
||||
NULL, /* suggests */
|
||||
NULL, /* plugin data */
|
||||
NULL /* destroy */
|
||||
};
|
||||
|
||||
EAPI CDList *
|
||||
remix_load(RemixEnv *env)
|
||||
{
|
||||
CDList *plugins = cd_list_new(env);
|
||||
|
||||
eet_sndfile_reader_plugin.init_scheme =
|
||||
cd_set_insert(env, eet_sndfile_reader_plugin.init_scheme, PATH_KEY,
|
||||
CD_POINTER(&path_scheme));
|
||||
eet_sndfile_reader_plugin.init_scheme =
|
||||
cd_set_insert(env, eet_sndfile_reader_plugin.init_scheme, SOUND_ID_KEY,
|
||||
CD_POINTER(&sound_id_scheme));
|
||||
eet_sndfile_reader_plugin.init_scheme =
|
||||
cd_set_insert(env, eet_sndfile_reader_plugin.init_scheme, SPEED_KEY,
|
||||
CD_POINTER(&speed_scheme));
|
||||
|
||||
plugins = cd_list_prepend(env, plugins,
|
||||
CD_POINTER(&eet_sndfile_reader_plugin));
|
||||
return plugins;
|
||||
}
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
#include "config.h"
|
||||
#include "edje_private.h"
|
||||
|
||||
#define DEFAULT_SAMPLERATE 44100
|
||||
|
||||
#ifdef HAVE_LIBREMIX
|
||||
EAPI RemixBase *
|
||||
multisense_sound_player_get(Edje_Multisense_Env *msenv)
|
||||
{
|
||||
RemixEnv *env = msenv->remixenv;
|
||||
RemixPlugin *player_plugin;
|
||||
RemixBase *player;
|
||||
|
||||
player_plugin = remix_find_plugin(env, "alsa_snd_player");
|
||||
if (!player_plugin)
|
||||
{
|
||||
WRN("ALSA player_plugin init fail\n");
|
||||
return remix_monitor_new(env);
|
||||
}
|
||||
player = remix_new(env, player_plugin, NULL);
|
||||
return player;
|
||||
}
|
||||
#endif
|
||||
|
||||
EAPI Eina_Bool
|
||||
multisense_factory_init(Edje_Multisense_Env *env __UNUSED__)
|
||||
{
|
||||
#ifdef HAVE_LIBREMIX
|
||||
remix_set_samplerate(env->remixenv, DEFAULT_SAMPLERATE);
|
||||
remix_set_channels(env->remixenv, REMIX_STEREO);
|
||||
#endif
|
||||
return EINA_TRUE;
|
||||
}
|
||||
Loading…
Reference in New Issue