cinelerra/audioidevice.C

   1 #include "audiodevice.h"
   2 #include "condition.h"
   3 #include "dcoffset.h"
   4 #include "bcprogressbox.h"
   5
   6
   7 int AudioDevice::set_record_dither(int bits)
   8 {
   9         rec_dither = bits;
  10         return 0;
  11 }
  12
  13
  14 int AudioDevice::get_dc_offset(int *output, RecordGUIDCOffsetText **dc_offset_text)
  15 {
  16         dc_offset_thread->calibrate_dc_offset(output, dc_offset_text, get_ichannels());
  17         return 0;
  18 }
  19
  20 int AudioDevice::set_dc_offset(int dc_offset, int channel)
  21 {
  22         dc_offset_thread->dc_offset[channel] = dc_offset;
  23         return 0;
  24 }
  25
  26 #define GET_PEAK_MACRO \
  27                                         input_channel[j] = sample;                          \
  28                                         if(sample > max[i]) max[i] = sample;           \
  29                                         else if(-sample > max[i]) max[i] = -sample;
  30
  31 // ============================ use 2 macros to allow for getting dc_offset
  32 // ============= must check for overload after dc_offset because of byte wrapping on save
  33
  34 #define GET_8BIT_SAMPLE_MACRO1 \
  35 sample = input_buffer[k];      \
  36 sample -= dc_offset_value;        \
  37 k += input_channels;           \
  38 if(sample >= max_sample[i]) { sample = max_sample[i]; if(over_count < 3) over_count++; } \
  39 else                           \
  40 if(sample <= min_sample[i]) { sample = min_sample[i]; if(over_count < 3) over_count++; } \
  41 else                           \
  42 if(over_count < 3) over_count = 0;
  43
  44 #define GET_8BIT_SAMPLE_MACRO2 \
  45 sample /= 0x7f;
  46
  47
  48
  49 #define GET_16BIT_SAMPLE_MACRO1                            \
  50 sample = input_buffer_16[k];                               \
  51 if(dither_scale) { dither_value = rand() % dither_scale; sample -= dither_value; } \
  52 sample -= dc_offset_value;                                    \
  53 k += input_channels;                                       \
  54 if(sample >= max_sample[i]) { sample = max_sample[i]; if(over_count < 3) over_count++; } \
  55 else                                                       \
  56 if(sample <= min_sample[i]) { sample = min_sample[i]; if(over_count < 3) over_count++; } \
  57 else                                                       \
  58 if(over_count < 3) over_count = 0;                         \
  59
  60 #define GET_16BIT_SAMPLE_MACRO2                            \
  61 sample /= 0x7fff;
  62
  63
  64
  65 #define GET_24BIT_SAMPLE_MACRO1 \
  66 sample = (unsigned char)input_buffer[k] | \
  67                         (((unsigned char)input_buffer[k + 1]) << 8) | \
  68                         (((int)input_buffer[k + 2]) << 16); \
  69 sample -= dc_offset_value; \
  70 k += input_channels * 3; \
  71 if(sample >= max_sample[i]) { sample = max_sample[i]; if(over_count < 3) over_count++; } \
  72 else                                                 \
  73 if(sample <= min_sample[i]) { sample = min_sample[i]; if(over_count < 3) over_count++; } \
  74 else                                                 \
  75 if(over_count < 3) over_count = 0;
  76
  77 #define GET_24BIT_SAMPLE_MACRO2       \
  78 sample /= 0x7fffff;
  79
  80
  81
  82 #define GET_32BIT_SAMPLE_MACRO1 \
  83 sample = (unsigned char)input_buffer[k] | \
  84                         (((unsigned char)input_buffer[k + 1]) << 8) | \
  85                         (((unsigned char)input_buffer[k + 2]) << 16) | \
  86                         (((int)input_buffer[k + 3]) << 24); \
  87 sample -= dc_offset_value; \
  88 k += input_channels * 4; \
  89 if(sample >= max_sample[i]) { sample = max_sample[i]; if(over_count < 3) over_count++; } \
  90 else \
  91 if(sample <= min_sample[i]) { sample = min_sample[i]; if(over_count < 3) over_count++; } \
  92 else \
  93 if(over_count < 3) over_count = 0;
  94
  95 #define GET_32BIT_SAMPLE_MACRO2       \
  96 sample /= 0x7fffffff;
  97
  98 int AudioDevice::read_buffer(double **input,
  99         int samples,
 100         int channels,
 101         int *over,
 102         double *max,
 103         int input_offset)
 104 {
 105         int i, j, k, frame, bits;
 106         double sample, denominator;
 107         double min_sample[MAXCHANNELS], max_sample[MAXCHANNELS];
 108         int sample_int;
 109         int over_count;
 110         int dither_value, dither_scale;
 111         int input_channels;
 112         int result = 0;
 113         double *input_channel;
 114         int *dc_offset_total;
 115         int dc_offset_value;
 116
 117         is_recording = 1;
 118         record_timer.update();
 119
 120         bits = get_ibits();
 121         input_channels = get_ichannels();
 122         frame = input_channels * bits / 8;
 123
 124         dither_scale = 0;
 125         total_samples_read += samples;
 126
 127         switch(bits)
 128         {
 129                 case 8:
 130                         denominator = 0x7f;
 131                         break;
 132                 case 16:
 133                         denominator = 0x7fff;
 134                         if(rec_dither == 8)
 135                         {
 136                                 dither_scale = 255;
 137                         }
 138                         break;
 139                 case 24:
 140                         denominator = 0x7fffff;
 141                         if(rec_dither == 8)
 142                         {
 143                                 dither_scale = 65535;
 144                         }
 145                         else
 146                         if (rec_dither == 16)
 147                         {
 148                                 dither_scale = 255;
 149                         }
 150                         break;
 151                 case 32:
 152                         denominator = 0x7fffffff;
 153                         dither_scale = 0;
 154                         break;
 155         }
 156
 157         if(input_buffer == 0) input_buffer = new char[samples * frame];
 158
 159         if(duplex_init && !record_before_play)
 160         {
 161 // block until playback starts
 162                 duplex_lock->lock("AudioDevice::read_buffer");
 163                 duplex_init = 0;
 164         }
 165
 166         result = get_lowlevel_in()->read_buffer(input_buffer, samples * frame);
 167
 168 // allow playback to start
 169         if(duplex_init && record_before_play)
 170         {
 171                 duplex_lock->unlock();
 172                 duplex_init = 0;
 173         }
 174
 175
 176         if(result < 0)
 177         {
 178                 perror("AudioDevice::read_buffer");
 179                 sleep(1);
 180         }
 181
 182         for(i = 0; i < channels && i < get_ichannels(); i++)
 183         {
 184                 input_channel = &input[i][input_offset];
 185                 dc_offset_value = dc_offset_thread->dc_offset[i];
 186
 187 // calculate minimum and maximum samples
 188                 if(dc_offset_thread->dc_offset[i] <= 0)
 189                 {
 190                         min_sample[i] = -denominator - dc_offset_thread->dc_offset[i];
 191                         max_sample[i] = denominator;
 192                 }
 193                 else
 194                 {
 195                         min_sample[i] = -denominator;
 196                         max_sample[i] = denominator - dc_offset_thread->dc_offset[i];
 197                 }
 198                 max[i] = 0;
 199                 over_count = 0;
 200
 201 // device is set to little endian
 202                 switch(bits)
 203                 {
 204                         case 8:
 205                                 if(dc_offset_thread->getting_dc_offset)
 206                                 {
 207                                         dc_offset_total = &(dc_offset_thread->dc_offset_total[i]);
 208                                         for(j = 0, k = i; j < samples; j++)
 209                                         {
 210                                                 GET_8BIT_SAMPLE_MACRO1
 211                                                 (*dc_offset_total) += (int)sample;
 212                                                 GET_8BIT_SAMPLE_MACRO2
 213                                                 GET_PEAK_MACRO
 214                                         }
 215                                 }
 216                                 else
 217                                 {
 218                                         for(j = 0, k = i; j < samples; j++)
 219                                         {
 220                                                 GET_8BIT_SAMPLE_MACRO1
 221                                                 GET_8BIT_SAMPLE_MACRO2
 222                                                 GET_PEAK_MACRO
 223                                         }
 224                                 }
 225                                 break;
 226
 227                         case 16:
 228                                 {
 229                                         int16_t *input_buffer_16;
 230                                         input_buffer_16 = (int16_t *)input_buffer;
 231                                         dc_offset_total = &(dc_offset_thread->dc_offset_total[i]);
 232
 233                                         if(dc_offset_thread->getting_dc_offset)
 234                                         {
 235                                                 for(j = 0, k = i; j < samples; j++)
 236                                                 {
 237                                                         GET_16BIT_SAMPLE_MACRO1
 238                                                         (*dc_offset_total) += (int)sample;
 239                                                         GET_16BIT_SAMPLE_MACRO2
 240                                                         GET_PEAK_MACRO
 241                                                 }
 242                                         }
 243                                         else
 244                                         {
 245                                                 for(j = 0, k = i; j < samples; j++)
 246                                                 {
 247                                                         GET_16BIT_SAMPLE_MACRO1
 248                                                         GET_16BIT_SAMPLE_MACRO2
 249                                                         GET_PEAK_MACRO
 250                                                 }
 251                                         }
 252                                 }
 253                                 break;
 254
 255                         case 24:
 256                                 {
 257                                         dc_offset_total = &(dc_offset_thread->dc_offset_total[i]);
 258
 259                                         if(dc_offset_thread->getting_dc_offset)
 260                                         {
 261                                                 for(j = 0, k = i * 3; j < samples; j++)
 262                                                 {
 263                                                         GET_24BIT_SAMPLE_MACRO1
 264                                                         (*dc_offset_total) += (int)sample;
 265                                                         GET_24BIT_SAMPLE_MACRO2
 266                                                         GET_PEAK_MACRO
 267                                                 }
 268                                         }
 269                                         else
 270                                         {
 271                                                 for(j = 0, k = i * 3; j < samples; j++)
 272                                                 {
 273                                                         GET_24BIT_SAMPLE_MACRO1
 274                                                         GET_24BIT_SAMPLE_MACRO2
 275                                                         GET_PEAK_MACRO
 276                                                 }
 277                                         }
 278                                 }
 279
 280                         case 32:
 281                                 {
 282                                         dc_offset_total = &(dc_offset_thread->dc_offset_total[i]);
 283
 284                                         if(dc_offset_thread->getting_dc_offset)
 285                                         {
 286                                                 for(j = 0, k = i * 4; j < samples; j++)
 287                                                 {
 288                                                         GET_32BIT_SAMPLE_MACRO1
 289                                                         (*dc_offset_total) += (int)sample;
 290                                                         GET_32BIT_SAMPLE_MACRO2
 291                                                         GET_PEAK_MACRO
 292                                                 }
 293                                         }
 294                                         else
 295                                         {
 296                                                 for(j = 0, k = i * 4; j < samples; j++)
 297                                                 {
 298                                                         GET_32BIT_SAMPLE_MACRO1
 299                                                         GET_32BIT_SAMPLE_MACRO2
 300                                                         GET_PEAK_MACRO
 301                                                 }
 302                                         }
 303                                 }
 304                                 break;
 305                 }
 306                 if(over_count >= 3) over[i] = 1; else over[i] = 0;
 307         }
 308
 309         if(dc_offset_thread->getting_dc_offset)
 310         {
 311                 dc_offset_thread->dc_offset_count += samples * channels;
 312                 if(dc_offset_thread->progress->update(dc_offset_thread->dc_offset_count, 1))
 313                 {
 314                         dc_offset_thread->getting_dc_offset = 0;
 315                         dc_offset_thread->dc_offset_lock->unlock();
 316                 }
 317                 else
 318                 if(dc_offset_thread->dc_offset_count > 256000)
 319                 {
 320                         for(i = 0; i < get_ichannels(); i++)
 321                         {
 322                                 dc_offset_thread->dc_offset[i] = dc_offset_thread->dc_offset_total[i] / dc_offset_thread->dc_offset_count * 2; // don't know why * 2
 323                         }
 324                         dc_offset_thread->getting_dc_offset = 0;
 325                         dc_offset_thread->dc_offset_lock->unlock();
 326                 }
 327         }
 328         return result < 0;
 329 }