Bump version to 1.0.0-alpha.17 in nuspec file

libaaruformat.nuspec

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
     <metadata>
         <id>libaaruformat</id>
-        <version>1.0.0-alpha.15</version>
+        <version>1.0.0-alpha.17</version>
         <description>Library for management of AaruFormat images.</description>
         <authors>claunia</authors>
         <projectUrl>https://github.com/aaru-dps/libaaruformat</projectUrl>

src/blocks/metadata.c

@@ -81,7 +81,7 @@ void process_metadata_block(aaruformat_context *ctx, const IndexEntry *entry)
 
     ctx->image_info.ImageSize += ctx->metadata_block_header.blockSize;
 
-    ctx->metadata_block = (uint8_t *)malloc(ctx->metadata_block_header.blockSize);
+    ctx->metadata_block = (uint8_t *)malloc(ctx->metadata_block_header.blockSize + sizeof(MetadataBlockHeader));
 
     if(ctx->metadata_block == NULL)
     {
@@ -104,6 +104,8 @@ void process_metadata_block(aaruformat_context *ctx, const IndexEntry *entry)
         memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader));
         free(ctx->metadata_block);
         FATAL("Could not read metadata block, continuing...");
+
+        return;
     }
 
     if(ctx->metadata_block_header.mediaSequence > 0 && ctx->metadata_block_header.lastMediaSequence > 0)

src/close.c

@@ -939,6 +939,7 @@ static void write_mode2_subheaders_block(aaruformat_context *ctx)
     else
         subheaders_block.cmpCrc64 = aaruf_crc64_data(buffer, subheaders_block.cmpLength);
 
+    const size_t length_to_write = subheaders_block.cmpLength;
     if(subheaders_block.compression == Lzma) subheaders_block.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -947,7 +948,7 @@ static void write_mode2_subheaders_block(aaruformat_context *ctx)
         if(subheaders_block.compression == Lzma) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        size_t written_bytes = fwrite(buffer, subheaders_block.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote MODE 2 subheaders block (%" PRIu64 " bytes)", subheaders_block.cmpLength);
@@ -1052,6 +1053,7 @@ static void write_sector_prefix(aaruformat_context *ctx)
     else
         prefix_block.cmpCrc64 = aaruf_crc64_data(buffer, prefix_block.cmpLength);
 
+    const size_t length_to_write = prefix_block.cmpLength;
     if(prefix_block.compression == Lzma) prefix_block.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -1060,7 +1062,7 @@ static void write_sector_prefix(aaruformat_context *ctx)
         if(prefix_block.compression == Lzma) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        const size_t written_bytes = fwrite(buffer, prefix_block.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote CD sector prefix block (%" PRIu64 " bytes)", prefix_block.cmpLength);
@@ -1174,6 +1176,7 @@ static void write_sector_suffix(aaruformat_context *ctx)
     else
         suffix_block.cmpCrc64 = aaruf_crc64_data(buffer, suffix_block.cmpLength);
 
+    const size_t length_to_write = suffix_block.cmpLength;
     if(suffix_block.compression == Lzma) suffix_block.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -1182,7 +1185,7 @@ static void write_sector_suffix(aaruformat_context *ctx)
         if(suffix_block.compression == Lzma) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        const size_t written_bytes = fwrite(buffer, suffix_block.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote CD sector suffix block (%" PRIu64 " bytes)", suffix_block.cmpLength);
@@ -1302,6 +1305,7 @@ static void write_sector_prefix_ddt(aaruformat_context *ctx)
     else
         ddt_header2.cmpCrc64 = aaruf_crc64_data(buffer, (uint32_t)ddt_header2.cmpLength);
 
+    const size_t length_to_write = ddt_header2.cmpLength;
     if(ddt_header2.compression == Lzma) ddt_header2.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -1310,7 +1314,7 @@ static void write_sector_prefix_ddt(aaruformat_context *ctx)
         if(ddt_header2.compression == Lzma) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        const size_t written_bytes = fwrite(buffer, ddt_header2.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote sector prefix DDT v2 (%" PRIu64 " bytes)", ddt_header2.cmpLength);
@@ -1446,6 +1450,7 @@ static void write_sector_suffix_ddt(aaruformat_context *ctx)
     else
         ddt_header2.cmpCrc64 = aaruf_crc64_data(buffer, (uint32_t)ddt_header2.cmpLength);
 
+    const size_t length_to_write = ddt_header2.cmpLength;
     if(ddt_header2.compression == Lzma) ddt_header2.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -1454,7 +1459,7 @@ static void write_sector_suffix_ddt(aaruformat_context *ctx)
         if(ddt_header2.compression == Lzma) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        const size_t written_bytes = fwrite(buffer, ddt_header2.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote sector suffix DDT v2 (%" PRIu64 " bytes)", ddt_header2.cmpLength);
@@ -1553,14 +1558,13 @@ static void write_sector_subchannel(const aaruformat_context *ctx)
     bool     owns_buffer                             = false;
     uint8_t  lzma_properties[LZMA_PROPERTIES_LENGTH] = {0};
 
-    subchannel_block.cmpLength = subchannel_block.length;
-
     if(ctx->image_info.MetadataMediaType == OpticalDisc)
     {
         subchannel_block.type   = CdSectorSubchannel;
         subchannel_block.length = (uint32_t)(ctx->user_data_ddt_header.negative + ctx->image_info.Sectors +
                                              ctx->user_data_ddt_header.overflow) *
                                   96;
+        subchannel_block.cmpLength = subchannel_block.length;
 
         if(ctx->compression_enabled)
         {
@@ -1627,6 +1631,7 @@ static void write_sector_subchannel(const aaruformat_context *ctx)
                 TRACE("Incorrect media type, not writing sector subchannel block");
                 return;  // Incorrect media type
         }
+        subchannel_block.cmpLength   = subchannel_block.length;
         subchannel_block.compression = Lzma;
 
         uint8_t *dst_buffer = malloc(subchannel_block.length);
@@ -1669,6 +1674,7 @@ static void write_sector_subchannel(const aaruformat_context *ctx)
     else
         subchannel_block.cmpCrc64 = aaruf_crc64_data(buffer, subchannel_block.cmpLength);
 
+    const size_t length_to_write = subchannel_block.cmpLength;
     if(subchannel_block.compression != None) subchannel_block.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -1677,7 +1683,7 @@ static void write_sector_subchannel(const aaruformat_context *ctx)
         if(subchannel_block.compression != None) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        const size_t written_bytes = fwrite(buffer, subchannel_block.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote sector subchannel block (%" PRIu64 " bytes)", subchannel_block.cmpLength);
@@ -1899,6 +1905,7 @@ void write_dvd_long_sector_blocks(aaruformat_context *ctx)
     else
         id_block.cmpCrc64 = aaruf_crc64_data(buffer, id_block.cmpLength);
 
+    size_t length_to_write = id_block.cmpLength;
     if(id_block.compression == Lzma) id_block.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -1907,7 +1914,7 @@ void write_dvd_long_sector_blocks(aaruformat_context *ctx)
         if(id_block.compression == Lzma) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        const size_t written_bytes = fwrite(buffer, id_block.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote DVD sector ID block (%" PRIu64 " bytes)", id_block.cmpLength);
@@ -1981,6 +1988,7 @@ void write_dvd_long_sector_blocks(aaruformat_context *ctx)
     else
         ied_block.cmpCrc64 = aaruf_crc64_data(buffer, ied_block.cmpLength);
 
+    length_to_write = ied_block.cmpLength;
     if(ied_block.compression == Lzma) ied_block.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -1989,7 +1997,7 @@ void write_dvd_long_sector_blocks(aaruformat_context *ctx)
         if(ied_block.compression == Lzma) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        const size_t written_bytes = fwrite(buffer, ied_block.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote DVD sector IED block (%" PRIu64 " bytes)", ied_block.cmpLength);
@@ -2063,6 +2071,7 @@ void write_dvd_long_sector_blocks(aaruformat_context *ctx)
     else
         cpr_mai_block.cmpCrc64 = aaruf_crc64_data(buffer, cpr_mai_block.cmpLength);
 
+    length_to_write = cpr_mai_block.cmpLength;
     if(cpr_mai_block.compression == Lzma) cpr_mai_block.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -2071,7 +2080,7 @@ void write_dvd_long_sector_blocks(aaruformat_context *ctx)
         if(cpr_mai_block.compression == Lzma) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        const size_t written_bytes = fwrite(buffer, cpr_mai_block.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote DVD sector CPR/MAI block (%" PRIu64 " bytes)", cpr_mai_block.cmpLength);
@@ -2145,6 +2154,7 @@ void write_dvd_long_sector_blocks(aaruformat_context *ctx)
     else
         edc_block.cmpCrc64 = aaruf_crc64_data(buffer, edc_block.cmpLength);
 
+    length_to_write = edc_block.cmpLength;
     if(edc_block.compression == Lzma) edc_block.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -2153,7 +2163,7 @@ void write_dvd_long_sector_blocks(aaruformat_context *ctx)
         if(edc_block.compression == Lzma) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        const size_t written_bytes = fwrite(buffer, edc_block.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote DVD sector EDC block (%" PRIu64 " bytes)", edc_block.cmpLength);
@@ -2333,6 +2343,7 @@ static void write_dvd_title_key_decrypted_block(const aaruformat_context *ctx)
     else
         decrypted_title_key_block.cmpCrc64 = aaruf_crc64_data(buffer, decrypted_title_key_block.cmpLength);
 
+    const size_t length_to_write = decrypted_title_key_block.cmpLength;
     if(decrypted_title_key_block.compression == Lzma) decrypted_title_key_block.cmpLength += LZMA_PROPERTIES_LENGTH;
 
     // Write header
@@ -2342,7 +2353,7 @@ static void write_dvd_title_key_decrypted_block(const aaruformat_context *ctx)
             fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);
 
         // Write data
-        const size_t written_bytes = fwrite(buffer, decrypted_title_key_block.cmpLength, 1, ctx->imageStream);
+        const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
         if(written_bytes == 1)
         {
             TRACE("Successfully wrote DVD decrypted title key block (%" PRIu64 " bytes)",
@@ -2502,6 +2513,7 @@ static void write_media_tags(const aaruformat_context *ctx)
         else
             tag_block.cmpCrc64 = aaruf_crc64_data(buffer, tag_block.cmpLength);
 
+        const size_t length_to_write = tag_block.cmpLength;
         if(tag_block.compression == Lzma) tag_block.cmpLength += LZMA_PROPERTIES_LENGTH;
 
         // Write header
@@ -2510,7 +2522,7 @@ static void write_media_tags(const aaruformat_context *ctx)
             if(tag_block.compression == Lzma)
                 fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream);  // Write data
 
-            const size_t written_bytes = fwrite(buffer, tag_block.cmpLength, 1, ctx->imageStream);
+            const size_t written_bytes = fwrite(buffer, length_to_write, 1, ctx->imageStream);
             if(written_bytes == 1)
             {
                 TRACE("Successfully wrote media tag block type %d (%" PRIu64 " bytes)", tag_block.type,

tests/create_image.cpp

@@ -739,7 +739,6 @@ TEST_F(CreateImageFixture, create_audio_image)
     EXPECT_EQ(close_result, AARUF_STATUS_OK) << "Failed to close image";
 }
 
-
 TEST_F(CreateImageFixture, create_image_negative_sectors)
 {
     char path[PATH_MAX];
@@ -855,3 +854,329 @@ TEST_F(CreateImageFixture, create_image_negative_sectors)
     close_result = aaruf_close(context);
     EXPECT_EQ(close_result, AARUF_STATUS_OK) << "Failed to close image";
 }
+
+TEST_F(CreateImageFixture, create_subchannel_uncompressed_image)
+{
+    char path[PATH_MAX];
+    char filename[PATH_MAX];
+
+    getcwd(path, PATH_MAX);
+    snprintf(filename, PATH_MAX, "%s/data/audio.bin", path);
+
+    // Open audio file
+    FILE *f = fopen(filename, "rb");
+    ASSERT_NE(f, nullptr) << "Failed to open audio.bin data file";
+
+    // Get file size
+    fseek(f, 0, SEEK_END);
+    const long audio_size = ftell(f);
+    fseek(f, 0, SEEK_SET);
+
+    // Read entire audio file into buffer
+    uint8_t *buffer = static_cast<uint8_t *>(malloc(audio_size));
+    ASSERT_NE(buffer, nullptr) << "Failed to allocate memory for audio data";
+
+    size_t bytes_read = fread(buffer, 1, audio_size, f);
+    fclose(f);
+    ASSERT_EQ(bytes_read, static_cast<size_t>(audio_size)) << "Failed to read complete audio data";
+
+    // Calculate total size: three times the audio.bin size
+    const size_t total_size = audio_size * 3;
+
+    // Create image with default options (NULL for options means defaults)
+    void *context = aaruf_create("test_audio.aif", 11, 2352, total_size / 2352, 0, 0, "compress=false",
+                                 reinterpret_cast<const uint8_t *>("gtest"), 10, 0, 0, false);
+
+    // Verify that the file was successfully opened
+    ASSERT_NE(context, nullptr) << "Failed to create test_audio.aif";
+
+    // Set up a single audio track spanning the entire media
+    TrackEntry track;
+    memset(&track, 0, sizeof(TrackEntry));
+    track.sequence = 1;                            // Track 1
+    track.type     = Audio;                        // Audio track type (0)
+    track.start    = 0;                            // Start at sector 0
+    track.end      = (audio_size * 3 / 2352) - 1;  // End at last sector (inclusive)
+    track.pregap   = 0;                            // No pregap
+    track.session  = 1;                            // Session 1
+    memset(track.isrc, 0, 13);                     // No ISRC
+    track.flags = 0;                               // No special flags
+
+    int32_t track_result = aaruf_set_tracks(context, &track, 1);
+    ASSERT_EQ(track_result, AARUF_STATUS_OK) << "Failed to set tracks";
+
+    crc64_ctx *ctx           = aaruf_crc64_init();
+    uint64_t   generated_crc = 0;
+
+    // Write audio data three times using write_sector_long
+    size_t total_sectors = total_size / 2352;
+
+    for(size_t sector = 0; sector < total_sectors; ++sector)
+    {
+        // Calculate offset in the original audio buffer (wrap around after each iteration)
+        const size_t  buffer_offset = (sector * 2352) % audio_size;
+        const int32_t write_result =
+            aaruf_write_sector_long(context, sector, false, buffer + buffer_offset, SectorStatusDumped, 2352);
+        ASSERT_EQ(write_result, AARUF_STATUS_OK) << "Failed to write sector " << sector;
+
+        aaruf_crc64_update(ctx, buffer + buffer_offset, 2352);
+    }
+
+    aaruf_crc64_final(ctx, &generated_crc);
+    aaruf_crc64_free(ctx);
+
+    // Write subchannel data for each sector and calculate CRC64
+    crc64_ctx *subchannel_ctx           = aaruf_crc64_init();
+    uint64_t   generated_subchannel_crc = 0;
+    uint8_t    subchannel_data[96];
+
+    for(size_t sector = 0; sector < total_sectors; ++sector)
+    {
+        // Generate subchannel pattern based on sector number (96 bytes per sector)
+        for(size_t i = 0; i < 96; ++i) { subchannel_data[i] = static_cast<uint8_t>((sector * 96 + i) & 0xFF); }
+
+        const int32_t subchannel_result =
+            aaruf_write_sector_tag(context, sector, false, subchannel_data, 96, CdSectorSubchannelAaru);
+        ASSERT_EQ(subchannel_result, AARUF_STATUS_OK) << "Failed to write subchannel for sector " << sector;
+
+        // Update CRC64 with the subchannel data we just wrote
+        aaruf_crc64_update(subchannel_ctx, subchannel_data, 96);
+    }
+
+    aaruf_crc64_final(subchannel_ctx, &generated_subchannel_crc);
+    aaruf_crc64_free(subchannel_ctx);
+
+    // Close the image
+    int32_t close_result = aaruf_close(context);
+    ASSERT_EQ(close_result, AARUF_STATUS_OK) << "Failed to close image";
+    free(buffer);
+
+    // Reopen the image
+    context = aaruf_open("test_audio.aif", false, NULL);
+    ASSERT_NE(context, nullptr) << "Failed to open test_audio.aif";
+
+    // Get image info to verify it's a valid image
+    ImageInfo     image_info;
+    const int32_t result = aaruf_get_image_info(context, &image_info);
+
+    ASSERT_EQ(result, AARUF_STATUS_OK) << "Failed to get image info";
+
+    // Basic sanity checks on the image info
+    ASSERT_EQ(image_info.HasPartitions, true) << "Image should not have partitions";
+    ASSERT_EQ(image_info.HasSessions, true) << "Image should not have sessions";
+    ASSERT_EQ(image_info.Sectors, total_sectors) << "Unexpected number of sectors";
+    ASSERT_EQ(image_info.SectorSize, 2352) << "Unexpected sector size";
+    ASSERT_STREQ(image_info.Version, "2.0") << "Unexpected image version";
+    ASSERT_STREQ(image_info.Application, "gtest") << "Unexpected application name";
+    ASSERT_STREQ(image_info.ApplicationVersion, "0.0") << "Unexpected application version";
+    ASSERT_EQ(image_info.MediaType, 11) << "Unexpected media type";
+    ASSERT_EQ(image_info.MetadataMediaType, 0) << "Unexpected metadata media type";
+
+    ctx          = aaruf_crc64_init();
+    uint64_t crc = 0;
+
+    for(size_t i = 0; i < total_sectors; i++)
+    {
+        uint8_t  sector_buffer[2352];
+        uint32_t length        = sizeof(sector_buffer);
+        uint8_t  sector_status = 0;
+
+        const int32_t read_result = aaruf_read_sector_long(context, i, false, sector_buffer, &length, &sector_status);
+        EXPECT_EQ(read_result, AARUF_STATUS_OK) << "Failed to read sector " << i;
+        EXPECT_EQ(length, 2352U) << "Unexpected length for sector " << i;
+        aaruf_crc64_update(ctx, sector_buffer, 2352);
+    }
+
+    aaruf_crc64_final(ctx, &crc);
+    aaruf_crc64_free(ctx);
+
+    ASSERT_EQ(crc, generated_crc) << "Unexpected CRC64 for image data";
+
+    // Read back and verify subchannel data
+    crc64_ctx *subchannel_read_ctx = aaruf_crc64_init();
+    uint64_t   read_subchannel_crc = 0;
+
+    for(size_t i = 0; i < total_sectors; i++)
+    {
+        uint8_t  subchannel_buffer[96];
+        uint32_t subchannel_length = sizeof(subchannel_buffer);
+
+        const int32_t subchannel_read_result =
+            aaruf_read_sector_tag(context, i, false, subchannel_buffer, &subchannel_length, CdSectorSubchannelAaru);
+        EXPECT_EQ(subchannel_read_result, AARUF_STATUS_OK) << "Failed to read subchannel for sector " << i;
+        EXPECT_EQ(subchannel_length, 96U) << "Unexpected subchannel length for sector " << i;
+        aaruf_crc64_update(subchannel_read_ctx, subchannel_buffer, 96);
+    }
+
+    aaruf_crc64_final(subchannel_read_ctx, &read_subchannel_crc);
+    aaruf_crc64_free(subchannel_read_ctx);
+
+    ASSERT_EQ(read_subchannel_crc, generated_subchannel_crc) << "Unexpected CRC64 for subchannel data";
+
+    // Close the image
+    close_result = aaruf_close(context);
+    EXPECT_EQ(close_result, AARUF_STATUS_OK) << "Failed to close image";
+}
+
+TEST_F(CreateImageFixture, create_subchannel_compressed_image)
+{
+    char path[PATH_MAX];
+    char filename[PATH_MAX];
+
+    getcwd(path, PATH_MAX);
+    snprintf(filename, PATH_MAX, "%s/data/audio.bin", path);
+
+    // Open audio file
+    FILE *f = fopen(filename, "rb");
+    ASSERT_NE(f, nullptr) << "Failed to open audio.bin data file";
+
+    // Get file size
+    fseek(f, 0, SEEK_END);
+    const long audio_size = ftell(f);
+    fseek(f, 0, SEEK_SET);
+
+    // Read entire audio file into buffer
+    uint8_t *buffer = static_cast<uint8_t *>(malloc(audio_size));
+    ASSERT_NE(buffer, nullptr) << "Failed to allocate memory for audio data";
+
+    size_t bytes_read = fread(buffer, 1, audio_size, f);
+    fclose(f);
+    ASSERT_EQ(bytes_read, static_cast<size_t>(audio_size)) << "Failed to read complete audio data";
+
+    // Calculate total size: three times the audio.bin size
+    const size_t total_size = audio_size * 3;
+
+    // Create image with default options (NULL for options means defaults)
+    void *context = aaruf_create("test_audio.aif", 11, 2352, total_size / 2352, 0, 0, "compress=true",
+                                 reinterpret_cast<const uint8_t *>("gtest"), 10, 0, 0, false);
+
+    // Verify that the file was successfully opened
+    ASSERT_NE(context, nullptr) << "Failed to create test_audio.aif";
+
+    // Set up a single audio track spanning the entire media
+    TrackEntry track;
+    memset(&track, 0, sizeof(TrackEntry));
+    track.sequence = 1;                            // Track 1
+    track.type     = Audio;                        // Audio track type (0)
+    track.start    = 0;                            // Start at sector 0
+    track.end      = (audio_size * 3 / 2352) - 1;  // End at last sector (inclusive)
+    track.pregap   = 0;                            // No pregap
+    track.session  = 1;                            // Session 1
+    memset(track.isrc, 0, 13);                     // No ISRC
+    track.flags = 0;                               // No special flags
+
+    int32_t track_result = aaruf_set_tracks(context, &track, 1);
+    ASSERT_EQ(track_result, AARUF_STATUS_OK) << "Failed to set tracks";
+
+    crc64_ctx *ctx           = aaruf_crc64_init();
+    uint64_t   generated_crc = 0;
+
+    // Write audio data three times using write_sector_long
+    size_t total_sectors = total_size / 2352;
+
+    for(size_t sector = 0; sector < total_sectors; ++sector)
+    {
+        // Calculate offset in the original audio buffer (wrap around after each iteration)
+        const size_t  buffer_offset = (sector * 2352) % audio_size;
+        const int32_t write_result =
+            aaruf_write_sector_long(context, sector, false, buffer + buffer_offset, SectorStatusDumped, 2352);
+        ASSERT_EQ(write_result, AARUF_STATUS_OK) << "Failed to write sector " << sector;
+
+        aaruf_crc64_update(ctx, buffer + buffer_offset, 2352);
+    }
+
+    aaruf_crc64_final(ctx, &generated_crc);
+    aaruf_crc64_free(ctx);
+
+    // Write subchannel data for each sector and calculate CRC64
+    crc64_ctx *subchannel_ctx           = aaruf_crc64_init();
+    uint64_t   generated_subchannel_crc = 0;
+    uint8_t    subchannel_data[96];
+
+    for(size_t sector = 0; sector < total_sectors; ++sector)
+    {
+        // Generate subchannel pattern based on sector number (96 bytes per sector)
+        for(size_t i = 0; i < 96; ++i) { subchannel_data[i] = static_cast<uint8_t>((sector * 96 + i) & 0xFF); }
+
+        const int32_t subchannel_result =
+            aaruf_write_sector_tag(context, sector, false, subchannel_data, 96, CdSectorSubchannelAaru);
+        ASSERT_EQ(subchannel_result, AARUF_STATUS_OK) << "Failed to write subchannel for sector " << sector;
+
+        // Update CRC64 with the subchannel data we just wrote
+        aaruf_crc64_update(subchannel_ctx, subchannel_data, 96);
+    }
+
+    aaruf_crc64_final(subchannel_ctx, &generated_subchannel_crc);
+    aaruf_crc64_free(subchannel_ctx);
+
+    // Close the image
+    int32_t close_result = aaruf_close(context);
+    ASSERT_EQ(close_result, AARUF_STATUS_OK) << "Failed to close image";
+    free(buffer);
+
+    // Reopen the image
+    context = aaruf_open("test_audio.aif", false, NULL);
+    ASSERT_NE(context, nullptr) << "Failed to open test_audio.aif";
+
+    // Get image info to verify it's a valid image
+    ImageInfo     image_info;
+    const int32_t result = aaruf_get_image_info(context, &image_info);
+
+    ASSERT_EQ(result, AARUF_STATUS_OK) << "Failed to get image info";
+
+    // Basic sanity checks on the image info
+    ASSERT_EQ(image_info.HasPartitions, true) << "Image should not have partitions";
+    ASSERT_EQ(image_info.HasSessions, true) << "Image should not have sessions";
+    ASSERT_EQ(image_info.Sectors, total_sectors) << "Unexpected number of sectors";
+    ASSERT_EQ(image_info.SectorSize, 2352) << "Unexpected sector size";
+    ASSERT_STREQ(image_info.Version, "2.0") << "Unexpected image version";
+    ASSERT_STREQ(image_info.Application, "gtest") << "Unexpected application name";
+    ASSERT_STREQ(image_info.ApplicationVersion, "0.0") << "Unexpected application version";
+    ASSERT_EQ(image_info.MediaType, 11) << "Unexpected media type";
+    ASSERT_EQ(image_info.MetadataMediaType, 0) << "Unexpected metadata media type";
+
+    ctx          = aaruf_crc64_init();
+    uint64_t crc = 0;
+
+    for(size_t i = 0; i < total_sectors; i++)
+    {
+        uint8_t  sector_buffer[2352];
+        uint32_t length        = sizeof(sector_buffer);
+        uint8_t  sector_status = 0;
+
+        const int32_t read_result = aaruf_read_sector_long(context, i, false, sector_buffer, &length, &sector_status);
+        EXPECT_EQ(read_result, AARUF_STATUS_OK) << "Failed to read sector " << i;
+        EXPECT_EQ(length, 2352U) << "Unexpected length for sector " << i;
+        aaruf_crc64_update(ctx, sector_buffer, 2352);
+    }
+
+    aaruf_crc64_final(ctx, &crc);
+    aaruf_crc64_free(ctx);
+
+    ASSERT_EQ(crc, generated_crc) << "Unexpected CRC64 for image data";
+
+    // Read back and verify subchannel data
+    crc64_ctx *subchannel_read_ctx = aaruf_crc64_init();
+    uint64_t   read_subchannel_crc = 0;
+
+    for(size_t i = 0; i < total_sectors; i++)
+    {
+        uint8_t  subchannel_buffer[96];
+        uint32_t subchannel_length = sizeof(subchannel_buffer);
+
+        const int32_t subchannel_read_result =
+            aaruf_read_sector_tag(context, i, false, subchannel_buffer, &subchannel_length, CdSectorSubchannelAaru);
+        EXPECT_EQ(subchannel_read_result, AARUF_STATUS_OK) << "Failed to read subchannel for sector " << i;
+        EXPECT_EQ(subchannel_length, 96U) << "Unexpected subchannel length for sector " << i;
+        aaruf_crc64_update(subchannel_read_ctx, subchannel_buffer, 96);
+    }
+
+    aaruf_crc64_final(subchannel_read_ctx, &read_subchannel_crc);
+    aaruf_crc64_free(subchannel_read_ctx);
+
+    ASSERT_EQ(read_subchannel_crc, generated_subchannel_crc) << "Unexpected CRC64 for subchannel data";
+
+    // Close the image
+    close_result = aaruf_close(context);
+    EXPECT_EQ(close_result, AARUF_STATUS_OK) << "Failed to close image";
+}