A (not complete) template for writing convolution algorithms in C.

t_wav.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char wav_struct[] = {
  'R', 'I', 'F', 'F',
   0,   0,   0,   0,  /* chunksize */
  'W', 'A', 'V', 'E',
  'f', 'm', 't', ' ', /* subchunk1id */
   16,  0,   0,   0,  /* subchunk1size */
   1,   0,            /* audioformat */
   1,   0,            /* numchannels */
   68,  172, 0,   0,  /* samplerate 44100 */
   136, 88,  1,   0,  /* byterare 88200 */
   2,   0,            /* blockalign */
   16,  0,            /* bitspersample */
  'd', 'a', 't', 'a', /* subchunk2id */
   0,   0,   0,   0   /* subchunk2size */

};

int main(int argc, char *argv[]){
   if (argc < 2){
      fprintf(stderr, "usage: %s [wavfile]\n", argv[0]);
      return 1;
   }

   FILE *fpin = fopen(argv[1], "rb");
   if (!fpin){
      fprintf(stderr, "%s: No such file or directory\n", argv[1]);
      return 1;
   }

   char data_tag[4];
   fseek(fpin, 36, SEEK_SET);
   do {
      fread(data_tag, sizeof(char), 4, fpin);
      if (!strncmp(data_tag, "data", 4)) break;
      fseek(fpin, -3, SEEK_CUR);
   } while (1);

   uint32_t subchunk2size;
   uint32_t numsamples;
   fread(&subchunk2size, sizeof(uint32_t), 1, fpin);
   numsamples = (subchunk2size << 1);

   int16_t *pcm_in = malloc(sizeof(int16_t)*numsamples);
   if (pcm_in == NULL){
      fprintf(stderr, "Allocating failed\n");
      return 1;
   }

   fread(pcm_in, sizeof(int16_t), numsamples, fpin);
   fclose(fpin);

   FILE *fpout = fopen("write.wav", "wb");
   if (fpout == NULL) {
      fprintf(stderr, "Couldn't create write.wav\n");
      return 1;
   }

   fwrite(wav_struct, sizeof(wav_struct), 1, fpout);

   int16_t s_front = 0;
   int16_t s_prev = 0;
   int16_t s_temp = 0;

   for (int i = 0; i < numsamples; i++){
      //s_front = pcm_in[(i == numsamples-1)? 0: i+1];
      s_temp =
#if 0
               pcm_in[(i-20 < 0)? 0: i-20]/21 +
               pcm_in[(i-19 < 0)? 0: i-19]/21 +
               pcm_in[(i-18 < 0)? 0: i-18]/21 +
               pcm_in[(i-17 < 0)? 0: i-17]/21 +
               pcm_in[(i-16 < 0)? 0: i-16]/21 +
               pcm_in[(i-15 < 0)? 0: i-15]/21 +
               pcm_in[(i-14 < 0)? 0: i-14]/21 +
               pcm_in[(i-13 < 0)? 0: i-13]/21 +
               pcm_in[(i-12 < 0)? 0: i-12]/21 +
               pcm_in[(i-11 < 0)? 0: i-11]/21 +
               pcm_in[(i-10 < 0)? 0: i-10]/21 +
               pcm_in[(i-9 < 0)? 0: i-9]/21 +
               pcm_in[(i-8 < 0)? 0: i-8]/21 +
               pcm_in[(i-7 < 0)? 0: i-7]/21 +
               pcm_in[(i-6 < 0)? 0: i-6]/21 +
               pcm_in[(i-5 < 0)? 0: i-5]/21 +
               pcm_in[(i-4 < 0)? 0: i-4]/21 +
               pcm_in[(i-3 < 0)? 0: i-3]/21 +
#endif
               pcm_in[(i-2 < 0)? 0: i-2]/3 +
               pcm_in[(i-1 < 0)? 0: i-1]/3 +
               pcm_in[i]/3;
#if 0
               pcm_in[(i+1 > numsamples)? 0: i+1]/2 +
               pcm_in[(i+2 > numsamples)? 0: i+2]/2 +
               pcm_in[(i+3 > numsamples)? 0: i+3]/2 +
               pcm_in[(i+4 > numsamples)? 0: i+4]/2 +
               pcm_in[(i+5 > numsamples)? 0: i+5]/2 +
               pcm_in[(i+6 > numsamples)? 0: i+6]/2 +
               pcm_in[(i+7 > numsamples)? 0: i+7]/40 +
               pcm_in[(i+8 > numsamples)? 0: i+8]/40 +
               pcm_in[(i+9 > numsamples)? 0: i+9]/40 +
               pcm_in[(i+10 > numsamples)? 0: i+10]/40 +
               pcm_in[(i+11 > numsamples)? 0: i+11]/40 +
               pcm_in[(i+12 > numsamples)? 0: i+12]/40 +
               pcm_in[(i+13 > numsamples)? 0: i+13]/40 +
               pcm_in[(i+14 > numsamples)? 0: i+14]/40 +
               pcm_in[(i+15 > numsamples)? 0: i+15]/40 +
               pcm_in[(i+16 > numsamples)? 0: i+16]/40 +
               pcm_in[(i+17 > numsamples)? 0: i+17]/40 +
               pcm_in[(i+18 > numsamples)? 0: i+18]/40 +
               pcm_in[(i+19 > numsamples)? 0: i+19]/40 +
               pcm_in[(i+20 > numsamples)? 0: i+20]/40;
#endif
      //s_temp = pcm_in[i];
      fwrite(&s_temp, sizeof(int16_t), 1, fpout);
   }


   uint32_t length = 32+subchunk2size;
   fseek(fpout, 4, SEEK_SET);
   fwrite(&length, sizeof(uint32_t), 1, fpout);

   fseek(fpout, 40, SEEK_SET);
   fwrite(&subchunk2size, sizeof(uint32_t), 1, fpout);

   fclose(fpout);

   free(pcm_in);
   return 0;

}