2 * RemixSnd_eetfile: a libsnd EET Virtual file handler
4 * Govindaraju SM <govi.sm@samsung.com>, August 2011
5 * Prince Kumar Dubey <prince.dubey@samsung.com>, August 2011
11 #include <remix/remix.h>
15 #define SOUND_ID_KEY 2
17 #define BLOCK_FRAMES 8192
19 static RemixBase *remix_eet_sndfile_optimise(RemixEnv *env, RemixBase *sndfile);
21 typedef struct _VIO_DATA VIO_DATA;
22 typedef struct _SndInstanceData SndInstanceData;
26 sf_count_t offset, length;
30 struct _SndInstanceData
32 /* plugin parameters */
37 /* Edj & Sndfile Reader */
49 RemixPCM prevreadbuf[2];
52 RemixCount resample_len;
54 RemixCount out_generated;
55 RemixCount required_resamples;
59 eet_snd_file_get_length(void *user_data)
61 VIO_DATA *vf = user_data;
66 eet_snd_file_seek(sf_count_t offset, int whence, void *user_data)
68 VIO_DATA *vf = user_data;
79 vf->offset = vf->length + offset;
88 eet_snd_file_read(void *ptr, sf_count_t count, void *user_data)
90 VIO_DATA *vf = user_data;
92 if ((vf->offset + count) > vf->length)
93 count = vf->length - vf->offset;
94 memcpy(ptr, vf->data + vf->offset, count);
100 eet_snd_file_tell(void *user_data)
102 VIO_DATA *vf = user_data;
107 remix_init_resampler_data(RemixEnv *env, RemixBase *base)
109 SndInstanceData *si = remix_base_get_instance_data(env, base);
111 si->rs_ratio = remix_get_samplerate(env) / si->snd_info->samplerate;
112 si->rs_ratio /= si->speed;
113 si->resample_len = (si->snd_info->frames * si->rs_ratio);
115 si->outbuf = malloc(sizeof(RemixPCM) * BLOCK_FRAMES * 2);
116 if (!si->outbuf) return 0;
117 if ((si->rs_ratio == 1.0)/* && (si->snd_info->channels == 2)*/)
119 si->enable_resample = 0;
123 si->enable_resample = 1;
126 si->out_generated = 0;
127 si->inbuf = malloc(sizeof(RemixPCM) * BLOCK_FRAMES *
128 si->snd_info->channels);
129 if (!si->inbuf) return 0;
134 remix_eet_sndfile_create(RemixEnv *env, RemixBase *sndfile, const char *path, const char *sound_id, const double speed)
136 SF_VIRTUAL_IO *eet_vio = NULL;
138 const void *sound_data;
141 if ((!path) || (!sound_id)) return NULL;
143 si = calloc(1, sizeof(SndInstanceData));
145 remix_base_set_instance_data(env, sndfile, si);
147 si->path = strdup(path);
148 si->sound_id = strdup(sound_id);
151 si->efp = eet_open(path, EET_FILE_MODE_READ);
152 if (!si->efp) goto err;
154 // xxx: eet_read_direct does not work on Threads, using eet_read.
155 sound_data = eet_read(si->efp, sound_id, &(sound_size));
158 if (sound_data == NULL) goto err;
160 eet_vio = calloc(1, sizeof(SF_VIRTUAL_IO));
161 if (!eet_vio) goto err;
163 /* Set up func pointers to read snd file directly from EET. */
164 eet_vio->get_filelen = eet_snd_file_get_length;
165 eet_vio->seek = eet_snd_file_seek;
166 eet_vio->read = eet_snd_file_read;
167 eet_vio->tell = eet_snd_file_tell;
169 si->vio_data = calloc(1, sizeof(VIO_DATA));
170 if (!si->vio_data) goto err;
171 si->vio_data->offset = 0;
172 si->vio_data->length = sound_size;
173 si->vio_data->data = sound_data;
175 si->snd_info = calloc(1, sizeof(SF_INFO));
176 if (!si->snd_info) goto err;
178 si->pcm_fp = sf_open_virtual(eet_vio, SFM_READ, si->snd_info, si->vio_data);
179 if (!si->pcm_fp) goto err;
183 if (!remix_init_resampler_data(env, sndfile)) goto err;
184 si->out_generated = 0;
189 if (eet_vio) free(eet_vio);
190 remix_set_error(env, REMIX_ERROR_SYSTEM);
191 remix_destroy(env, (RemixBase *)sndfile);
196 remix_eet_sndfile_reader_init(RemixEnv *env, RemixBase *base, CDSet *parameters)
198 char *file_path, *sound_id;
201 file_path = (cd_set_find(env, parameters, PATH_KEY)).s_string;
202 sound_id = (cd_set_find(env, parameters, SOUND_ID_KEY)).s_string;
203 speed = (cd_set_find(env, parameters, SPEED_KEY)).s_double;
205 if (!remix_eet_sndfile_create(env, base, file_path, sound_id, speed))
207 remix_eet_sndfile_optimise (env, base);
212 remix_eet_sndfile_clone(RemixEnv *env, RemixBase *base)
214 SndInstanceData *si = remix_base_get_instance_data(env, base);
215 RemixBase *new_sndfile = remix_base_new(env);
217 remix_eet_sndfile_create(env, new_sndfile, si->path, si->sound_id, si->speed);
218 remix_eet_sndfile_optimise(env, new_sndfile);
223 remix_eet_sndfile_destroy(RemixEnv *env, RemixBase *base)
225 SndInstanceData *si = remix_base_get_instance_data(env, base);
228 sf_close (si->pcm_fp);
230 if (si->path) free(si->path);
231 if (si->sound_id) free(si->sound_id);
232 if (si->snd_info) free(si->snd_info);
233 if (si->efp) eet_close(si->efp);
234 if (si->inbuf) free(si->inbuf);
235 if (si->outbuf) free(si->outbuf);
236 if (si->vio_data) free(si->vio_data);
239 if (base) free (base);
244 remix_pcm_resample(SndInstanceData *si)
246 RemixPCM *src, *dst, *srcbase;
247 int i = 0, in_samples, pos, total, chnum, reqsamp, avail;
250 dst = si->outbuf + (si->out_generated * 2);
251 in_samples = (double)si->required_resamples / si->rs_ratio;
252 chnum = si->snd_info->channels;
253 reqsamp = si->required_resamples;
254 avail = si->in_avail;
255 srcbase = si->readbuf;
256 if ((interp) && (si->rs_ratio >= 1.0))
258 // linear interpolation of resampling for lower quality samples
259 // so they don't get high requency aliasing effects
260 for (i = 0; i < reqsamp; i++)
265 fpos = (float)(i * in_samples) / (float)reqsamp;
267 if (pos >= avail) break;
270 src = srcbase + (pos * chnum);
275 psam[0] = si->prevreadbuf[0];
276 psam[1] = si->prevreadbuf[1];
280 psam[0] = src[0 - 2];
281 psam[1] = src[1 - 2];
283 *dst++ = (src[0] * fpos) + (psam[0] * fpos1);
284 *dst++ = (src[1] * fpos) + (psam[1] * fpos1);
289 psam[0] = si->prevreadbuf[0];
291 psam[0] = src[0 - 1];
292 *dst++ = (src[0] * fpos) + (psam[0] * fpos1);
298 // simple sample-picking/nearest. faster and simpler
299 for (i = 0; i < reqsamp; i++)
301 pos = (i * in_samples) / reqsamp;
302 if (pos >= avail) break;
303 src = srcbase + (pos * chnum);
313 si->out_generated += i;
314 total = (i * in_samples) / reqsamp;
315 si->readbuf += total * chnum;
316 si->in_avail -= total;
320 /* An RemixChunkFunc for creating sndfile */
322 remix_eet_sndfile_read_update(RemixEnv *env, RemixBase *sndfile, RemixCount count)
324 SndInstanceData *si = remix_base_get_instance_data(env, sndfile);
326 si->out_generated = 0;
327 if (si->enable_resample)
333 if (si->in_avail <= 0)
335 si->in_avail = sf_readf_float(si->pcm_fp, si->inbuf, BLOCK_FRAMES);
336 si->readbuf = si->inbuf;
338 si->required_resamples = (count - gen);
339 remix_pcm_resample(si);
340 if (si->snd_info->channels == 2)
342 si->prevreadbuf[0] = si->readbuf[-2];
343 si->prevreadbuf[1] = si->readbuf[-1];
347 si->prevreadbuf[0] = si->readbuf[-1];
349 gen += si->out_generated;
351 si->out_generated = gen;
355 si->out_generated = sf_readf_float(si->pcm_fp, si->outbuf, count);
357 return si->out_generated;
361 remix_eet_sndfile_read_into_chunk(RemixEnv *env, RemixChunk *chunk, RemixCount offset, RemixCount count, int channelname, void *data)
363 RemixBase *sndfile = data;
364 SndInstanceData *si = remix_base_get_instance_data(env, sndfile);
366 RemixCount remaining = count, written = 0, n, i;
368 d = &chunk->data[offset];
369 n = MIN(remaining, BLOCK_FRAMES);
370 // Need parameter support to advance the data reading
371 if (channelname == 0)
372 remix_eet_sndfile_read_update(env, sndfile, n);
373 n = MIN(si->out_generated, remaining);
375 if (si->snd_info->channels > 1) p += channelname;
376 for (i = 0; i < n; i++)
379 p += si->snd_info->channels;
381 if (n == 0) n = _remix_pcm_set(d, 0.0, remaining);
388 remix_eet_sndfile_reader_process(RemixEnv *env, RemixBase *base, RemixCount count, RemixStream *input __UNUSED__, RemixStream *output)
390 return remix_stream_chunkfuncify(env, output, count,
391 remix_eet_sndfile_read_into_chunk,
396 remix_eet_sndfile_length(RemixEnv *env, RemixBase *base)
398 SndInstanceData *si = remix_base_get_instance_data(env, base);
399 return si->resample_len;
403 remix_eet_sndfile_seek(RemixEnv *env, RemixBase *base, RemixCount offset)
405 SndInstanceData *si = remix_base_get_instance_data(env, base);
406 return sf_seek(si->pcm_fp, offset, SEEK_SET);
409 static struct _RemixMethods _remix_eet_sndfile_reader_methods =
411 remix_eet_sndfile_clone,
412 remix_eet_sndfile_destroy,
415 remix_eet_sndfile_reader_process,
416 remix_eet_sndfile_length,
417 remix_eet_sndfile_seek,
422 remix_eet_sndfile_optimise(RemixEnv *env, RemixBase *sndfile)
424 remix_base_set_methods(env, sndfile, &_remix_eet_sndfile_reader_methods);
428 static struct _RemixParameterScheme path_scheme =
431 "Path to sound file",
433 REMIX_CONSTRAINT_TYPE_NONE,
438 static struct _RemixParameterScheme sound_id_scheme =
441 "Sound Id (Key) inside EET",
443 REMIX_CONSTRAINT_TYPE_NONE,
448 static struct _RemixParameterScheme speed_scheme =
453 REMIX_CONSTRAINT_TYPE_NONE,
458 static struct _RemixMetaText eet_sndfile_reader_metatext =
460 "eet_sndfile_reader",
461 "File:: Sound file Reader from EET",
462 "Reads PCM audio files from EET bundle using libsndfile",
463 "Copyright (C) 2011, Samsung Electronics Co., Ltd.",
464 "http://www.samsung.com",
465 REMIX_ONE_AUTHOR ("govi.sm@samsung.com", "prince.dubey@samsung.com"),
468 static struct _RemixPlugin eet_sndfile_reader_plugin =
470 &eet_sndfile_reader_metatext,
472 CD_EMPTY_SET, /* init scheme */
473 remix_eet_sndfile_reader_init,
474 CD_EMPTY_SET, /* process scheme */
476 NULL, /* plugin data */
481 remix_load(RemixEnv *env)
483 CDList *plugins = cd_list_new(env);
485 eet_sndfile_reader_plugin.init_scheme =
486 cd_set_insert(env, eet_sndfile_reader_plugin.init_scheme, PATH_KEY,
487 CD_POINTER(&path_scheme));
488 eet_sndfile_reader_plugin.init_scheme =
489 cd_set_insert(env, eet_sndfile_reader_plugin.init_scheme, SOUND_ID_KEY,
490 CD_POINTER(&sound_id_scheme));
491 eet_sndfile_reader_plugin.init_scheme =
492 cd_set_insert(env, eet_sndfile_reader_plugin.init_scheme, SPEED_KEY,
493 CD_POINTER(&speed_scheme));
495 plugins = cd_list_prepend(env, plugins,
496 CD_POINTER(&eet_sndfile_reader_plugin));