BEAST/BSE - Better Audio System and Sound Engine  0.9.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
gsldatautils.hh
Go to the documentation of this file.
1  // Licensed GNU LGPL v2.1 or later: http://www.gnu.org/licenses/lgpl.html
2 #ifndef __GSL_DATA_UTILS_H__
3 #define __GSL_DATA_UTILS_H__
4 
5 #include <bse/bsemath.hh>
6 #include <bse/gsldatahandle.hh>
7 
8 G_BEGIN_DECLS
9 
10 /* --- structures --- */
11 #define GSL_DATA_HANDLE_PEEK_BUFFER (2048)
12 typedef struct
13 {
14  gint dir; /* initialize direction to -1 or +1 (or 0 for random access) */
15  GslLong start; /* initialize to 0 */
16  GslLong end; /* initialize to 0 */
17  gfloat data[GSL_DATA_HANDLE_PEEK_BUFFER];
19 typedef struct
20 {
21  GslLong head_skip; /* FIXME: remove this */
22  GslLong tail_cut;
23  GslLong min_loop;
24  GslLong max_loop;
25 } GslLoopSpec; /* rename this to GslData... */
26 
27 
28 /* --- data utils --- */
29 gboolean gsl_data_detect_signal (GslDataHandle *handle,
30  GslLong *sigstart,
31  GslLong *sigend);
32 GslLong gsl_data_find_sample (GslDataHandle *dhandle,
33  gfloat min_value,
34  gfloat max_value,
35  GslLong start_offset,
36  gint direction);
37 gboolean gsl_data_find_tailmatch (GslDataHandle *dhandle,
38  const GslLoopSpec *lspec,
39  GslLong *loop_start_p,
40  GslLong *loop_end_p);
41 GslLong gsl_data_find_block (GslDataHandle *handle,
42  guint n_values,
43  const gfloat *values,
44  gfloat epsilon);
45 gfloat* gsl_data_make_fade_ramp (GslDataHandle *handle,
46  GslLong min_pos, /* *= 0.0 + delta */
47  GslLong max_pos, /* *= 1.0 - delta */
48  GslLong *length_p);
49 double gsl_data_find_min_max (GslDataHandle *handle,
50  double *dmin,
51  double *dmax);
52 
53 
54 /* --- data handle utils --- */
55 static inline gfloat gsl_data_handle_peek_value (GslDataHandle *dhandle,
56  GslLong position,
57  GslDataPeekBuffer *peekbuf);
58 gint /* errno */ gsl_data_handle_dump (GslDataHandle *dhandle,
59  gint fd,
60  GslWaveFormatType format,
61  guint byte_order);
62 gint /* errno */ gsl_data_handle_dump_wav (GslDataHandle *dhandle,
63  gint fd,
64  guint n_bits,
65  guint n_channels,
66  guint sample_freq);
67 void gsl_data_handle_dump_wstore(GslDataHandle *dhandle,
68  SfiWStore *wstore,
69  GslWaveFormatType format,
70  guint byte_order);
71 gint /* errno */ bse_wave_file_dump_header (gint fd,
72  guint n_data_bytes,
73  guint n_bits,
74  guint n_channels,
75  guint sample_freq);
76 gint /* errno */ bse_wave_file_patch_length (gint fd,
77  guint n_data_bytes);
78 gint /* errno */ bse_wave_file_dump_data (gint fd,
79  guint n_bits,
80  guint n_values,
81  const gfloat *values);
82 gint /* errno */ bse_wave_file_from_fbuffer (const char *file_name,
83  guint n_bits,
84  guint n_channels,
85  guint sample_freq,
86  guint n_values,
87  const gfloat *values);
88 gint /* errno */ bse_wave_file_from_dbuffer (const char *file_name,
89  guint n_bits,
90  guint n_channels,
91  guint sample_freq,
92  guint n_values,
93  const gdouble *values);
94 
95 /* --- conversion utils --- */
96 static inline guint gsl_conv_from_float (GslWaveFormatType format,
97  guint byte_order,
98  const gfloat *src,
99  gpointer dest,
100  guint n_values);
101 static inline guint gsl_conv_from_float_clip (GslWaveFormatType format,
102  guint byte_order,
103  const gfloat *src,
104  gpointer dest,
105  guint n_values);
106 static inline void gsl_conv_to_float (GslWaveFormatType format,
107  guint byte_order,
108  gconstpointer src,
109  gfloat *dest,
110  guint n_values);
111 static inline guint gsl_conv_from_double (GslWaveFormatType format,
112  guint byte_order,
113  const gdouble *src,
114  gpointer dest,
115  guint n_values);
116 static inline guint gsl_conv_from_double_clip (GslWaveFormatType format,
117  guint byte_order,
118  const gdouble *src,
119  gpointer dest,
120  guint n_values);
121 static inline void gsl_conv_to_double (GslWaveFormatType format,
122  guint byte_order,
123  gconstpointer src,
124  gdouble *dest,
125  guint n_values);
126 static inline gint16 gsl_alaw_to_pcm (gint8 alawv);
127 static inline gint16 gsl_ulaw_to_pcm (gint8 ulawv);
128 
129 
130 /* --- clipping --- */
131 typedef struct
132 {
133  guint produce_info : 1;
134  gfloat threshold; /* 0..+1 */
135  guint head_samples;
136  guint tail_samples;
137  guint fade_samples;
138  guint pad_samples;
139  guint tail_silence;
141 typedef struct
142 {
143  GslDataHandle *dhandle;
144  guint clipped_to_0length : 1; /* no data above threshold */
145  guint head_detected : 1; /* found head_samples silence */
146  guint tail_detected : 1; /* found tail_samples silence */
147  guint clipped_head : 1;
148  guint clipped_tail : 1;
149  BseErrorType error;
151 
152 BseErrorType gsl_data_clip_sample (GslDataHandle *dhandle,
153  GslDataClipConfig *cconfig,
154  GslDataClipResult *result);
155 
156 
157 /* --- misc implementations --- */
158 gfloat gsl_data_peek_value_f (GslDataHandle *dhandle,
159  GslLong pos,
160  GslDataPeekBuffer *peekbuf);
161 
162 static inline gfloat
163 gsl_data_handle_peek_value (GslDataHandle *dhandle,
164  GslLong position,
165  GslDataPeekBuffer *peekbuf)
166 {
167  return (position >= peekbuf->start && position < peekbuf->end ?
168  peekbuf->data[position - peekbuf->start] :
169  gsl_data_peek_value_f (dhandle, position, peekbuf));
170 }
171 
172 #define GSL_CONV_FORMAT(format, endian_flag) (((endian_flag) << 16) | ((format) & 0xffff))
173 
174 static inline guint /* returns number of bytes used in dest */
175 gsl_conv_from_float (GslWaveFormatType format,
176  guint byte_order,
177  const gfloat *src,
178  gpointer dest,
179  guint n_values)
180 {
181  gint8 *i8 = (gint8*) dest;
182  guint8 *u8 = (guint8*) dest;
183  gint16 *i16 = (gint16*) dest;
184  guint16 *u16 = (guint16*) dest;
185  gint32 *i32 = (gint32*) dest;
186  guint32 *u32dest = (guint32*) dest;
187  const gfloat *bound = src + n_values;
188  const guint32 *u32src = (guint32*) src, *u32bound = (const guint32*) bound;
189 
190  if (!n_values)
191  return 0;
192 
193  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
194  {
195  BseFpuState fpu;
196  gfloat v;
197  gint16 vi16;
198  guint16 vu16;
199  guint32 vu32;
200  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
201  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
202  do
203  *u8++ = bse_dtoi (*src++ * 128. + 128);
204  while (src < bound);
205  return n_values;
206  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
207  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
208  bse_fpu_setround (&fpu);
209  do
210  {
211  v = *src++;
212  v *= 128.;
213  *i8++ = bse_dtoi (v);
214  }
215  while (src < bound);
216  bse_fpu_restore (fpu);
217  return n_values;
218  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
219  do
220  *u16++ = bse_dtoi (*src++ * 2048. + 2048);
221  while (src < bound);
222  return n_values << 1;
223  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
224  do
225  {
226  vu16 = bse_dtoi (*src++ * 2048. + 2048);
227  *u16++ = GUINT16_SWAP_LE_BE (vu16);
228  }
229  while (src < bound);
230  return n_values << 1;
231  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
232  bse_fpu_setround (&fpu);
233  do
234  {
235  v = *src++;
236  v *= 2048.;
237  *i16++ = bse_dtoi (v);
238  }
239  while (src < bound);
240  bse_fpu_restore (fpu);
241  return n_values << 1;
242  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
243  bse_fpu_setround (&fpu);
244  do
245  {
246  v = *src++;
247  v *= 2048.;
248  vi16 = bse_dtoi (v);
249  *i16++ = GUINT16_SWAP_LE_BE (vi16);
250  }
251  while (src < bound);
252  bse_fpu_restore (fpu);
253  return n_values << 1;
254  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
255  do
256  *u16++ = bse_dtoi (*src++ * 32768. + 32768);
257  while (src < bound);
258  return n_values << 1;
259  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
260  do
261  {
262  vu16 = bse_dtoi (*src++ * 32768. + 32768);
263  *u16++ = GUINT16_SWAP_LE_BE (vu16);
264  }
265  while (src < bound);
266  return n_values << 1;
267  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
268  bse_fpu_setround (&fpu);
269  do
270  {
271  v = *src++;
272  v *= 32768.;
273  *i16++ = bse_dtoi (v);
274  }
275  while (src < bound);
276  bse_fpu_restore (fpu);
277  return n_values << 1;
278  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
279  bse_fpu_setround (&fpu);
280  do
281  {
282  v = *src++;
283  v *= 32768.;
284  vi16 = bse_dtoi (v);
285  *i16++ = GUINT16_SWAP_LE_BE (vi16);
286  }
287  while (src < bound);
288  bse_fpu_restore (fpu);
289  return n_values << 1;
290  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER == G_BYTE_ORDER):
291  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER != G_BYTE_ORDER):
292  bse_fpu_setround (&fpu);
293  if (byte_order == G_LITTLE_ENDIAN)
294  do
295  {
296  v = *src++;
297  v *= 8388608.;
298  gint32 vi32 = bse_dtoi (v);
299  *u8++ = vi32 >> 0;
300  *u8++ = vi32 >> 8;
301  *((gint8*) u8) = vi32 >> 16;
302  u8++;
303  }
304  while (src < bound);
305  else /* G_BIG_ENDIAN */
306  do
307  {
308  v = *src++;
309  v *= 8388608.;
310  gint32 vi32 = bse_dtoi (v);
311  *((gint8*) u8) = vi32 >> 16;
312  u8++;
313  *u8++ = vi32 >> 8;
314  *u8++ = vi32 >> 0;
315  }
316  while (src < bound);
317  bse_fpu_restore (fpu);
318  return n_values * 3;
319  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER == G_BYTE_ORDER):
320  bse_fpu_setround (&fpu);
321  do
322  {
323  v = *src++;
324  v *= 8388608.;
325  *i32++ = bse_dtoi (v);
326  }
327  while (src < bound);
328  bse_fpu_restore (fpu);
329  return n_values * 4;
330  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER != G_BYTE_ORDER):
331  bse_fpu_setround (&fpu);
332  do
333  {
334  v = *src++;
335  v *= 8388608.;
336  gint32 vi32 = bse_dtoi (v);
337  *i32++ = GUINT32_SWAP_LE_BE (vi32);
338  }
339  while (src < bound);
340  bse_fpu_restore (fpu);
341  return n_values * 4;
342  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER == G_BYTE_ORDER):
343  bse_fpu_setround (&fpu);
344  do
345  {
346  v = *src++;
347  v *= 2147483648.;
348  *i32++ = bse_dtoi (v);
349  }
350  while (src < bound);
351  bse_fpu_restore (fpu);
352  return n_values * 4;
353  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER != G_BYTE_ORDER):
354  bse_fpu_setround (&fpu);
355  do
356  {
357  v = *src++;
358  v *= 2147483648.;
359  gint32 vi32 = bse_dtoi (v);
360  *i32++ = GUINT32_SWAP_LE_BE (vi32);
361  }
362  while (src < bound);
363  bse_fpu_restore (fpu);
364  return n_values * 4;
365  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
366  return n_values * 4;
367  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
368  do
369  {
370  vu32 = *u32src++;
371  *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
372  }
373  while (u32src < u32bound);
374  return n_values * 4;
375  default:
376  g_assert_not_reached ();
377  return 0;
378  }
379 }
380 
381 static inline guint /* returns number of bytes used in dest */
382 gsl_conv_from_float_clip (GslWaveFormatType format,
383  guint byte_order,
384  const gfloat *src,
385  gpointer dest,
386  guint n_values)
387 {
388  gint8 *i8 = (gint8*) dest;
389  guint8 *u8 = (guint8*) dest;
390  gint16 *i16 = (gint16*) dest;
391  guint16 *u16 = (guint16*) dest;
392  gint32 *i32 = (gint32*) dest;
393  guint32 *u32dest = (guint32*) dest;
394  const gfloat *bound = src + n_values;
395  const guint32 *u32src = (const guint32*) src, *u32bound = (const guint32*) bound;
396 
397  if (!n_values)
398  return 0;
399 
400  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
401  {
402  BseFpuState fpu;
403  gfloat v;
404  guint32 vu32;
405  gint32 vi32;
406  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
407  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
408  do
409  {
410  vi32 = bse_dtoi (*src++ * 128. + 128);
411  *u8++ = CLAMP (vi32, 0, 255);
412  }
413  while (src < bound);
414  return n_values;
415  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
416  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
417  bse_fpu_setround (&fpu);
418  do
419  {
420  v = *src++;
421  v *= 128.;
422  vi32 = bse_dtoi (v);
423  *i8++ = CLAMP (vi32, -128, 127);
424  }
425  while (src < bound);
426  bse_fpu_restore (fpu);
427  return n_values;
428  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
429  do
430  {
431  vi32 = bse_dtoi (*src++ * 2048. + 2048);
432  *u16++ = CLAMP (vi32, 0, 4095);
433  }
434  while (src < bound);
435  return n_values << 1;
436  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
437  do
438  {
439  vi32 = bse_dtoi (*src++ * 2048. + 2048);
440  vi32 = CLAMP (vi32, 0, 4095);
441  *u16++ = GUINT16_SWAP_LE_BE (vi32);
442  }
443  while (src < bound);
444  return n_values << 1;
445  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
446  bse_fpu_setround (&fpu);
447  do
448  {
449  v = *src++;
450  v *= 2048.;
451  vi32 = bse_dtoi (v);
452  *i16++ = CLAMP (vi32, -2048, 2047);
453  }
454  while (src < bound);
455  bse_fpu_restore (fpu);
456  return n_values << 1;
457  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
458  bse_fpu_setround (&fpu);
459  do
460  {
461  v = *src++;
462  v *= 2048.;
463  vi32 = bse_dtoi (v);
464  vi32 = CLAMP (vi32, -2048, 2047);
465  *i16++ = GUINT16_SWAP_LE_BE (vi32);
466  }
467  while (src < bound);
468  bse_fpu_restore (fpu);
469  return n_values << 1;
470  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
471  do
472  {
473  vi32 = bse_dtoi (*src++ * 32768. + 32768);
474  *u16++ = CLAMP (vi32, 0, 65535);
475  }
476  while (src < bound);
477  return n_values << 1;
478  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
479  do
480  {
481  vi32 = bse_dtoi (*src++ * 32768. + 32768);
482  vi32 = CLAMP (vi32, 0, 65535);
483  *u16++ = GUINT16_SWAP_LE_BE (vi32);
484  }
485  while (src < bound);
486  return n_values << 1;
487  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
488  bse_fpu_setround (&fpu);
489  do
490  {
491  v = *src++;
492  v *= 32768.;
493  vi32 = bse_dtoi (v);
494  vi32 = CLAMP (vi32, -32768, 32767);
495  *i16++ = vi32;
496  }
497  while (src < bound);
498  bse_fpu_restore (fpu);
499  return n_values << 1;
500  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
501  bse_fpu_setround (&fpu);
502  do
503  {
504  v = *src++;
505  v *= 32768.;
506  vi32 = bse_dtoi (v);
507  vi32 = CLAMP (vi32, -32768, 32767);
508  *i16++ = GUINT16_SWAP_LE_BE (vi32);
509  }
510  while (src < bound);
511  bse_fpu_restore (fpu);
512  return n_values << 1;
513  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER == G_BYTE_ORDER):
514  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER != G_BYTE_ORDER):
515  bse_fpu_setround (&fpu);
516  if (byte_order == G_LITTLE_ENDIAN)
517  do
518  {
519  v = *src++;
520  v *= 8388608.;
521  gint32 vi32 = bse_dtoi (v);
522  vi32 = CLAMP (vi32, -8388608, 8388607);
523  *u8++ = vi32 >> 0;
524  *u8++ = vi32 >> 8;
525  *((gint8*) u8) = vi32 >> 16;
526  u8++;
527  }
528  while (src < bound);
529  else /* G_BIG_ENDIAN */
530  do
531  {
532  v = *src++;
533  v *= 8388608.;
534  gint32 vi32 = bse_dtoi (v);
535  vi32 = CLAMP (vi32, -8388608, 8388607);
536  *((gint8*) u8) = vi32 >> 16;
537  u8++;
538  *u8++ = vi32 >> 8;
539  *u8++ = vi32 >> 0;
540  }
541  while (src < bound);
542  bse_fpu_restore (fpu);
543  return n_values * 3;
544  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER == G_BYTE_ORDER):
545  bse_fpu_setround (&fpu);
546  do
547  {
548  v = *src++;
549  v *= 8388608.;
550  vi32 = bse_dtoi (v);
551  vi32 = CLAMP (vi32, -8388608, 8388607);
552  *i32++ = vi32;
553  }
554  while (src < bound);
555  bse_fpu_restore (fpu);
556  return n_values * 4;
557  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER != G_BYTE_ORDER):
558  bse_fpu_setround (&fpu);
559  do
560  {
561  v = *src++;
562  v *= 8388608.;
563  vi32 = bse_dtoi (v);
564  vi32 = CLAMP (vi32, -8388608, 8388607);
565  *i32++ = GUINT32_SWAP_LE_BE (vi32);
566  }
567  while (src < bound);
568  bse_fpu_restore (fpu);
569  return n_values * 4;
570  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER == G_BYTE_ORDER):
571  bse_fpu_setround (&fpu);
572  do
573  {
574  v = *src++;
575  v *= 2147483648.;
576  vi32 = bse_dtoi (v);
577  // vi32 = CLAMP (vi32, -2147483648, 2147483647);
578  *i32++ = vi32;
579  }
580  while (src < bound);
581  bse_fpu_restore (fpu);
582  return n_values * 4;
583  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER != G_BYTE_ORDER):
584  bse_fpu_setround (&fpu);
585  do
586  {
587  v = *src++;
588  v *= 2147483648.;
589  vi32 = bse_dtoi (v);
590  // vi32 = CLAMP (vi32, -2147483648, 2147483647);
591  *i32++ = GUINT32_SWAP_LE_BE (vi32);
592  }
593  while (src < bound);
594  bse_fpu_restore (fpu);
595  return n_values * 4;
596  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
597  return n_values << 2;
598  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
599  do
600  {
601  vu32 = *u32src++;
602  *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
603  }
604  while (u32src < u32bound);
605  return n_values << 2;
606  default:
607  g_assert_not_reached ();
608  return 0;
609  }
610 }
611 
612 #define GSL_ALAW_MAX (0x7e00)
613 static inline gint16
614 gsl_alaw_to_pcm (gint8 alawv)
615 {
616  static const short alaw2pcm_table[128] = {
617  0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280,
618  0x1d80, 0x1c80, 0x1f80, 0x1e80, 0x1980, 0x1880, 0x1b80, 0x1a80,
619  0x0ac0, 0x0a40, 0x0bc0, 0x0b40, 0x08c0, 0x0840, 0x09c0, 0x0940,
620  0x0ec0, 0x0e40, 0x0fc0, 0x0f40, 0x0cc0, 0x0c40, 0x0dc0, 0x0d40,
621  0x5600, 0x5200, 0x5e00, 0x5a00, 0x4600, 0x4200, 0x4e00, 0x4a00,
622  0x7600, 0x7200, 0x7e00, 0x7a00, 0x6600, 0x6200, 0x6e00, 0x6a00,
623  0x2b00, 0x2900, 0x2f00, 0x2d00, 0x2300, 0x2100, 0x2700, 0x2500,
624  0x3b00, 0x3900, 0x3f00, 0x3d00, 0x3300, 0x3100, 0x3700, 0x3500,
625  0x0158, 0x0148, 0x0178, 0x0168, 0x0118, 0x0108, 0x0138, 0x0128,
626  0x01d8, 0x01c8, 0x01f8, 0x01e8, 0x0198, 0x0188, 0x01b8, 0x01a8,
627  0x0058, 0x0048, 0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028,
628  0x00d8, 0x00c8, 0x00f8, 0x00e8, 0x0098, 0x0088, 0x00b8, 0x00a8,
629  0x0560, 0x0520, 0x05e0, 0x05a0, 0x0460, 0x0420, 0x04e0, 0x04a0,
630  0x0760, 0x0720, 0x07e0, 0x07a0, 0x0660, 0x0620, 0x06e0, 0x06a0,
631  0x02b0, 0x0290, 0x02f0, 0x02d0, 0x0230, 0x0210, 0x0270, 0x0250,
632  0x03b0, 0x0390, 0x03f0, 0x03d0, 0x0330, 0x0310, 0x0370, 0x0350,
633  };
634  return alawv < 0 ? alaw2pcm_table[128 + alawv] : -alaw2pcm_table[alawv];
635 }
636 
637 #define GSL_ULAW_MAX (0x7d7c)
638 static inline gint16
639 gsl_ulaw_to_pcm (gint8 ulawv)
640 {
641  static const short ulaw2pcm_table[128] = {
642  0x7d7c, 0x797c, 0x757c, 0x717c, 0x6d7c, 0x697c, 0x657c, 0x617c,
643  0x5d7c, 0x597c, 0x557c, 0x517c, 0x4d7c, 0x497c, 0x457c, 0x417c,
644  0x3e7c, 0x3c7c, 0x3a7c, 0x387c, 0x367c, 0x347c, 0x327c, 0x307c,
645  0x2e7c, 0x2c7c, 0x2a7c, 0x287c, 0x267c, 0x247c, 0x227c, 0x207c,
646  0x1efc, 0x1dfc, 0x1cfc, 0x1bfc, 0x1afc, 0x19fc, 0x18fc, 0x17fc,
647  0x16fc, 0x15fc, 0x14fc, 0x13fc, 0x12fc, 0x11fc, 0x10fc, 0x0ffc,
648  0x0f3c, 0x0ebc, 0x0e3c, 0x0dbc, 0x0d3c, 0x0cbc, 0x0c3c, 0x0bbc,
649  0x0b3c, 0x0abc, 0x0a3c, 0x09bc, 0x093c, 0x08bc, 0x083c, 0x07bc,
650  0x075c, 0x071c, 0x06dc, 0x069c, 0x065c, 0x061c, 0x05dc, 0x059c,
651  0x055c, 0x051c, 0x04dc, 0x049c, 0x045c, 0x041c, 0x03dc, 0x039c,
652  0x036c, 0x034c, 0x032c, 0x030c, 0x02ec, 0x02cc, 0x02ac, 0x028c,
653  0x026c, 0x024c, 0x022c, 0x020c, 0x01ec, 0x01cc, 0x01ac, 0x018c,
654  0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104,
655  0x00f4, 0x00e4, 0x00d4, 0x00c4, 0x00b4, 0x00a4, 0x0094, 0x0084,
656  0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040,
657  0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000,
658  };
659  return ulawv < 0 ? ulaw2pcm_table[128 + ulawv] : -ulaw2pcm_table[ulawv];
660 }
661 
662 static inline void
663 gsl_conv_to_float (GslWaveFormatType format,
664  guint byte_order,
665  gconstpointer src,
666  gfloat *dest,
667  guint n_values)
668 {
669  const guint8 *u8 = (guint8*) src;
670  const gint8 *i8 = (gint8*) src;
671  const guint16 *u16 = (guint16*) src;
672  const gint16 *i16 = (gint16*) src;
673  const gint32 *i32 = (gint32*) src;
674  const guint32 *u32src = (guint32*) src;
675  gfloat *bound = dest + n_values;
676  guint32 *u32dest = (guint32*) dest, *u32bound = (guint32*) bound;
677 
678  if (!n_values)
679  return;
680 
681  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
682  {
683  gint16 vi16;
684  guint16 vu16;
685  guint32 vu32;
686  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
687  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
688  do
689  *dest++ = (*u8++ - 128) * (1. / 128.);
690  while (dest < bound);
691  break;
692  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
693  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
694  do
695  *dest++ = *i8++ * (1. / 128.);
696  while (dest < bound);
697  break;
698  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_ALAW, G_BYTE_ORDER == G_BYTE_ORDER):
699  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_ALAW, G_BYTE_ORDER != G_BYTE_ORDER):
700  do
701  *dest++ = gsl_alaw_to_pcm (*i8++) * (1.0 / GSL_ALAW_MAX);
702  while (dest < bound);
703  break;
704  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_ULAW, G_BYTE_ORDER == G_BYTE_ORDER):
705  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_ULAW, G_BYTE_ORDER != G_BYTE_ORDER):
706  do
707  *dest++ = gsl_ulaw_to_pcm (*i8++) * (1.0 / GSL_ULAW_MAX);
708  while (dest < bound);
709  break;
710  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
711  do
712  *dest++ = ((*u16++ & 0x0fff) - 2048) * (1. / 2048.);
713  while (dest < bound);
714  break;
715  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
716  do
717  {
718  vu16 = *u16++;
719  *dest++ = ((GUINT16_SWAP_LE_BE (vu16) & 0x0fff) - 2048) * (1. / 2048.);
720  }
721  while (dest < bound);
722  break;
723  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
724  do
725  {
726  vi16 = *i16++;
727  *dest++ = CLAMP (vi16, -2048, 2048) * (1. / 2048.);
728  }
729  while (dest < bound);
730  break;
731  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
732  do
733  {
734  vi16 = *i16++;
735  vi16 = GUINT16_SWAP_LE_BE (vi16);
736  *dest++ = CLAMP (vi16, -2048, 2048) * (1. / 2048.);
737  }
738  while (dest < bound);
739  break;
740  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
741  do
742  *dest++ = (*u16++ - 32768) * (1. / 32768.);
743  while (dest < bound);
744  break;
745  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
746  do
747  {
748  vu16 = *u16++;
749  *dest++ = (GUINT16_SWAP_LE_BE (vu16) - 32768) * (1. / 32768.);
750  }
751  while (dest < bound);
752  break;
753  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
754  do
755  *dest++ = *i16++ * (1. / 32768.);
756  while (dest < bound);
757  break;
758  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
759  do
760  {
761  vi16 = *i16++;
762  *dest++ = GUINT16_SWAP_LE_BE (vi16) * (1. / 32768.);
763  }
764  while (dest < bound);
765  break;
766  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER == G_BYTE_ORDER):
767  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER != G_BYTE_ORDER):
768  if (byte_order == G_LITTLE_ENDIAN)
769  do
770  {
771  gint32 v32 = *u8++;
772  v32 |= *u8++ << 8;
773  v32 |= *((gint8*) u8) << 16;
774  u8++;
775  *dest++ = v32 * (1. / 8388608.);
776  }
777  while (dest < bound);
778  else /* G_BIG_ENDIAN */
779  do
780  {
781  gint32 v32 = *((gint8*) u8) << 16;
782  u8++;
783  v32 |= *u8++ << 8;
784  v32 |= *u8++;
785  *dest++ = v32 * (1. / 8388608.);
786  }
787  while (dest < bound);
788  break;
789  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER == G_BYTE_ORDER):
790  do
791  *dest++ = *i32++ * (1. / 8388608.);
792  while (dest < bound);
793  break;
794  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER != G_BYTE_ORDER):
795  do
796  {
797  gint32 vi32 = *i32++;
798  *dest++ = GUINT32_SWAP_LE_BE (vi32) * (1. / 8388608.);
799  }
800  while (dest < bound);
801  break;
802  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER == G_BYTE_ORDER):
803  do
804  *dest++ = *i32++ * (1. / 2147483648.);
805  while (dest < bound);
806  break;
807  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER != G_BYTE_ORDER):
808  do
809  {
810  gint32 vi32 = *i32++;
811  *dest++ = GUINT32_SWAP_LE_BE (vi32) * (1. / 2147483648.);
812  }
813  while (dest < bound);
814  break;
815  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
816  break;
817  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
818  do
819  {
820  vu32 = *u32src++;
821  *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
822  }
823  while (u32dest < u32bound);
824  break;
825  default:
826  g_assert_not_reached ();
827  }
828 }
829 
830 /* same as above with s/float/double */
831 static inline guint /* returns number of bytes used in dest */
832 gsl_conv_from_double (GslWaveFormatType format,
833  guint byte_order,
834  const gdouble *src,
835  gpointer dest,
836  guint n_values)
837 {
838  gint8 *i8 = (gint8*) dest;
839  guint8 *u8 = (guint8*) dest;
840  gint16 *i16 = (gint16*) dest;
841  guint16 *u16 = (guint16*) dest;
842  guint32 *u32dest = (guint32*) dest;
843  gint32 *i32 = (gint32*) dest;
844  const gdouble *bound = src + n_values;
845  const guint32 *u32src = (const guint32*) src, *u32bound = (const guint32*) bound;
846 
847  if (!n_values)
848  return 0;
849 
850  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
851  {
852  BseFpuState fpu;
853  gdouble v;
854  gint16 vi16;
855  guint16 vu16;
856  guint32 vu32;
857  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
858  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
859  do
860  *u8++ = bse_dtoi (*src++ * 128. + 128);
861  while (src < bound);
862  return n_values;
863  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
864  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
865  bse_fpu_setround (&fpu);
866  do
867  {
868  v = *src++;
869  v *= 128.;
870  *i8++ = bse_dtoi (v);
871  }
872  while (src < bound);
873  bse_fpu_restore (fpu);
874  return n_values;
875  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
876  do
877  *u16++ = bse_dtoi (*src++ * 2048. + 2048);
878  while (src < bound);
879  return n_values << 1;
880  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
881  do
882  {
883  vu16 = bse_dtoi (*src++ * 2048. + 2048);
884  *u16++ = GUINT16_SWAP_LE_BE (vu16);
885  }
886  while (src < bound);
887  return n_values << 1;
888  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
889  bse_fpu_setround (&fpu);
890  do
891  {
892  v = *src++;
893  v *= 2048.;
894  *i16++ = bse_dtoi (v);
895  }
896  while (src < bound);
897  bse_fpu_restore (fpu);
898  return n_values << 1;
899  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
900  bse_fpu_setround (&fpu);
901  do
902  {
903  v = *src++;
904  v *= 2048.;
905  vi16 = bse_dtoi (v);
906  *i16++ = GUINT16_SWAP_LE_BE (vi16);
907  }
908  while (src < bound);
909  bse_fpu_restore (fpu);
910  return n_values << 1;
911  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
912  do
913  *u16++ = bse_dtoi (*src++ * 32768. + 32768);
914  while (src < bound);
915  return n_values << 1;
916  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
917  do
918  {
919  vu16 = bse_dtoi (*src++ * 32768. + 32768);
920  *u16++ = GUINT16_SWAP_LE_BE (vu16);
921  }
922  while (src < bound);
923  return n_values << 1;
924  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
925  bse_fpu_setround (&fpu);
926  do
927  {
928  v = *src++;
929  v *= 32768.;
930  *i16++ = bse_dtoi (v);
931  }
932  while (src < bound);
933  bse_fpu_restore (fpu);
934  return n_values << 1;
935  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
936  bse_fpu_setround (&fpu);
937  do
938  {
939  v = *src++;
940  v *= 32768.;
941  vi16 = bse_dtoi (v);
942  *i16++ = GUINT16_SWAP_LE_BE (vi16);
943  }
944  while (src < bound);
945  bse_fpu_restore (fpu);
946  return n_values << 1;
947  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER == G_BYTE_ORDER):
948  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER != G_BYTE_ORDER):
949  bse_fpu_setround (&fpu);
950  if (byte_order == G_LITTLE_ENDIAN)
951  do
952  {
953  v = *src++;
954  v *= 8388608.;
955  gint32 vi32 = bse_dtoi (v);
956  *u8++ = vi32 >> 0;
957  *u8++ = vi32 >> 8;
958  *((gint8*) u8) = vi32 >> 16;
959  u8++;
960  }
961  while (src < bound);
962  else /* G_BIG_ENDIAN */
963  do
964  {
965  v = *src++;
966  v *= 8388608.;
967  gint32 vi32 = bse_dtoi (v);
968  *((gint8*) u8) = vi32 >> 16;
969  u8++;
970  *u8++ = vi32 >> 8;
971  *u8++ = vi32 >> 0;
972  }
973  while (src < bound);
974  bse_fpu_restore (fpu);
975  return n_values * 3;
976  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER == G_BYTE_ORDER):
977  bse_fpu_setround (&fpu);
978  do
979  {
980  v = *src++;
981  v *= 8388608.;
982  *i32++ = bse_dtoi (v);
983  }
984  while (src < bound);
985  bse_fpu_restore (fpu);
986  return n_values * 4;
987  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER != G_BYTE_ORDER):
988  bse_fpu_setround (&fpu);
989  do
990  {
991  v = *src++;
992  v *= 8388608.;
993  gint32 vi32 = bse_dtoi (v);
994  *i32++ = GUINT32_SWAP_LE_BE (vi32);
995  }
996  while (src < bound);
997  bse_fpu_restore (fpu);
998  return n_values * 4;
999  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER == G_BYTE_ORDER):
1000  bse_fpu_setround (&fpu);
1001  do
1002  {
1003  v = *src++;
1004  v *= 2147483648.;
1005  *i32++ = bse_dtoi (v);
1006  }
1007  while (src < bound);
1008  bse_fpu_restore (fpu);
1009  return n_values * 4;
1010  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER != G_BYTE_ORDER):
1011  bse_fpu_setround (&fpu);
1012  do
1013  {
1014  v = *src++;
1015  v *= 2147483648.;
1016  gint32 vi32 = bse_dtoi (v);
1017  *i32++ = GUINT32_SWAP_LE_BE (vi32);
1018  }
1019  while (src < bound);
1020  bse_fpu_restore (fpu);
1021  return n_values * 4;
1022  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
1023  return n_values << 2;
1024  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
1025  do
1026  {
1027  vu32 = *u32src++;
1028  *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
1029  }
1030  while (u32src < u32bound);
1031  return n_values << 2;
1032  default:
1033  g_assert_not_reached ();
1034  return 0;
1035  }
1036 }
1037 
1038 static inline guint /* returns number of bytes used in dest */
1039 gsl_conv_from_double_clip (GslWaveFormatType format,
1040  guint byte_order,
1041  const gdouble *src,
1042  gpointer dest,
1043  guint n_values)
1044 {
1045  gint8 *i8 = (gint8*) dest;
1046  guint8 *u8 = (guint8*) dest;
1047  gint16 *i16 = (gint16*) dest;
1048  guint16 *u16 = (guint16*) dest;
1049  guint32 *u32dest = (guint32*) dest;
1050  gint32 *i32 = (gint32*) dest;
1051  const gdouble *bound = src + n_values;
1052  const guint32 *u32src = (const guint32*) src, *u32bound = (const guint32*) bound;
1053 
1054  if (!n_values)
1055  return 0;
1056 
1057  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
1058  {
1059  BseFpuState fpu;
1060  gdouble v;
1061  guint32 vu32;
1062  gint32 vi32;
1063  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
1064  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
1065  do
1066  {
1067  vi32 = bse_dtoi (*src++ * 128. + 128);
1068  *u8++ = CLAMP (vi32, 0, 255);
1069  }
1070  while (src < bound);
1071  return n_values;
1072  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
1073  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
1074  bse_fpu_setround (&fpu);
1075  do
1076  {
1077  v = *src++;
1078  v *= 128.;
1079  vi32 = bse_dtoi (v);
1080  *i8++ = CLAMP (vi32, -128, 127);
1081  }
1082  while (src < bound);
1083  bse_fpu_restore (fpu);
1084  return n_values;
1085  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
1086  do
1087  {
1088  vi32 = bse_dtoi (*src++ * 2048. + 2048);
1089  *u16++ = CLAMP (vi32, 0, 4095);
1090  }
1091  while (src < bound);
1092  return n_values << 1;
1093  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
1094  do
1095  {
1096  vi32 = bse_dtoi (*src++ * 2048. + 2048);
1097  vi32 = CLAMP (vi32, 0, 4095);
1098  *u16++ = GUINT16_SWAP_LE_BE (vi32);
1099  }
1100  while (src < bound);
1101  return n_values << 1;
1102  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
1103  bse_fpu_setround (&fpu);
1104  do
1105  {
1106  v = *src++;
1107  v *= 2048.;
1108  vi32 = bse_dtoi (v);
1109  *i16++ = CLAMP (vi32, -2048, 2047);
1110  }
1111  while (src < bound);
1112  bse_fpu_restore (fpu);
1113  return n_values << 1;
1114  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
1115  bse_fpu_setround (&fpu);
1116  do
1117  {
1118  v = *src++;
1119  v *= 2048.;
1120  vi32 = bse_dtoi (v);
1121  vi32 = CLAMP (vi32, -2048, 2047);
1122  *i16++ = GUINT16_SWAP_LE_BE (vi32);
1123  }
1124  while (src < bound);
1125  bse_fpu_restore (fpu);
1126  return n_values << 1;
1127  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
1128  do
1129  {
1130  vi32 = bse_dtoi (*src++ * 32768. + 32768);
1131  *u16++ = CLAMP (vi32, 0, 65535);
1132  }
1133  while (src < bound);
1134  return n_values << 1;
1135  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
1136  do
1137  {
1138  vi32 = bse_dtoi (*src++ * 32768. + 32768);
1139  vi32 = CLAMP (vi32, 0, 65535);
1140  *u16++ = GUINT16_SWAP_LE_BE (vi32);
1141  }
1142  while (src < bound);
1143  return n_values << 1;
1144  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
1145  bse_fpu_setround (&fpu);
1146  do
1147  {
1148  v = *src++;
1149  v *= 32768.;
1150  vi32 = bse_dtoi (v);
1151  vi32 = CLAMP (vi32, -32768, 32767);
1152  *i16++ = vi32;
1153  }
1154  while (src < bound);
1155  bse_fpu_restore (fpu);
1156  return n_values << 1;
1157  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
1158  bse_fpu_setround (&fpu);
1159  do
1160  {
1161  v = *src++;
1162  v *= 32768.;
1163  vi32 = bse_dtoi (v);
1164  vi32 = CLAMP (vi32, -32768, 32767);
1165  *i16++ = GUINT16_SWAP_LE_BE (vi32);
1166  }
1167  while (src < bound);
1168  bse_fpu_restore (fpu);
1169  return n_values << 1;
1170  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER == G_BYTE_ORDER):
1171  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER != G_BYTE_ORDER):
1172  bse_fpu_setround (&fpu);
1173  if (byte_order == G_LITTLE_ENDIAN)
1174  do
1175  {
1176  v = *src++;
1177  v *= 8388608.;
1178  gint32 vi32 = bse_dtoi (v);
1179  vi32 = CLAMP (vi32, -8388608, 8388607);
1180  *u8++ = vi32 >> 0;
1181  *u8++ = vi32 >> 8;
1182  *((gint8*) u8) = vi32 >> 16;
1183  u8++;
1184  }
1185  while (src < bound);
1186  else /* G_BIG_ENDIAN */
1187  do
1188  {
1189  v = *src++;
1190  v *= 8388608.;
1191  gint32 vi32 = bse_dtoi (v);
1192  vi32 = CLAMP (vi32, -8388608, 8388607);
1193  *((gint8*) u8) = vi32 >> 16;
1194  u8++;
1195  *u8++ = vi32 >> 8;
1196  *u8++ = vi32 >> 0;
1197  }
1198  while (src < bound);
1199  bse_fpu_restore (fpu);
1200  return n_values * 3;
1201  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER == G_BYTE_ORDER):
1202  bse_fpu_setround (&fpu);
1203  do
1204  {
1205  v = *src++;
1206  v *= 8388608.;
1207  vi32 = bse_dtoi (v);
1208  vi32 = CLAMP (vi32, -8388608, 8388607);
1209  *i32++ = vi32;
1210  }
1211  while (src < bound);
1212  bse_fpu_restore (fpu);
1213  return n_values * 4;
1214  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER != G_BYTE_ORDER):
1215  bse_fpu_setround (&fpu);
1216  do
1217  {
1218  v = *src++;
1219  v *= 8388608.;
1220  vi32 = bse_dtoi (v);
1221  vi32 = CLAMP (vi32, -8388608, 8388607);
1222  *i32++ = GUINT32_SWAP_LE_BE (vi32);
1223  }
1224  while (src < bound);
1225  bse_fpu_restore (fpu);
1226  return n_values * 4;
1227  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER == G_BYTE_ORDER):
1228  bse_fpu_setround (&fpu);
1229  do
1230  {
1231  v = *src++;
1232  v *= 2147483648.;
1233  vi32 = bse_dtoi (v);
1234  // vi32 = CLAMP (vi32, -2147483648, 2147483647);
1235  *i32++ = vi32;
1236  }
1237  while (src < bound);
1238  bse_fpu_restore (fpu);
1239  return n_values * 4;
1240  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER != G_BYTE_ORDER):
1241  bse_fpu_setround (&fpu);
1242  do
1243  {
1244  v = *src++;
1245  v *= 2147483648.;
1246  vi32 = bse_dtoi (v);
1247  // vi32 = CLAMP (vi32, -2147483648, 2147483647);
1248  *i32++ = GUINT32_SWAP_LE_BE (vi32);
1249  }
1250  while (src < bound);
1251  bse_fpu_restore (fpu);
1252  return n_values * 4;
1253  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
1254  return n_values << 2;
1255  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
1256  do
1257  {
1258  vu32 = *u32src++;
1259  *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
1260  }
1261  while (u32src < u32bound);
1262  return n_values << 2;
1263  default:
1264  g_assert_not_reached ();
1265  return 0;
1266  }
1267 }
1268 
1269 static inline void
1270 gsl_conv_to_double (GslWaveFormatType format,
1271  guint byte_order,
1272  gconstpointer src,
1273  gdouble *dest,
1274  guint n_values)
1275 {
1276  const guint8 *u8 = (guint8*) src;
1277  const gint8 *i8 = (gint8*) src;
1278  const guint16 *u16 = (guint16*) src;
1279  const gint16 *i16 = (gint16*) src;
1280  const guint32 *u32src = (guint32*) src;
1281  const gint32 *i32 = (gint32*) src;
1282  gdouble *bound = dest + n_values;
1283  guint32 *u32dest = (guint32*) dest, *u32bound = (guint32*) bound;
1284 
1285  if (!n_values)
1286  return;
1287 
1288  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
1289  {
1290  gint16 vi16;
1291  guint16 vu16;
1292  guint32 vu32;
1293  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
1294  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
1295  do
1296  *dest++ = (*u8++ - 128) * (1. / 128.);
1297  while (dest < bound);
1298  break;
1299  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
1300  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
1301  do
1302  *dest++ = *i8++ * (1. / 128.);
1303  while (dest < bound);
1304  break;
1305  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_ALAW, G_BYTE_ORDER == G_BYTE_ORDER):
1306  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_ALAW, G_BYTE_ORDER != G_BYTE_ORDER):
1307  do
1308  *dest++ = gsl_alaw_to_pcm (*i8++) * (1.0 / GSL_ALAW_MAX);
1309  while (dest < bound);
1310  break;
1311  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_ULAW, G_BYTE_ORDER == G_BYTE_ORDER):
1312  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_ULAW, G_BYTE_ORDER != G_BYTE_ORDER):
1313  do
1314  *dest++ = gsl_ulaw_to_pcm (*i8++) * (1.0 / GSL_ULAW_MAX);
1315  while (dest < bound);
1316  break;
1317  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
1318  do
1319  *dest++ = ((*u16++ & 0x0fff) - 2048) * (1. / 2048.);
1320  while (dest < bound);
1321  break;
1322  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
1323  do
1324  {
1325  vu16 = *u16++;
1326  *dest++ = ((GUINT16_SWAP_LE_BE (vu16) & 0x0fff) - 2048) * (1. / 2048.);
1327  }
1328  while (dest < bound);
1329  break;
1330  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
1331  do
1332  {
1333  vi16 = *i16++;
1334  *dest++ = CLAMP (vi16, -2048, 2048) * (1. / 2048.);
1335  }
1336  while (dest < bound);
1337  break;
1338  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
1339  do
1340  {
1341  vi16 = *i16++;
1342  vi16 = GUINT16_SWAP_LE_BE (vi16);
1343  *dest++ = CLAMP (vi16, -2048, 2048) * (1. / 2048.);
1344  }
1345  while (dest < bound);
1346  break;
1347  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
1348  do
1349  *dest++ = (*u16++ - 32768) * (1. / 32768.);
1350  while (dest < bound);
1351  break;
1352  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
1353  do
1354  {
1355  vu16 = *u16++;
1356  *dest++ = (GUINT16_SWAP_LE_BE (vu16) - 32768) * (1. / 32768.);
1357  }
1358  while (dest < bound);
1359  break;
1360  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
1361  do
1362  *dest++ = *i16++ * (1. / 32768.);
1363  while (dest < bound);
1364  break;
1365  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
1366  do
1367  {
1368  vi16 = *i16++;
1369  *dest++ = GUINT16_SWAP_LE_BE (vi16) * (1. / 32768.);
1370  }
1371  while (dest < bound);
1372  break;
1373  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER == G_BYTE_ORDER):
1374  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24, G_BYTE_ORDER != G_BYTE_ORDER):
1375  if (byte_order == G_LITTLE_ENDIAN)
1376  do
1377  {
1378  gint32 v32 = *u8++;
1379  v32 |= *u8++ << 8;
1380  v32 |= *((gint8*) u8) << 16;
1381  u8++;
1382  *dest++ = v32 * (1. / 8388608.);
1383  }
1384  while (dest < bound);
1385  else /* G_BIG_ENDIAN */
1386  do
1387  {
1388  gint32 v32 = *((gint8*) u8) << 16;
1389  u8++;
1390  v32 |= *u8++ << 8;
1391  v32 |= *u8++;
1392  *dest++ = v32 * (1. / 8388608.);
1393  }
1394  while (dest < bound);
1395  break;
1396  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER == G_BYTE_ORDER):
1397  do
1398  *dest++ = *i32++ * (1. / 8388608.);
1399  while (dest < bound);
1400  break;
1401  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_24_PAD4, G_BYTE_ORDER != G_BYTE_ORDER):
1402  do
1403  {
1404  gint32 vi32 = *i32++;
1405  *dest++ = GUINT32_SWAP_LE_BE (vi32) * (1. / 8388608.);
1406  }
1407  while (dest < bound);
1408  break;
1409  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER == G_BYTE_ORDER):
1410  do
1411  *dest++ = *i32++ * (1. / 2147483648.);
1412  while (dest < bound);
1413  break;
1414  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_32, G_BYTE_ORDER != G_BYTE_ORDER):
1415  do
1416  {
1417  gint32 vi32 = *i32++;
1418  *dest++ = GUINT32_SWAP_LE_BE (vi32) * (1. / 2147483648.);
1419  }
1420  while (dest < bound);
1421  break;
1422  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
1423  break;
1424  case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
1425  do
1426  {
1427  vu32 = *u32src++;
1428  *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
1429  }
1430  while (u32dest < u32bound);
1431  break;
1432  default:
1433  g_assert_not_reached ();
1434  }
1435 }
1436 
1437 G_END_DECLS
1438 
1439 #endif /* __GSL_DATA_UTILS_H__ */
1440 
1441 /* vim:set ts=8 sts=2 sw=2: */
gfloat * gsl_data_make_fade_ramp(GslDataHandle *handle, GslLong min_pos, GslLong max_pos, GslLong *length_p)
Definition: gsldatautils.cc:700
Definition: gsldatautils.hh:141
Definition: gsldatautils.hh:12
Definition: gsldatautils.hh:19
BseErrorType gsl_data_clip_sample(GslDataHandle *dhandle, GslDataClipConfig *cconfig, GslDataClipResult *result)
Definition: gsldatautils.cc:755
Definition: sfistore.hh:14
GslLong gsl_data_find_block(GslDataHandle *handle, guint n_values, const gfloat *values, gfloat epsilon)
Definition: gsldatautils.cc:654
Definition: gsldatautils.hh:131