I'm using fwrite to write a file (it's an image).
First, I'm writing a header that has a fixed size
int num_meta_write_bytes = fwrite(headerBuffer, 1, headerSize, file);
This works OK
Then I have to write the pixels:
num_write_bytes = fwrite(data_pointer, 1, image_size, file);
This works OK
For my case, I have to write a variable number of zeros between the header and the pixels, the (ugly?) solution I found is:
for (size_t i = 0; i < padding_zeros; i++) //padding_zeros is calculated in runtime
{
uint8_t zero = 0;
num_meta_write_bytes += fwrite(&zero, 1, sizeof(uint8_t), fp);
}
(This code is placed before writing the pixels)
My question is: is there a way to directly tell fwrite to continously write the same value padding_zeros times? instead of using this for loop?
You can create a zero-filled block of data with calloc(), then write that data to the file in one call (and remember to free the data afterwards):
uint8_t* zeros = calloc(padding_zeros, sizeof(uint8_t));
if (zeros) {
num_meta_write_bytes += fwrite(zeros, sizeof(uint8_t), padding_zeros, fp);
free(zeros);
}
else {
// Error handling, or use your 'loop' method if calloc fails
}
As mentioned in the comments, you could also use a variable length array; however, VLAs are an 'optional' feature in C (since the C11 Standard), and you would anyway have to explicitly set the data to zeros (with a call to memset), as VLAs cannot be initialized like ordinary (fixed-size) arrays.
I found another solution, althouht I think is OS dependent:
fseek(fp, padding_zeros, SEEK_CUR);
This is quite fast as there is no allocation. Just when copying the resulting file, the OS will generate the actual zeros.
This worked fine in my linux target.