Algorithme pour mixer le son

Vous devez les ajouter ensemble, mais le clip le résultat de la plage autorisée pour empêcher plus de/underflow.

Dans le cas de l'écrêtage produit, vous sera introduire de distorsion dans l'audio, mais qui est inévitable. Vous pouvez utiliser votre écrêtage de code de "détecter" de cette condition et de signaler à l'utilisateur/opérateur (l'équivalent de rouge 'clip' la lumière sur une table de mixage...)

Vous pourriez mettre en œuvre un "bon" d'un compresseur/limiteur, mais sans en connaître les dates exactes de votre application, il est difficile de dire si il vaudrait la peine.

Si vous êtes en train de faire beaucoup de traitement audio, vous pouvez représenter vos niveaux audio comme des valeurs à virgule flottante, et seulement revenir à la 16-bits de l'espace à la fin du processus. Audio numérique souvent, les systèmes fonctionnent de cette manière.

Il y a un article sur le mélange ici. Je serais intéressé de savoir ce que les autres pensent à ce sujet.

"Plus de la moitié" n'est pas tout à fait correct. En raison de l'oreille de la réponse logarithmique, en divisant les échantillons dans la moitié va faire 6 db plus silencieux - certainement sensible, mais pas catastrophique.

Vous pourriez vouloir faire des compromis en multipliant par 0,75. Qui va le faire à 3 db plus silencieux, mais va diminuer les chances de débordement et aussi de diminuer la distorsion quand ça arrive.

Vous pouvez aussi vous acheter une hauteur avec un algorithme de type y= 1.1 x 0,2 x^3 pour la courbe, et avec un chapeau sur le haut et le bas. J'ai utilisé ce dans Hexaphone lorsque le joueur est de jouer plusieurs notes en même ensemble (jusqu'à 6).

float waveshape_distort( float in ) {
  if(in <= -1.25f) {
    return -0.984375;
  } else if(in >= 1.25f) {
    return 0.984375;
  } else {    
    return 1.1f * in - 0.2f * in * in * in;
  }
}

Ce n'est pas à l'épreuve des balles - mais vous permettra d'obtenir jusqu'à 1,25 niveau, et adoucit le clip d'un jolie courbe. Produit de la distorsion harmonique, qui sonne mieux que le découpage et peut être souhaitable dans certaines circonstances.

Si vous avez besoin pour faire de ce droit, je suggère de regarder à l'open source logiciel de mixage implémentations, au moins pour la théorie.

Quelques liens:

Audacity

GStreamer

En fait, vous devriez probablement utiliser une bibliothèque.

Je pense que, tant que les volets ne sont pas corrélés, vous ne devriez pas avoir trop à s'inquiéter, vous devriez être en mesure de s'en sortir avec l'écrêtage. Si vous êtes vraiment préoccupé par la distorsion dans le clip de points, un soft limiteur serait probablement OK.

J'ai fait de cette façon une fois: j'ai utilisé de la flotte (échantillons entre -1 et 1), et j'ai initialisé un "autoGain" variable avec une valeur de 1. Ensuite, je voudrais ajouter tous les échantillons (peut également être plus que 2). Alors je voudrais multiplier le signal sortant avec autoGain. Si la valeur absolue de la somme des signaux avant la multiplication serait supérieur à 1, je voudrais faire attribuer 1/cette somme de la valeur. Cela permettrait effectivement de faire autogain inférieure à 1 disons 0,7 et serait l'équivalent de certains opérateur tourne rapidement vers le bas le volume principal dès qu'il voit que l'ensemble du son est trop fort. Alors je voudrais sur une période réglable de temps, ajouter de l'autogain jusqu'à ce que finalement il serait de retour à "1" (notre opérateur a récupéré d'un choc, et est lentement démarrage le volume :-)).

Depuis votre profil indique que vous travaillez dans les systèmes embarqués, je vais supposer que les opérations à virgule flottante ne sont pas toujours une option.

> So what's the correct method to add these sounds together in my software mixer?

Comme vous l'avez deviné, de l'ajout et de l'écrêtage est la bonne voie à suivre si vous ne voulez pas perdre de volume sur les sources. Avec des échantillons qui sont int16_t, vous avez besoin de la somme à int32_t, puis de les limiter et de les convertir en arrière pour int16_t.

> Am I wrong and the correct method is to lower the volume of each by half?

Oui. La réduction de moitié du volume est un peu subjectif, mais ce que vous pouvez voir ici et là, c'est que la réduction de moitié du volume (volume) est une diminution d'environ 10 dB (division de la puissance par 10, ou les valeurs de l'échantillon par 3.16). Mais tu veux dire, évidemment, à la baisse de la valeurs de l'échantillon de moitié. C'est une diminution de 6 dB, une réduction notable, mais pas autant que la réduction de moitié du volume (le volume de la table de il y est très utile).

Avec cette réduction de 6 dB vous permettra d'éviter tout écrêtage. Mais ce qui arrive quand vous voulez plus de canaux d'entrée? Pour quatre canaux, vous devez diviser les valeurs d'entrée par 4, c'est l'abaissement de 12 dB, ce qui va à moins que la moitié de l'intensité sonore de chaque canal.

> Do I need to add a compressor/limiter or some other processing stage to 
get the volume and mixing effect I'm trying for?

Vous voulez mélanger, pas de clip, et ne pas perdre de l'intensité sonore sur les signaux d'entrée. Ce n'est pas possible, non sans une sorte de distorsion.

Comme suggéré par la Marque de Rançon, une solution pour éviter l'écrêtage tout en ne perdant pas autant de 6 dB par canal est de frapper quelque part entre les deux "ajout et clipping" et "moyenne".

Qui est de deux sources: l'ajout, en divisant par quelque part entre 1 et 2 (réduction de la gamme de [-65536, 65534] à quelque chose de plus petit), puis de les limiter.

Si vous souvent de la pince, avec cette solution, et il semble trop sévère, alors vous voudrez peut adoucir la limite du genou avec un compresseur. C'est un peu plus complexe, car vous avez besoin de faire le facteur de division dépend de la puissance d'entrée. Essayez le limiteur seule tout d'abord, et de considérer le compresseur uniquement si vous n'êtes pas heureux avec le résultat.

J'ai trouvé une nouvelle façon d'ajouter des échantillons de manière à ce qu'ils ne peuvent jamais dépasser un intervalle donné. L'Idée de base est de convertir des valeurs dans une plage allant de -1 à 1 à une plage comprise entre environ -l'Infini à +l'Infini, ajouter le tout et l'inverse de la première transformation. Je suis venu avec les formules suivantes pour ce:

Je l'ai essayé et il fonctionne, mais pour de multiples sons forts l'audio semble pire que simplement en ajoutant l'ensemble des échantillons, et le découpage de chaque valeur qui est trop grand. J'ai utilisé le code suivant pour tester ceci:

#include <math.h>
#include <stdio.h>
#include <float.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include <sndfile.h>

//fabs wasn't accurate enough
long double ldabs(long double x){
  return x < 0 ? -x : x;
}

//-Inf<input<+Inf, -1<=output<=+1
long double infiniteToFinite( long double sample ){
  //if the input value was too big, we'll just map it to -1 or 1
  if( isinf(sample) )
    return sample < 0 ? -1. : 1.;
  long double ret = sample /( ldabs(sample) + 1 );
  //Just in case of calculation errors
  if( isnan(ret) )
    ret = sample < 0 ? -1. : 1.;
  if( ret < -1. )
    ret = -1.;
  if( ret > 1. )
    ret = 1.;
  return ret;
}

//-1<=input<=+1, -Inf<output<+Inf
long double finiteToInfinite( long double sample ){
  //if out of range, clamp to 1 or -1
  if( sample > 1. )
    sample = 1.;
  if( sample < -1. )
    sample = -1.;
  long double res = -( sample /( ldabs(sample) - 1. ) );
  //sample was too close to 1 or -1, return largest long double
  if( isinf(res) )
    return sample < 0 ? -LDBL_MAX : LDBL_MAX;
  return res;
}

//-1<input<1, -1<=output<=1 | Try to avoid input values too close to 1 or -1
long double addSamples( size_t count, long double sample[] ){
  long double sum = 0;
  while( count-- ){
    sum += finiteToInfinite( sample[count] );
    if( isinf(sum) )
      sum = sum < 0 ? -LDBL_MAX : LDBL_MAX;
  }
  return infiniteToFinite( sum );
}

#define BUFFER_LEN 256

int main( int argc, char* argv[] ){

  if( argc < 3 ){
    fprintf(stderr,"Usage: %s output.wav input1.wav [input2.wav...]\n",*argv);
    return 1;
  }

  {
    SNDFILE *outfile, *infiles[argc-2];
    SF_INFO sfinfo;
    SF_INFO sfinfo_tmp;

    memset( &sfinfo, 0, sizeof(sfinfo) );

    for( int i=0; i<argc-2; i++ ){
      memset( &sfinfo_tmp, 0, sizeof(sfinfo_tmp) );
      if(!( infiles[i] = sf_open( argv[i+2], SFM_READ, &sfinfo_tmp ) )){
        fprintf(stderr,"Could not open file: %s\n",argv[i+2]);
        puts(sf_strerror(0));
        goto cleanup;
      }
      printf("Sample rate %d, channel count %d\n",sfinfo_tmp.samplerate,sfinfo_tmp.channels);
      if( i ){
        if( sfinfo_tmp.samplerate != sfinfo.samplerate
         || sfinfo_tmp.channels != sfinfo.channels
        ){
          fprintf(stderr,"Mismatching sample rate or channel count\n");
          goto cleanup;
        }
      }else{
        sfinfo = sfinfo_tmp;
      }
      continue;
      cleanup: {
        while(i--)
          sf_close(infiles[i]);
        return 2;
      }
    }

    if(!( outfile = sf_open(argv[1], SFM_WRITE, &sfinfo) )){
      fprintf(stderr,"Could not open file: %s\n",argv[1]);
      puts(sf_strerror(0));
      for( int i=0; i<argc-2; i++ )
        sf_close(infiles[i]);
      return 3;
    }

    double inbuffer[argc-2][BUFFER_LEN];
    double outbuffer[BUFFER_LEN];

    size_t max_read;
    do {
      max_read = 0;
      memset(outbuffer,0,BUFFER_LEN*sizeof(double));
      for( int i=0; i<argc-2; i++ ){
        memset( inbuffer[i], 0, BUFFER_LEN*sizeof(double) );
        size_t read_count = sf_read_double( infiles[i], inbuffer[i], BUFFER_LEN );
        if( read_count > max_read )
          max_read = read_count;
      }
      long double insamples[argc-2];
      for( size_t j=0; j<max_read; j++ ){
        for( int i=0; i<argc-2; i++ )
          insamples[i] = inbuffer[i][j];
        outbuffer[j] = addSamples( argc-2, insamples );
      }
      sf_write_double( outfile, outbuffer, max_read );
    } while( max_read );

    sf_close(outfile);
    for( int i=0; i<argc-2; i++ )
      sf_close(infiles[i]);
  }

  return 0;
}

Cette question est ancienne mais ici, c'est la validité de la méthode de l'OMI.

1. Convertir à la fois l'échantillon au pouvoir.
2. Ajouter à la fois l'échantillon au pouvoir.
3. La normaliser. Comme la valeur maximale ne pas dépasser votre limite.
4. Reconvertir en amplitude.

Vous pouvez faire les 2 premières étapes, mais avec le maximum et le minimum de normaliser dans une deuxième passe pour l'étape 3 et 4.

J'espère que cela aide quelqu'un.