如何仅用系统调用在C语言中合并P6格式PPM图像文件？

Alright, let's solve this problem using only the low-level system calls you mentioned. Since we're dealing with binary PPM (P6) files, we need to handle their structure carefully—no fancy image libraries allowed! Here's a step-by-step breakdown and implementation:

First, let's recap the binary PPM format to make sure we're on the same page:

• Starts with the magic number P6 (followed by whitespace)
• Then the image width, height, and maximum color value (usually 255), each separated by whitespace
• After the header, there's raw binary data: each pixel is 3 consecutive bytes (R, G, B), stored row-by-row from top-left to bottom-right

Our goal is to place the small image in the top-right corner of the large image. Here's the plan:

1. Open all three files (large input, small input, output) using open()
2. Parse the headers of both images to get their width, height, and confirm they're valid P6 files
3. Validate that the small image fits (its width ≤ large width, height ≤ large height—otherwise we can't place it in the corner)
4. Copy the large image's header to the output file (since the output will have the same dimensions as the large image)
5. Copy the entire large image's pixel data to the output file first
6. Use lseek() to jump to the correct positions in the output file and overwrite the top-right region with the small image's pixel data

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

// Helper function to parse P6 PPM header, skipping comments
int parse_ppm_header(int fd, int *width, int *height, int *max_val) {
    char buf[256];
    int bytes_read;
    int state = 0; // 0: looking for P6, 1: width, 2: height, 3: max_val

    while (state < 4) {
        // Read one byte at a time to handle whitespace and comments
        if ((bytes_read = read(fd, buf, 1)) != 1) {
            return -1; // Error or unexpected EOF
        }

        // Skip whitespace
        if (*buf == ' ' || *buf == '\n' || *buf == '\t' || *buf == '\r') {
            continue;
        }

        // Skip comments (lines starting with #)
        if (*buf == '#') {
            while (read(fd, buf, 1) == 1 && *buf != '\n');
            continue;
        }

        // Now read the actual values
        if (state == 0) {
            // Check magic number P6
            char magic[3];
            magic[0] = *buf;
            if (read(fd, magic+1, 2) != 2 || strncmp(magic, "P6\n", 3) != 0) {
                return -1; // Not a P6 PPM
            }
            state = 1;
        } else if (state == 1) {
            // Read width
            int w = 0;
            while (*buf >= '0' && *buf <= '9') {
                w = w * 10 + (*buf - '0');
                if (read(fd, buf, 1) != 1) break;
            }
            *width = w;
            state = 2;
        } else if (state == 2) {
            // Read height
            int h = 0;
            while (*buf >= '0' && *buf <= '9') {
                h = h * 10 + (*buf - '0');
                if (read(fd, buf, 1) != 1) break;
            }
            *height = h;
            state = 3;
        } else if (state == 3) {
            // Read max value
            int mv = 0;
            while (*buf >= '0' && *buf <= '9') {
                mv = mv * 10 + (*buf - '0');
                if (read(fd, buf, 1) != 1) break;
            }
            *max_val = mv;
            state = 4;
        }
    }

    // After header, there's one final whitespace to skip
    while (read(fd, buf, 1) == 1 && (*buf == ' ' || *buf == '\n' || *buf == '\t' || *buf == '\r'));
    // Seek back one byte since we read past the last whitespace
    lseek(fd, -1, SEEK_CUR);

    return 0;
}

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "Usage: %s <large_ppm> <small_ppm> <output_ppm>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    int fd_large = open(argv[1], O_RDONLY);
    int fd_small = open(argv[2], O_RDONLY);
    int fd_out = open(argv[3], O_WRONLY | O_CREAT | O_TRUNC, 0644);

    if (fd_large == -1 || fd_small == -1 || fd_out == -1) {
        perror("Failed to open files");
        exit(EXIT_FAILURE);
    }

    int large_w, large_h, large_mv;
    int small_w, small_h, small_mv;

    if (parse_ppm_header(fd_large, &large_w, &large_h, &large_mv) == -1) {
        fprintf(stderr, "Invalid large PPM file\n");
        exit(EXIT_FAILURE);
    }

    if (parse_ppm_header(fd_small, &small_w, &small_h, &small_mv) == -1) {
        fprintf(stderr, "Invalid small PPM file\n");
        exit(EXIT_FAILURE);
    }

    // Check if small image fits in top-right corner
    if (small_w > large_w || small_h > large_h) {
        fprintf(stderr, "Small image is too big to fit in large image's top-right corner\n");
        exit(EXIT_FAILURE);
    }

    // Copy large image's header to output: first rewind large file to start
    lseek(fd_large, 0, SEEK_SET);
    char header_buf[1024];
    int header_len = read(fd_large, header_buf, sizeof(header_buf));
    if (header_len == -1) {
        perror("Failed to read large header");
        exit(EXIT_FAILURE);
    }
    // Write header to output
    if (write(fd_out, header_buf, header_len) != header_len) {
        perror("Failed to write header to output");
        exit(EXIT_FAILURE);
    }

    // Copy entire large image pixel data to output
    char pixel_buf[4096]; // Use a buffer for efficient copying
    ssize_t bytes_read;
    while ((bytes_read = read(fd_large, pixel_buf, sizeof(pixel_buf))) > 0) {
        if (write(fd_out, pixel_buf, bytes_read) != bytes_read) {
            perror("Failed to copy large image pixels");
            exit(EXIT_FAILURE);
        }
    }
    if (bytes_read == -1) {
        perror("Failed to read large image pixels");
        exit(EXIT_FAILURE);
    }

    // Now overwrite the top-right corner with small image pixels
    // Each row of the small image starts at:
    // (y * large_w * 3) + (large_w - small_w) * 3
    // where y ranges from 0 to small_h - 1
    char small_row_buf[1024 * 3]; // Buffer for one row of small image (max 1024 width)
    for (int y = 0; y < small_h; y++) {
        // Read one row from small image
        ssize_t row_len = small_w * 3;
        if (read(fd_small, small_row_buf, row_len) != row_len) {
            perror("Failed to read small image row");
            exit(EXIT_FAILURE);
        }

        // Calculate offset in output file
        off_t offset = (off_t)y * large_w * 3 + (large_w - small_w) * 3;
        // Add header length to offset (since header comes before pixel data)
        offset += header_len;

        // Seek to the correct position in output file
        if (lseek(fd_out, offset, SEEK_SET) == -1) {
            perror("Failed to seek in output file");
            exit(EXIT_FAILURE);
        }

        // Write the small image row to output
        if (write(fd_out, small_row_buf, row_len) != row_len) {
            perror("Failed to write small image row");
            exit(EXIT_FAILURE);
        }
    }

    // Cleanup
    close(fd_large);
    close(fd_small);
    close(fd_out);

    printf("Images merged successfully! Output file: %s\n", argv[3]);
    return EXIT_SUCCESS;
}

• Header Parsing: The parse_ppm_header function handles comments and whitespace correctly, which is important because PPM headers can have arbitrary comments starting with #.
• Offset Calculation: For each row of the small image, we calculate where it should go in the output file. The formula accounts for the large image's row size (large_w *3 bytes) and the starting x-position (large_w - small_w pixels from the left, which translates to (large_w - small_w)*3 bytes).
• Efficient Copying: We use a buffer (4096 bytes) to copy the large image's pixel data in chunks, which is faster than reading/writing one byte at a time.
• Error Handling: Every system call is checked for errors, which is crucial for robust low-level programming.

To compile and run:

gcc -o merge_ppm merge_ppm.c
./merge_ppm large.p6 small.p6 output.p6

内容的提问来源于stack exchange，提问作者J. J