intern/audaspace/intern/AUD_ConverterFunctions.cpp

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * Copyright 2009-2011 Jörg Hermann Müller
   7  *
   8  * This file is part of AudaSpace.
   9  *
  10  * Audaspace is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * AudaSpace is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with Audaspace; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  23  *
  24  * ***** END GPL LICENSE BLOCK *****
  25  */
  26
  27 /** \file audaspace/intern/AUD_ConverterFunctions.cpp
  28  *  \ingroup audaspaceintern
  29  */
  30
  31
  32 #include "AUD_ConverterFunctions.h"
  33 #include "AUD_Buffer.h"
  34
  35 #define AUD_U8_0                0x80
  36 #define AUD_S16_MAX             0x7FFF
  37 #define AUD_S16_MIN             0x8000
  38 #define AUD_S16_FLT             32768.0f
  39 #define AUD_S32_MAX             0x7FFFFFFF
  40 #define AUD_S32_MIN             0x80000000
  41 #define AUD_S32_FLT             2147483648.0f
  42 #define AUD_FLT_MAX             1.0f
  43 #define AUD_FLT_MIN             -1.0f
  44
  45 void AUD_convert_u8_s16(data_t* target, data_t* source, int length)
  46 {
  47         int16_t* t = (int16_t*) target;
  48         for(int i = length - 1; i >= 0; i--)
  49                 t[i] = (((int16_t)source[i]) - AUD_U8_0) << 8;
  50 }
  51
  52 void AUD_convert_u8_s24_be(data_t* target, data_t* source, int length)
  53 {
  54         for(int i = length - 1; i >= 0; i--)
  55         {
  56                 target[i*3] = source[i] - AUD_U8_0;
  57                 target[i*3+1] = 0;
  58                 target[i*3+2] = 0;
  59         }
  60 }
  61
  62 void AUD_convert_u8_s24_le(data_t* target, data_t* source, int length)
  63 {
  64         for(int i = length - 1; i >= 0; i--)
  65         {
  66                 target[i*3+2] = source[i] - AUD_U8_0;
  67                 target[i*3+1] = 0;
  68                 target[i*3] = 0;
  69         }
  70 }
  71
  72 void AUD_convert_u8_s32(data_t* target, data_t* source, int length)
  73 {
  74         int32_t* t = (int32_t*) target;
  75         for(int i = length - 1; i >= 0; i--)
  76                 t[i] = (((int32_t)source[i]) - AUD_U8_0) << 24;
  77 }
  78
  79 void AUD_convert_u8_float(data_t* target, data_t* source, int length)
  80 {
  81         float* t = (float*) target;
  82         for(int i = length - 1; i >= 0; i--)
  83                 t[i] = (((int32_t)source[i]) - AUD_U8_0) / ((float)AUD_U8_0);
  84 }
  85
  86 void AUD_convert_u8_double(data_t* target, data_t* source, int length)
  87 {
  88         double* t = (double*) target;
  89         for(int i = length - 1; i >= 0; i--)
  90                 t[i] = (((int32_t)source[i]) - AUD_U8_0) / ((double)AUD_U8_0);
  91 }
  92
  93 void AUD_convert_s16_u8(data_t* target, data_t* source, int length)
  94 {
  95         int16_t* s = (int16_t*) source;
  96         for(int i = 0; i < length; i++)
  97                 target[i] = (unsigned char)((s[i] >> 8) + AUD_U8_0);
  98 }
  99
 100 void AUD_convert_s16_s24_be(data_t* target, data_t* source, int length)
 101 {
 102         int16_t* s = (int16_t*) source;
 103         int16_t t;
 104         for(int i = length - 1; i >= 0; i--)
 105         {
 106                 t = s[i];
 107                 target[i*3] = t >> 8 & 0xFF;
 108                 target[i*3+1] = t & 0xFF;
 109                 target[i*3+2] = 0;
 110         }
 111 }
 112
 113 void AUD_convert_s16_s24_le(data_t* target, data_t* source, int length)
 114 {
 115         int16_t* s = (int16_t*) source;
 116         int16_t t;
 117         for(int i = length - 1; i >= 0; i--)
 118         {
 119                 t = s[i];
 120                 target[i*3+2] = t >> 8 & 0xFF;
 121                 target[i*3+1] = t & 0xFF;
 122                 target[i*3] = 0;
 123         }
 124 }
 125
 126 void AUD_convert_s16_s32(data_t* target, data_t* source, int length)
 127 {
 128         int16_t* s = (int16_t*) source;
 129         int32_t* t = (int32_t*) target;
 130         for(int i = length - 1; i >= 0; i--)
 131                 t[i] = ((int32_t)s[i]) << 16;
 132 }
 133
 134 void AUD_convert_s16_float(data_t* target, data_t* source, int length)
 135 {
 136         int16_t* s = (int16_t*) source;
 137         float* t = (float*) target;
 138         for(int i = length - 1; i >= 0; i--)
 139                 t[i] = s[i] / AUD_S16_FLT;
 140 }
 141
 142 void AUD_convert_s16_double(data_t* target, data_t* source, int length)
 143 {
 144         int16_t* s = (int16_t*) source;
 145         double* t = (double*) target;
 146         for(int i = length - 1; i >= 0; i--)
 147                 t[i] = s[i] / AUD_S16_FLT;
 148 }
 149
 150 void AUD_convert_s24_u8_be(data_t* target, data_t* source, int length)
 151 {
 152         for(int i = 0; i < length; i++)
 153                 target[i] = source[i*3] ^ AUD_U8_0;
 154 }
 155
 156 void AUD_convert_s24_u8_le(data_t* target, data_t* source, int length)
 157 {
 158         for(int i = 0; i < length; i++)
 159                 target[i] = source[i*3+2] ^ AUD_U8_0;
 160 }
 161
 162 void AUD_convert_s24_s16_be(data_t* target, data_t* source, int length)
 163 {
 164         int16_t* t = (int16_t*) target;
 165         for(int i = 0; i < length; i++)
 166                 t[i] = source[i*3] << 8 | source[i*3+1];
 167 }
 168
 169 void AUD_convert_s24_s16_le(data_t* target, data_t* source, int length)
 170 {
 171         int16_t* t = (int16_t*) target;
 172         for(int i = 0; i < length; i++)
 173                 t[i] = source[i*3+2] << 8 | source[i*3+1];
 174 }
 175
 176 void AUD_convert_s24_s24(data_t* target, data_t* source, int length)
 177 {
 178         memcpy(target, source, length * 3);
 179 }
 180
 181 void AUD_convert_s24_s32_be(data_t* target, data_t* source, int length)
 182 {
 183         int32_t* t = (int32_t*) target;
 184         for(int i = length - 1; i >= 0; i--)
 185                 t[i] = source[i*3] << 24 | source[i*3+1] << 16 | source[i*3+2] << 8;
 186 }
 187
 188 void AUD_convert_s24_s32_le(data_t* target, data_t* source, int length)
 189 {
 190         int32_t* t = (int32_t*) target;
 191         for(int i = length - 1; i >= 0; i--)
 192                 t[i] = source[i*3+2] << 24 | source[i*3+1] << 16 | source[i*3] << 8;
 193 }
 194
 195 void AUD_convert_s24_float_be(data_t* target, data_t* source, int length)
 196 {
 197         float* t = (float*) target;
 198         int32_t s;
 199         for(int i = length - 1; i >= 0; i--)
 200         {
 201                 s = source[i*3] << 24 | source[i*3+1] << 16 | source[i*3+2] << 8;
 202                 t[i] = s / AUD_S32_FLT;
 203         }
 204 }
 205
 206 void AUD_convert_s24_float_le(data_t* target, data_t* source, int length)
 207 {
 208         float* t = (float*) target;
 209         int32_t s;
 210         for(int i = length - 1; i >= 0; i--)
 211         {
 212                 s = source[i*3+2] << 24 | source[i*3+1] << 16 | source[i*3] << 8;
 213                 t[i] = s / AUD_S32_FLT;
 214         }
 215 }
 216
 217 void AUD_convert_s24_double_be(data_t* target, data_t* source, int length)
 218 {
 219         double* t = (double*) target;
 220         int32_t s;
 221         for(int i = length - 1; i >= 0; i--)
 222         {
 223                 s = source[i*3] << 24 | source[i*3+1] << 16 | source[i*3+2] << 8;
 224                 t[i] = s / AUD_S32_FLT;
 225         }
 226 }
 227
 228 void AUD_convert_s24_double_le(data_t* target, data_t* source, int length)
 229 {
 230         double* t = (double*) target;
 231         int32_t s;
 232         for(int i = length - 1; i >= 0; i--)
 233         {
 234                 s = source[i*3+2] << 24 | source[i*3+1] << 16 | source[i*3] << 8;
 235                 t[i] = s / AUD_S32_FLT;
 236         }
 237 }
 238
 239 void AUD_convert_s32_u8(data_t* target, data_t* source, int length)
 240 {
 241         int16_t* s = (int16_t*) source;
 242         for(int i = 0; i < length; i++)
 243                 target[i] = (unsigned char)((s[i] >> 24) + AUD_U8_0);
 244 }
 245
 246 void AUD_convert_s32_s16(data_t* target, data_t* source, int length)
 247 {
 248         int16_t* t = (int16_t*) target;
 249         int32_t* s = (int32_t*) source;
 250         for(int i = 0; i < length; i++)
 251                 t[i] = s[i] >> 16;
 252 }
 253
 254 void AUD_convert_s32_s24_be(data_t* target, data_t* source, int length)
 255 {
 256         int32_t* s = (int32_t*) source;
 257         int32_t t;
 258         for(int i = 0; i < length; i++)
 259         {
 260                 t = s[i];
 261                 target[i*3] = t >> 24 & 0xFF;
 262                 target[i*3+1] = t >> 16 & 0xFF;
 263                 target[i*3+2] = t >> 8 & 0xFF;
 264         }
 265 }
 266
 267 void AUD_convert_s32_s24_le(data_t* target, data_t* source, int length)
 268 {
 269         int32_t* s = (int32_t*) source;
 270         int32_t t;
 271         for(int i = 0; i < length; i++)
 272         {
 273                 t = s[i];
 274                 target[i*3+2] = t >> 24 & 0xFF;
 275                 target[i*3+1] = t >> 16 & 0xFF;
 276                 target[i*3] = t >> 8 & 0xFF;
 277         }
 278 }
 279
 280 void AUD_convert_s32_float(data_t* target, data_t* source, int length)
 281 {
 282         int32_t* s = (int32_t*) source;
 283         float* t = (float*) target;
 284         for(int i = 0; i < length; i++)
 285                 t[i] = s[i] / AUD_S32_FLT;
 286 }
 287
 288 void AUD_convert_s32_double(data_t* target, data_t* source, int length)
 289 {
 290         int32_t* s = (int32_t*) source;
 291         double* t = (double*) target;
 292         for(int i = length - 1; i >= 0; i--)
 293                 t[i] = s[i] / AUD_S32_FLT;
 294 }
 295
 296 void AUD_convert_float_u8(data_t* target, data_t* source, int length)
 297 {
 298         float* s = (float*) source;
 299         float t;
 300         for(int i = 0; i < length; i++)
 301         {
 302                 t = s[i] + AUD_FLT_MAX;
 303                 if(t <= 0.0f)
 304                         target[i] = 0;
 305                 else if(t >= 2.0f)
 306                         target[i] = 255;
 307                 else
 308                         target[i] = (unsigned char)(t*127);
 309         }
 310 }
 311
 312 void AUD_convert_float_s16(data_t* target, data_t* source, int length)
 313 {
 314         int16_t* t = (int16_t*) target;
 315         float* s = (float*) source;
 316         for(int i = 0; i < length; i++)
 317         {
 318                 if(s[i] <= AUD_FLT_MIN)
 319                         t[i] = AUD_S16_MIN;
 320                 else if(s[i] >= AUD_FLT_MAX)
 321                         t[i] = AUD_S16_MAX;
 322                 else
 323                         t[i] = (int16_t)(s[i] * AUD_S16_MAX);
 324         }
 325 }
 326
 327 void AUD_convert_float_s24_be(data_t* target, data_t* source, int length)
 328 {
 329         int32_t t;
 330         float* s = (float*) source;
 331         for(int i = 0; i < length; i++)
 332         {
 333                 if(s[i] <= AUD_FLT_MIN)
 334                         t = AUD_S32_MIN;
 335                 else if(s[i] >= AUD_FLT_MAX)
 336                         t = AUD_S32_MAX;
 337                 else
 338                         t = (int32_t)(s[i]*AUD_S32_MAX);
 339                 target[i*3] = t >> 24 & 0xFF;
 340                 target[i*3+1] = t >> 16 & 0xFF;
 341                 target[i*3+2] = t >> 8 & 0xFF;
 342         }
 343 }
 344
 345 void AUD_convert_float_s24_le(data_t* target, data_t* source, int length)
 346 {
 347         int32_t t;
 348         float* s = (float*) source;
 349         for(int i = 0; i < length; i++)
 350         {
 351                 if(s[i] <= AUD_FLT_MIN)
 352                         t = AUD_S32_MIN;
 353                 else if(s[i] >= AUD_FLT_MAX)
 354                         t = AUD_S32_MAX;
 355                 else
 356                         t = (int32_t)(s[i]*AUD_S32_MAX);
 357                 target[i*3+2] = t >> 24 & 0xFF;
 358                 target[i*3+1] = t >> 16 & 0xFF;
 359                 target[i*3] = t >> 8 & 0xFF;
 360         }
 361 }
 362
 363 void AUD_convert_float_s32(data_t* target, data_t* source, int length)
 364 {
 365         int32_t* t = (int32_t*) target;
 366         float* s = (float*) source;
 367         for(int i = 0; i < length; i++)
 368         {
 369                 if(s[i] <= AUD_FLT_MIN)
 370                         t[i] = AUD_S32_MIN;
 371                 else if(s[i] >= AUD_FLT_MAX)
 372                         t[i] = AUD_S32_MAX;
 373                 else
 374                         t[i] = (int32_t)(s[i]*AUD_S32_MAX);
 375         }
 376 }
 377
 378 void AUD_convert_float_double(data_t* target, data_t* source, int length)
 379 {
 380         float* s = (float*) source;
 381         double* t = (double*) target;
 382         for(int i = length - 1; i >= 0; i++)
 383                 t[i] = s[i];
 384 }
 385
 386 void AUD_convert_double_u8(data_t* target, data_t* source, int length)
 387 {
 388         double* s = (double*) source;
 389         double t;
 390         for(int i = 0; i < length; i++)
 391         {
 392                 t = s[i] + AUD_FLT_MAX;
 393                 if(t <= 0.0)
 394                         target[i] = 0;
 395                 else if(t >= 2.0)
 396                         target[i] = 255;
 397                 else
 398                         target[i] = (unsigned char)(t*127);
 399         }
 400 }
 401
 402 void AUD_convert_double_s16(data_t* target, data_t* source, int length)
 403 {
 404         int16_t* t = (int16_t*) target;
 405         double* s = (double*) source;
 406         for(int i = 0; i < length; i++)
 407         {
 408                 if(s[i] <= AUD_FLT_MIN)
 409                         t[i] = AUD_S16_MIN;
 410                 else if(s[i] >= AUD_FLT_MAX)
 411                         t[i] = AUD_S16_MAX;
 412                 else
 413                         t[i] = (int16_t)(s[i]*AUD_S16_MAX);
 414         }
 415 }
 416
 417 void AUD_convert_double_s24_be(data_t* target, data_t* source, int length)
 418 {
 419         int32_t t;
 420         double* s = (double*) source;
 421         for(int i = 0; i < length; i++)
 422         {
 423                 if(s[i] <= AUD_FLT_MIN)
 424                         t = AUD_S32_MIN;
 425                 else if(s[i] >= AUD_FLT_MAX)
 426                         t = AUD_S32_MAX;
 427                 else
 428                         t = (int32_t)(s[i]*AUD_S32_MAX);
 429                 target[i*3] = t >> 24 & 0xFF;
 430                 target[i*3+1] = t >> 16 & 0xFF;
 431                 target[i*3+2] = t >> 8 & 0xFF;
 432         }
 433 }
 434
 435 void AUD_convert_double_s24_le(data_t* target, data_t* source, int length)
 436 {
 437         int32_t t;
 438         double* s = (double*) source;
 439         for(int i = 0; i < length; i++)
 440         {
 441                 if(s[i] <= AUD_FLT_MIN)
 442                         t = AUD_S32_MIN;
 443                 else if(s[i] >= AUD_FLT_MAX)
 444                         t = AUD_S32_MAX;
 445                 else
 446                         t = (int32_t)(s[i]*AUD_S32_MAX);
 447                 target[i*3+2] = t >> 24 & 0xFF;
 448                 target[i*3+1] = t >> 16 & 0xFF;
 449                 target[i*3] = t >> 8 & 0xFF;
 450         }
 451 }
 452
 453 void AUD_convert_double_s32(data_t* target, data_t* source, int length)
 454 {
 455         int32_t* t = (int32_t*) target;
 456         double* s = (double*) source;
 457         for(int i = 0; i < length; i++)
 458         {
 459                 if(s[i] <= AUD_FLT_MIN)
 460                         t[i] = AUD_S32_MIN;
 461                 else if(s[i] >= AUD_FLT_MAX)
 462                         t[i] = AUD_S32_MAX;
 463                 else
 464                         t[i] = (int32_t)(s[i]*AUD_S32_MAX);
 465         }
 466 }
 467
 468 void AUD_convert_double_float(data_t* target, data_t* source, int length)
 469 {
 470         double* s = (double*) source;
 471         float* t = (float*) target;
 472         for(int i = 0; i < length; i++)
 473                 t[i] = s[i];
 474 }