CS50 Problem Set 4#

1
// Modifies the volume of an audio file
2

3
#include <stdint.h>
4
#include <stdio.h>
5
#include <stdlib.h>
6

7
// Number of bytes in .wav header
8
const int HEADER_SIZE = 44;
9

10
int main(int argc, char *argv[])
11
{
12
    // Check command-line arguments
13
    if (argc != 4)
14
    {
15
        printf("Usage: ./volume input.wav output.wav factor\n");
16
        return 1;
17
    }
18

19
    // Open files and determine scaling factor
20
    FILE *input = fopen(argv[1], "r");
21
    if (input == NULL)
22
    {
23
        printf("Could not open file.\n");
24
        return 1;
25
    }
26

27
    FILE *output = fopen(argv[2], "w");
28
    if (output == NULL)
29
    {
30
        printf("Could not open file.\n");
31
        return 1;
32
    }
33

34
    float factor = atof(argv[3]);
35

36
    // TODO: Copy header from input file to output file
37
    uint8_t header[44];
38
    fread(&header, 44, 1, input);
39
    fwrite(&header, 44, 1, output);
40

41
    // TODO: Read samples from input file and write updated data to output file
42
    int16_t buffer;
43

44
    while (fread(&buffer, sizeof(int16_t), 1, input))
45
    {
46
        buffer *= factor;
47
        fwrite(&buffer, sizeof(int16_t), 1, output);
48
    }
49

50
    // Close files
51
    fclose(input);
52
    fclose(output);
53
}

1
#include "helpers.h"
2
#include <math.h>
3

4
// Convert image to grayscale
5
void grayscale(int height, int width, RGBTRIPLE image[height][width])
6
{
7
    int avg = 0;
8

9
    for (int i = 0; i < height; i++)
10
    {
11
        for (int j = 0; j < width; j++)
12
        {
13
            avg = (int) round((image[i][j].rgbtRed + image[i][j].rgbtGreen + image[i][j].rgbtBlue) /
14
                              3.0);
15

16
            image[i][j].rgbtRed = avg;
17
            image[i][j].rgbtGreen = avg;
18
            image[i][j].rgbtBlue = avg;
19
        }
20
    }
21
    return;
22
}
23

24
// Convert image to sepia
25
void sepia(int height, int width, RGBTRIPLE image[height][width])
26
{
27
    for (int i = 0; i < height; i++)
28
    {
29
        for (int j = 0; j < width; j++)
30
        {
31
            int sepiaRed = (int) round(.393 * image[i][j].rgbtRed + .769 * image[i][j].rgbtGreen +
32
                                       .189 * image[i][j].rgbtBlue);
33
            int sepiaGreen = (int) round(.349 * image[i][j].rgbtRed + .686 * image[i][j].rgbtGreen +
34
                                         .168 * image[i][j].rgbtBlue);
35
            int sepiaBlue = (int) round(.272 * image[i][j].rgbtRed + .534 * image[i][j].rgbtGreen +
36
                                        .131 * image[i][j].rgbtBlue);
37
            // sepiaRed = .393 * originalRed + .769 * originalGreen + .189 * originalBlue
38
            // sepiaGreen = .349 * originalRed + .686 * originalGreen + .168 * originalBlue
39
            // sepiaBlue = .272 * originalRed + .534 * originalGreen + .131 * originalBlue
40

41
            // Make sure that if the value of sepiaRed, sepiaGreen and sepiaBlue exceed 255, their
42
            // value will be capped at 255
43
            if (sepiaRed > 255)
44
            {
45
                sepiaRed = 255;
46
            }
47
            if (sepiaGreen > 255)
48
            {
49
                sepiaGreen = 255;
50
            }
51
            if (sepiaBlue > 255)
52
            {
53
                sepiaBlue = 255;
54
            }
55

56
            image[i][j].rgbtRed = sepiaRed;
57
            image[i][j].rgbtGreen = sepiaGreen;
58
            image[i][j].rgbtBlue = sepiaBlue;
59
        }
60
    }
61
    return;
62
}
63

64
// Reflect image horizontally
65
void reflect(int height, int width, RGBTRIPLE image[height][width])
66
{
67
    int temp_width = 0;
68
    RGBTRIPLE temp[height][width];
69

70
    if (width % 2 == 0)
71
    {
72
        temp_width = width / 2;
73
    }
74
    else
75
    {
76
        temp_width = (width + 1) / 2;
77
    }
78
    for (int i = 0; i < height; i++)
79
    {
80
        for (int j = 0; j < temp_width; j++)
81
        {
82
            // Swap pixels
83
            temp[i][j] = image[i][j];
84
            image[i][j] = image[i][width - 1 - j];
85
            image[i][width - 1 - j] = temp[i][j];
86
        }
87
    }
88
    return;
89
}
90

91
// Blur image
92
void blur(int height, int width, RGBTRIPLE image[height][width])
93
{
94
    // Create a copy of image
95
    RGBTRIPLE copy[height][width];
96
    for (int i = 0; i < height; i++)
97
    {
98
        for (int j = 0; j < width; j++)
99
        {
100
            int tempRed = 0, tempGreen = 0, tempBlue = 0;
101
            float pixel_count = 0;
102
            copy[i][j] = image[i][j];
103

104
            // get the average of the pixel RGB values
105
            for (int m = i - 1; m <= i + 1; m++)
106
            {
107
                for (int n = j - 1; n <= j + 1; n++)
108
                {
109
                    if (m >= 0 && m < height && n >= 0 &&
110
                        n < width) // avoiding the pixels that cross the edge
111
                    {
112
                        tempRed += image[m][n].rgbtRed;
113
                        tempGreen += image[m][n].rgbtGreen;
114
                        tempBlue += image[m][n].rgbtBlue;
115

116
                        pixel_count += 1;
117
                    }
118
                }
119
            }
120
            copy[i][j].rgbtRed = round(tempRed / pixel_count);
121
            copy[i][j].rgbtGreen = round(tempGreen / pixel_count);
122
            copy[i][j].rgbtBlue = round(tempBlue / pixel_count);
123
        }
124
    }
125

126
    // give the value of copy[i][j] back to image[i][j]
127
    for (int i = 0; i < height; i++)
128
    {
129
        for (int j = 0; j < width; j++)
130
        {
131
            image[i][j] = copy[i][j];
132
        }
133
    }
134
    return;
135
}

1
#include <stdint.h>
2
#include <stdio.h>
3
#include <stdlib.h>
4

5
int main(int argc, char *argv[])
6
{
7
    // Accept a single command-line argument
8
    if (argc != 2)
9
    {
10
        printf("Usage: ./recover FILE\n");
11
        return 1;
12
    }
13

14
    // Open the memory card
15
    FILE *card = fopen(argv[1], "r");
16

17
    // Create a buffer for a block of data
18
    uint8_t buffer[512];
19
    int counter = 0;
20
    int found_image = 1;
21
    FILE *img;
22
    char filename[8];
23
    // While there's still data left to read from the memory card
24
    while (fread(buffer, 1, 512, card) == 512)
25
    {
26
        // Create JPEGs from the data
27
        if (buffer[0] == 0xff && buffer[1] == 0xd8 && buffer[2] == 0xff &&
28
            (buffer[3] & 0xf0) == 0xe0)
29
        {
30
            found_image = 0;
31
        }
32

33
        if (found_image == 0)
34
        {
35
            if (counter != 0)
36
            {
37
                fclose(img);
38
            } // close the previous file and start a new file to write (except the first file)
39

40
            sprintf(filename, "%03i.jpg", counter);
41
            img = fopen(filename, "w");
42
            fwrite(buffer, 1, 512, img);
43
            counter += 1;
44
            found_image = 1;
45
        }
46
        else if (counter != 0)
47
        // the block does not contain the signature of jpg, so it will be continuously written into
48
        // the previously opened file if the first block does not contain the signature, it won't be
49
        // written to the image
50
        {
51
            fwrite(buffer, 1, 512, img);
52
        }
53
    }
54

55
    // there's nothing to write, so close all the files
56
    fclose(img);
57
    fclose(card);
58
}