How do I write a wav file in C?

I'm trying to write a wav file in C but the file is not recognized by audacity or vlc.

I know that some of the header data is big endian and I'm not sure how to determine that when writing a binary file in C. I think this is probably the issue.

I'm going off of these sites:
https://www.videoproc.com/resource/wav-file.htm,
https://docs.fileformat.com/audio/wav/

The current code doesn't have any errors but the wav file it creates isn't recognized.

wav specs:
16bit,
96kHz,
2 channel

// Writes data to wav file
    FILE *fp = fopen("output/video_signal.wav", "w");
    if (fp == NULL)
    {
        printf("Output file couldn't be opened!\n");
        return 4;
    }
    int16_t byte;
    uint32_t length = 160+(4800*frame_count);
    float multiplier = 32767 / sync_level; // scales signal to use full 16bit resolution

    //// WAVE Header Data

    unsigned char riff[] = {'R', 'I', 'F', 'F'};
    fwrite(&riff, 1, 4, fp);

    uint32_t file_size = length + 44;
    fwrite(&file_size, 4, 1, fp); // Overall file size

    unsigned char wave[] = {'W', 'A', 'V', 'E'};
    fwrite(&wave, 1, 4, fp);

    unsigned char fmt[] = {'f', 'm', 't'}; // ?
    fwrite(&fmt, 1, 4, fp);

    uint32_t fmt_length = 16;  // ?
    fwrite(&fmt_length, 4, 1, fp);

    uint16_t fmt_type = 1; // 1 = PCM
    fwrite(&fmt_type, 2, 1, fp);

    uint16_t chan_num = 2; // Number of channels
    fwrite(&chan_num, 2, 1, fp);

    uint32_t rate = 96000; // Sample rate
    fwrite(&rate, 4, 1, fp);

    uint32_t funny_number = rate * 16 * chan_num; // (Sample Rate * BitsPerSample * Channels) / 8
    fwrite(&funny_number, 4, 1, fp);

    uint16_t another_format = 4; // 4 = 16bit stereo
    fwrite(&another_format, 2, 1, fp);

    uint16_t bits = 16; // Bit depth / Bits per sample
    fwrite(&bits, 2, 1, fp);

    unsigned char data_start[] = {'d', 'a', 't', 'a'}; // Marks the start of the data
    fwrite(&data_start, 1, 4, fp);

    fwrite(&length, 4, 1, fp); // Data size

    for (int i = 0; i < length; i++)
    {
        byte = (channel1[i] * multiplier);
        fwrite(&byte, 2, 1, fp);
        byte = (channel2[i] * multiplier);
        fwrite(&byte, 2, 1, fp);
    }

    fclose(fp);

Here is a modified version of your code that generates one second of white noise:

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

int main()
{
    uint32_t duration = 1;
    uint32_t rate = 96000;  // Sample rate
    uint32_t frame_count = duration * rate;
    uint16_t chan_num = 2;  // Number of channels
    uint16_t bits = 16;  // Bit depth
    uint32_t length = frame_count*chan_num*bits / 8;
    int16_t byte;
    float sync_level = 1.0;
    // scales signal to use full 16bit resolution
    float multiplier = 32767 / sync_level;


    float *channel1 = (float *) malloc(frame_count * sizeof(float));
    float *channel2 = (float *) malloc(frame_count * sizeof(float));
    for (uint32_t i=0; i < frame_count; i++) {
        channel1[i] = (float) (rand() - RAND_MAX / 2) / RAND_MAX;
        channel2[i] = (float) (rand() - RAND_MAX / 2) / RAND_MAX;
    }

    // Writes data to wav file
    FILE *fp = fopen("video_signal.wav", "w");
    if (fp == NULL)
    {
        printf("Output file couldn't be opened!\n");
        return 4;
    }

    //// WAVE Header Data
    fwrite("RIFF", 1, 4, fp);
    uint32_t chunk_size = length + 44 - 8;
    fwrite(&chunk_size, 4, 1, fp);
    fwrite("WAVE", 1, 4, fp);
    fwrite("fmt ", 1, 4, fp);
    uint32_t subchunk1_size = 16;
    fwrite(&subchunk1_size, 4, 1, fp);
    uint16_t fmt_type = 1;  // 1 = PCM
    fwrite(&fmt_type, 2, 1, fp);
    fwrite(&chan_num, 2, 1, fp);
    fwrite(&rate, 4, 1, fp);
    // (Sample Rate * BitsPerSample * Channels) / 8
    uint32_t byte_rate = rate * bits * chan_num / 8;
    fwrite(&byte_rate, 4, 1, fp);
    uint16_t block_align = chan_num * bits / 8;
    fwrite(&block_align, 2, 1, fp);
    fwrite(&bits, 2, 1, fp);

    // Marks the start of the data
    fwrite("data", 1, 4, fp);
    fwrite(&length, 4, 1, fp);  // Data size
    for (uint32_t i = 0; i < frame_count; i++)
    {
        byte = (channel1[i] * multiplier);
        fwrite(&byte, 2, 1, fp);
        byte = (channel2[i] * multiplier);
        fwrite(&byte, 2, 1, fp);
    }

    fclose(fp);
    free(channel1);
    free(channel2);
    return 0;
}

There were a few problems in your code:

• the funny number was missing dividing by 8
• the "fmt " mark was missing the space at the end
• the length calculation didn't correspond to the data size