Svenska ElektronikForumet

Kod: Markera allt

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

#define PATH "C:\\Documents and Settings\\Admin\\Mina dokument\\Avancerat\\ekg\\"
#define INFIL "ekg_raw.wav"
#define UTFIL "ekg_filt.wav"

    #define FILT 4
    #define RATE 600 // sampels per sekund
    #define DIV (8000/RATE)

// ************* denna struct innehåller alla data i headern från "infil" ************
struct wavefil {
    int Riff;               // 4 bytes  "RIFF"
    int ChunkSize;          // 4 bytes  bytes (36 + SubChunk2Size)
    int Format;             // 4 bytes  "WAVE"
    int SubChunk1ID;        // 4 bytes  "fmt "
    int SubChunk1Size;      // 4 bytes  16 for PCM
    short int AudioFormat;  // 2 bytes  PCM = 1 (i.e. Linear quantization)
    short int NumCHannels;  // 2 bytes  Mono = 1, Stereo = 2, etc.
    int SampleRate;         // 4 bytes  8000, 44100, etc.
    int ByteRate;           // 4 bytes  == SampleRate * NumChannels * BitsPerSample/8
    short int BlockAlign;   // 2 bytes  == NumChannels * BitsPerSample/8
    short int BitsPerSample;// 2 bytes   (8 / 16) BitsPerSample
    int Subchunk2ID;        // 4 bytes  "data"
    int Subchunk2Size;      // 4 bytes  number of bytes in the data.
} wav;


FILE *infil, *utfil;

int main() {
    printf("wave-file-resample test\n");

// ************ Öppna wave-filen för läsning ***********
    if ((infil = fopen(PATH INFIL, "rb")) == NULL) {
        printf ("File OPEN error: ");
        printf( PATH INFIL );
        return 0;
    }

    printf("\n----- " INFIL " laeses in ------\n");

    // *********** read wave header

    fread(&wav, sizeof(wav), 1, infil);

    // ************ skriv ut lite information om filen *********
    printf("\n============================================");
    printf("\nRIFF 46464952\t %x", wav.Riff);
    printf("\nChunksize\t %i", wav.ChunkSize);
    printf("\nFormat   \t %x", wav.Format);
    printf("\nSubChunk1ID\t %i", wav.SubChunk1ID);
    printf("\nSubChunk1Size\t %i", wav.SubChunk1Size);
    printf("\nAudioFormat\t %i", wav.AudioFormat);
    printf("\nNumCHannels\t %i", wav.NumCHannels);
    printf("\nSampleRate\t %i", wav.SampleRate);
    printf("\nByteRate\t %i", wav.ByteRate);
    printf("\nBlockAlign\t %i", wav.BlockAlign);
    printf("\nBitsPerSample\t %i", wav.BitsPerSample);
    printf("\nSubchunk2ID\t %i", wav.Subchunk2ID);
    printf("\nSubchunk2Size\t %i", wav.Subchunk2Size);
    printf("\n============================================\n");

// ************ beräkna tid i sekunder och  antal samplingar totalt ***********
    float total_time = wav.Subchunk2Size * 1.0 / wav.ByteRate;
    int ant_samples = wav.Subchunk2Size / wav.BlockAlign;
    printf("Total time %f sec\n", total_time);
    printf("Antal samples %i\n", ant_samples);


    //-------------------öppna utfil--------------------------//
    if ((utfil = fopen(PATH UTFIL, "wb")) == NULL) {
        printf ("Utfil OPEN error: ");
        printf( PATH UTFIL );
        return 0;
    }
        // skapa wave header *** fusk: kopierar bara infilens header ****
    fwrite(&wav, sizeof(wav), 1, utfil);
    printf("\n----- " UTFIL " skapades --------\n");

// ************* variabler för statistik och filtrering ****************
    int i, maxs,maxf,mins,minf;
    maxs = 0;
    maxf = 0;
    mins = 0;
    minf = 0;
    short int sample = 0;
    short int utsamp = 0;
    int antal_utsamp = 0;
    int filter = 0;
    int filter2 = 0;
    int filter3 = 0;
    int summa = 0;

// ******** loop: läs in ett antal samples och räkna ut medelvärdet === downsampling ******
    for (i = 0; i < ant_samples / DIV; i++) {
        int j;
        summa = 0;
        for (j=0; j< DIV; j++) {
            sample = 0;
            fread(&sample, wav.BlockAlign , 1, infil); // läser in ett sample
            summa += sample;
        }
        summa = summa / DIV; // ** medelvärdet

// ********* spara sampel i utfilen ***********
// ** spara i fyra kanaler:
// ** kanal 1: ofiltrerat - "original-ljud" fast nedsamplat
// ** kanal 2: fitrerat grad 1
// ** kanal 3: fitrerat grad 2
// ** kanal 4: fitrerat grad 3

        fwrite(&summa, wav.BlockAlign , 1, utfil); // kanal 1 original
        antal_utsamp++;

        filter = (filter * (FILT-1) / FILT) + summa;
        utsamp = filter / (FILT) ; // invertera

        fwrite(&utsamp, wav.BlockAlign , 1, utfil); // kanal 2 1:a ordningen
        antal_utsamp++;

        filter2 = (filter2 * (FILT-1) / FILT) + filter / FILT;
        utsamp = filter2 / (FILT) ; // invertera

        fwrite(&utsamp, wav.BlockAlign , 1, utfil); // kanal 3 2:a ordningen
        antal_utsamp++;

        filter3 = (filter3 * (FILT-1) / FILT) + filter2 / FILT;
        utsamp = filter3 / (FILT) ; // invertera

        fwrite(&utsamp, wav.BlockAlign , 1, utfil); // kanal 4 3:e ordningen
        antal_utsamp++;

        if ((i & 127) == 0) printf("block %i\t\t\r", (i >> 7)); // skriv ut i konsolen hur långt jag kommit
    }
    printf("\n");
    int antal_bytes = antal_utsamp * wav.BlockAlign;
    /* ******* tänkte rätta till utfil-headern i efterhand, men det blev fel nånstans
         ****** så det blir bortkommenterat just nu
    fseek(utfil, +4, SEEK_SET); // flytta till ChunkSize
    fwrite(&antal_bytes+36, 4 , 1, utfil); // antal totalt
    fseek(utfil, +36, SEEK_SET); // flytta till ChunkSize
    fwrite(&antal_bytes, 4 , 1, utfil); // antal data */

    fclose(infil);
    fclose(utfil);
    printf("\nklart!");
    return 0;
}

Kod: Markera allt

20        2   AudioFormat      PCM = 1 (i.e. Linear quantization)
                               Values other than 1 indicate some 
                               form of compression.

Kod: Markera allt

#include <stdio.h>

int main(void)
{
   unsigned char buf;
   int bytes = 0;

   FILE *f = fopen("fil.wav","r");

   printf("unsigned char sound[MISSING] = {\n");
   while(!feof(f))
   {
      fread(&buf, 1,1, f);
      printf("%d,\n", buf);
      bytes++;
   }
   fclose(f);

   printf("};\n\n");

   printf("Fyll i detta innanför []:arna längst upp: %d\n", bytes);
   return 0;
}

}