write.c

Go to the documentation of this file.

/*
 * This file is part of the Aaru Data Preservation Suite.
 * Copyright (c) 2019-2026 Natalia Portillo.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of the
 * License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "aaruformat.h"
#include "erasure_internal.h"
#include "internal.h"
#include "log.h"
#include "ps3/ps3_crypto.h"
#include "ps3/ps3_encryption_map.h"
#include "structs/lisa_tag.h"
#include "xxhash.h"

static int32_t grow_arena(uint8_t **arena, size_t *length, const size_t needed, const size_t minimum)
{
    if(needed <= *length) return AARUF_STATUS_OK;
 
    size_t new_length = *length * 2;
    if(new_length < needed) new_length = needed;
    if(new_length < minimum) new_length = minimum;
 
    uint8_t *grown = realloc(*arena, new_length);
    if(grown == NULL) return AARUF_ERROR_NOT_ENOUGH_MEMORY;
 
    memset(grown + *length, 0, new_length - *length);
    *arena  = grown;
    *length = new_length;
 
    return AARUF_STATUS_OK;
}

static bool cd_header_matches_lba(const uint8_t *data, const int64_t lba)
{
    for(int i = 0x0C; i <= 0x0E; i++)
        if((data[i] >> 4) > 9 || (data[i] & 0x0F) > 9) return false;
 
    const int minute = (data[0x0C] >> 4) * 10 + (data[0x0C] & 0x0F);
    const int second = (data[0x0D] >> 4) * 10 + (data[0x0D] & 0x0F);
    const int frame  = (data[0x0E] >> 4) * 10 + (data[0x0E] & 0x0F);
 
    if(second > 59 || frame > 74) return false;
 
    return (int64_t)minute * 60 * 75 + second * 75 + frame - 150 == lba;
}

AARU_EXPORT int32_t AARU_CALL aaruf_write_sector(void *context, uint64_t sector_address, bool negative,
                                                 const uint8_t *data, uint8_t sector_status, uint32_t length)
{
    TRACE("Entering aaruf_write_sector(%p, %" PRIu64 ", %d, %p, %u, %u)", context, sector_address, negative, data,
          sector_status, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    aaruformat_context *ctx = context;
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Flux-only images carry no DDT and no sector storage.
    if(ctx->no_user_data_ddt)
    {
        FATAL("Cannot write sector to flux-only image (no user-data DDT)");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_USER_DATA_NOT_PRESENT");
        return AARUF_ERROR_USER_DATA_NOT_PRESENT;
    }
 
    if(negative && sector_address > ctx->user_data_ddt_header.negative)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    if(length > USHRT_MAX)
    {
        FATAL("Sector length too large");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_INVALID_SECTOR_LENGTH");
        return AARUF_ERROR_INVALID_SECTOR_LENGTH;
    }
 
    if(length > ctx->header.biggestSectorSize) ctx->header.biggestSectorSize = (uint16_t)length;
 
    if(!ctx->rewinded)
    {
        // disable checksums on first encounter of decrypted/generable sectors
        if(sector_status == SectorStatusUnencrypted || sector_status == SectorStatusGenerable)
        {
            TRACE("NGCW sector detected, disabling checksums");
            ctx->rewinded = true;
 
            if(ctx->calculating_md5) ctx->calculating_md5 = false;
            if(ctx->calculating_sha1) ctx->calculating_sha1 = false;
            if(ctx->calculating_sha256) ctx->calculating_sha256 = false;
            if(ctx->calculating_spamsum) ctx->calculating_spamsum = false;
            if(ctx->calculating_blake3) ctx->calculating_blake3 = false;
        }
        else if(sector_address <= ctx->last_written_block)
        {
            if(sector_address == 0 && !ctx->block_zero_written)
                ctx->block_zero_written = true;
            else
            {
                TRACE("Rewinded");
                ctx->rewinded = true;
 
                // Disable MD5 calculation
                if(ctx->calculating_md5) ctx->calculating_md5 = false;
                // Disable SHA1 calculation
                if(ctx->calculating_sha1) ctx->calculating_sha1 = false;
                // Disable SHA256 calculation
                if(ctx->calculating_sha256) ctx->calculating_sha256 = false;
                // Disable SpamSum calculation
                if(ctx->calculating_spamsum) ctx->calculating_spamsum = false;
                // Disable BLAKE3 calculation
                if(ctx->calculating_blake3) ctx->calculating_blake3 = false;
            }
        }
        else
            ctx->last_written_block = sector_address;
    }
 
    // Calculate MD5 on-the-fly if requested and sector is within user sectors (not negative or overflow)
    if(ctx->calculating_md5 && !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long)
        aaruf_md5_update(&ctx->md5_context, data, length);
    // Calculate SHA1 on-the-fly if requested and sector is within user sectors (not negative or overflow)
    if(ctx->calculating_sha1 && !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long)
        aaruf_sha1_update(&ctx->sha1_context, data, length);
    // Calculate SHA256 on-the-fly if requested and sector is within user sectors (not negative or overflow)
    if(ctx->calculating_sha256 && !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long)
        aaruf_sha256_update(&ctx->sha256_context, data, length);
    // Calculate SpamSum on-the-fly if requested and sector is within user sectors (not negative or overflow)
    if(ctx->calculating_spamsum && !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long)
        aaruf_spamsum_update(ctx->spamsum_context, data, length);
    // Calculate BLAKE3 on-the-fly if requested and sector is within user sectors (not negative or overflow)
    if(ctx->calculating_blake3 && !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long)
        blake3_hasher_update(ctx->blake3_context, data, length);
 
    // Mark checksum block as dirty if any checksums are being calculated
    if((ctx->calculating_md5 || ctx->calculating_sha1 || ctx->calculating_sha256 || ctx->calculating_spamsum ||
        ctx->calculating_blake3) &&
       !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long)
        ctx->dirty_checksum_block = true;
 
    // PS3 decryption: if caller sends encrypted data marked as "to be stored decrypted"
    // Checksums have already been computed on the ciphertext above.
    const uint8_t *write_data       = data;
    uint8_t       *decrypted_buffer = NULL;
 
    if(sector_status == SectorStatusUnencrypted && (ctx->header.mediaType == PS3DVD || ctx->header.mediaType == PS3BD))
    {
        if(!ctx->ps3_encryption_initialized)
        {
            ps3_lazy_init(ctx);
            ctx->ps3_encryption_initialized = true;
        }
 
        if(ctx->ps3_disc_key != NULL && ctx->ps3_plaintext_regions != NULL &&
           ps3_is_sector_encrypted((const Ps3PlaintextRegion *)ctx->ps3_plaintext_regions,
                                   ctx->ps3_plaintext_region_count, sector_address))
        {
            decrypted_buffer = (uint8_t *)malloc(length);
 
            if(decrypted_buffer == NULL)
            {
                FATAL("Could not allocate memory for PS3 decryption buffer");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(decrypted_buffer, data, length);
            ps3_decrypt_sector(ctx->ps3_disc_key, sector_address, decrypted_buffer, length);
            write_data = decrypted_buffer;
        }
    }
 
    // NGCW: SectorStatusGenerable — set DDT entry only, do not store data in any block
    if(sector_status == SectorStatusGenerable && (ctx->header.mediaType == GOD || ctx->header.mediaType == WOD))
    {
        uint64_t ddt_entry_gen = 0;
        bool     ddt_ok_gen    = set_ddt_entry_v2(ctx, sector_address, negative, 0, 0, sector_status, &ddt_entry_gen);
 
        free(decrypted_buffer);
 
        if(!ddt_ok_gen)
        {
            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_CANNOT_SET_DDT_ENTRY");
            return AARUF_ERROR_CANNOT_SET_DDT_ENTRY;
        }
 
        TRACE("Exiting aaruf_write_sector() = AARUF_STATUS_OK (generable)");
        return AARUF_STATUS_OK;
    }
 
    // Close current block first
    if(ctx->writing_buffer != NULL &&
       // When sector size changes or block reaches maximum size
       (ctx->current_block_header.sectorSize != length ||
        ctx->current_block_offset == 1 << ctx->user_data_ddt_header.dataShift))
    {
        TRACE("Closing current block before writing new data");
        int error = aaruf_close_current_block(ctx);
 
        if(error != AARUF_STATUS_OK)
        {
            FATAL("Error closing current block: %d", error);
 
            TRACE("Exiting aaruf_write_sector() = %d", error);
            return error;
        }
    }
 
    uint64_t ddt_entry = 0;
    bool     ddt_ok;
 
    if(ctx->deduplicate)
    {
        // Calculate 64-bit XXH3 hash of the sector (on decrypted data for dedup)
        TRACE("Hashing sector data for deduplication");
        uint64_t hash = XXH3_64bits(write_data, length);
 
        // Check if the hash is already in the map
        bool existing = lookup_map(ctx->sector_hash_map, hash, &ddt_entry);
        TRACE("Block does %s exist in deduplication map", existing ? "already" : "not yet");
 
        ddt_ok = set_ddt_entry_v2(ctx, sector_address, negative, ctx->current_block_offset, ctx->next_block_position,
                                  sector_status, &ddt_entry);
        if(!ddt_ok)
        {
            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_CANNOT_SET_DDT_ENTRY");
            return AARUF_ERROR_CANNOT_SET_DDT_ENTRY;
        }
 
        if(existing)
        {
            TRACE("Sector exists, so not writing to image");
            free(decrypted_buffer);
            TRACE("Exiting aaruf_write_sector() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        }
 
        TRACE("Inserting sector hash into deduplication map, proceeding to write into image as normal");
        insert_map(ctx->sector_hash_map, hash, ddt_entry);
    }
    else
        ddt_ok = set_ddt_entry_v2(ctx, sector_address, negative, ctx->current_block_offset, ctx->next_block_position,
                                  sector_status, &ddt_entry);
 
    if(!ddt_ok)
    {
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_CANNOT_SET_DDT_ENTRY");
        return AARUF_ERROR_CANNOT_SET_DDT_ENTRY;
    }
 
    // No block set
    if(ctx->writing_buffer_position == 0)
    {
        TRACE("Creating new writing block");
        ctx->current_block_header.identifier = DataBlock;
        ctx->current_block_header.type       = kDataTypeUserData;
        ctx->current_block_header.sectorSize = length;
 
        // We need to save the track type for later compression
        if(ctx->image_info.MetadataMediaType == OpticalDisc && ctx->track_entries != NULL)
        {
            const TrackEntry *track = NULL;
            for(int i = 0; i < ctx->tracks_header.entries; i++)
                if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end)
                {
                    track = &ctx->track_entries[i];
                    break;
                }
 
            if(track != NULL)
            {
                ctx->current_track_type = track->type;
 
                if(track->sequence == 0 && track->start == 0 && track->end == 0)
                    ctx->current_track_type = kTrackTypeData;
            }
            else
                ctx->current_track_type = kTrackTypeData;
 
            if(ctx->current_track_type == kTrackTypeAudio &&
               // JaguarCD stores data in audio tracks. FLAC is too inefficient, we need to use LZMA as data.
               (ctx->image_info.MediaType == JaguarCD && track->session > 1 ||
                // VideoNow stores video in audio tracks, and LZMA works better too.
                ctx->image_info.MediaType == VideoNow || ctx->image_info.MediaType == VideoNowColor ||
                ctx->image_info.MediaType == VideoNowXp))
                ctx->current_track_type = kTrackTypeData;
 
            if(ctx->compression_enabled)
            {
                if(ctx->current_track_type == kTrackTypeAudio)
                    ctx->current_block_header.compression = kCompressionFlac;
                else
                    ctx->current_block_header.compression = ctx->use_zstd ? kCompressionZstd : kCompressionLzma;
            }
            else
                ctx->current_block_header.compression = kCompressionNone;
        }
        else
        {
            ctx->current_track_type = kTrackTypeData;
            if(ctx->compression_enabled)
                ctx->current_block_header.compression = ctx->use_zstd ? kCompressionZstd : kCompressionLzma;
            else
                ctx->current_block_header.compression = kCompressionNone;
        }
 
        uint32_t max_buffer_size =
            (1 << ctx->user_data_ddt_header.dataShift) * ctx->current_block_header.sectorSize * 2;
        TRACE("Setting max buffer size to %u bytes", max_buffer_size);
 
        TRACE("Allocating memory for writing buffer");
        ctx->writing_buffer = (uint8_t *)calloc(1, max_buffer_size);
        if(ctx->writing_buffer == NULL)
        {
            FATAL("Could not allocate memory");
 
            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
        }
    }
 
    TRACE("Copying data to writing buffer at position %zu", ctx->writing_buffer_position);
    memcpy(ctx->writing_buffer + ctx->writing_buffer_position, write_data, length);
    TRACE("Advancing writing buffer position to %zu", ctx->writing_buffer_position + length);
    ctx->writing_buffer_position += length;
    TRACE("Advancing current block offset to %zu", ctx->current_block_offset + 1);
    ctx->current_block_offset++;
 
    free(decrypted_buffer);
 
    TRACE("Exiting aaruf_write_sector() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_write_sector_long(void *context, uint64_t sector_address, bool negative,
                                                      const uint8_t *data, uint8_t sector_status, uint32_t length)
{
    TRACE("Entering aaruf_write_sector_long(%p, %" PRIu64 ", %d, %p, %u, %u)", context, sector_address, negative, data,
          sector_status, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    aaruformat_context *ctx = context;
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Flux-only images carry no DDT and no sector storage.
    if(ctx->no_user_data_ddt)
    {
        FATAL("Cannot write long sector to flux-only image (no user-data DDT)");
 
        TRACE("Exiting aaruf_write_sector_long() = AARUF_ERROR_USER_DATA_NOT_PRESENT");
        return AARUF_ERROR_USER_DATA_NOT_PRESENT;
    }
 
    if(negative && sector_address > ctx->user_data_ddt_header.negative)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    switch(ctx->image_info.MetadataMediaType)
    {
        case OpticalDisc:
        {
            TrackEntry track = {0};
 
            for(int i = 0; i < ctx->tracks_header.entries; i++)
                if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end)
                {
                    track = ctx->track_entries[i];
                    break;
                }
 
            if(track.sequence == 0 && track.start == 0 && track.end == 0) track.type = kTrackTypeData;
 
            uint64_t corrected_sector_address = sector_address;
 
            // Calculate positive or negative sector
            if(negative)
                corrected_sector_address = ctx->user_data_ddt_header.negative - sector_address;
            else
                corrected_sector_address += ctx->user_data_ddt_header.negative;
 
            uint64_t total_sectors =
                ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow;
 
            // LBA as encoded in a CD sector header (lead-in sectors are negative)
            const int64_t signed_lba = negative ? -(int64_t)sector_address : (int64_t)sector_address;
 
            // DVD long sector
            if(length == 2064 && (ctx->image_info.MediaType == DVDROM || ctx->image_info.MediaType == PS2DVD ||
                                  ctx->image_info.MediaType == SACD || ctx->image_info.MediaType == PS3DVD ||
                                  ctx->image_info.MediaType == DVDR || ctx->image_info.MediaType == DVDRW ||
                                  ctx->image_info.MediaType == DVDPR || ctx->image_info.MediaType == DVDPRW ||
                                  ctx->image_info.MediaType == DVDPRWDL || ctx->image_info.MediaType == DVDRDL ||
                                  ctx->image_info.MediaType == DVDPRDL || ctx->image_info.MediaType == DVDRAM ||
                                  ctx->image_info.MediaType == DVDRWDL || ctx->image_info.MediaType == DVDDownload ||
                                  ctx->image_info.MediaType == Nuon))
            {
                if(ctx->sector_id == NULL) ctx->sector_id = calloc(1, 4 * total_sectors);
                if(ctx->sector_ied == NULL) ctx->sector_ied = calloc(1, 2 * total_sectors);
                if(ctx->sector_cpr_mai == NULL) ctx->sector_cpr_mai = calloc(1, 6 * total_sectors);
                if(ctx->sector_edc == NULL) ctx->sector_edc = calloc(1, 4 * total_sectors);
 
                memcpy(ctx->sector_id + corrected_sector_address * 4, data, 4);
                memcpy(ctx->sector_ied + corrected_sector_address * 2, data + 4, 2);
                memcpy(ctx->sector_cpr_mai + corrected_sector_address * 6, data + 6, 6);
                memcpy(ctx->sector_edc + corrected_sector_address * 4, data + 2060, 4);
 
                return aaruf_write_sector(context, sector_address, negative, data + 12, sector_status, 2048);
            }
 
            // Nintendo DVD long sector
            if(length == 2064 && ctx->image_info.MediaType == GOD || ctx->image_info.MediaType == WOD)
            {
                if(ctx->sector_id == NULL) ctx->sector_id = calloc(1, 4 * total_sectors);
                if(ctx->sector_ied == NULL) ctx->sector_ied = calloc(1, 2 * total_sectors);
                if(ctx->sector_cpr_mai == NULL) ctx->sector_cpr_mai = calloc(1, 6 * total_sectors);
                if(ctx->sector_edc == NULL) ctx->sector_edc = calloc(1, 4 * total_sectors);
 
                memcpy(ctx->sector_id + corrected_sector_address * 4, data, 4);
                memcpy(ctx->sector_ied + corrected_sector_address * 2, data + 4, 2);
                memcpy(ctx->sector_cpr_mai + corrected_sector_address * 6, data + 2054, 6);
                memcpy(ctx->sector_edc + corrected_sector_address * 4, data + 2060, 4);
 
                return aaruf_write_sector(context, sector_address, negative, data + 6, sector_status, 2048);
            }
 
            // Blu-ray long sector
            if(length == 2052 && (ctx->image_info.MediaType == BDROM || ctx->image_info.MediaType == BDR ||
                                  ctx->image_info.MediaType == BDRE || ctx->image_info.MediaType == BDRXL ||
                                  ctx->image_info.MediaType == BDREXL || ctx->image_info.MediaType == UHDBD ||
                                  ctx->image_info.MediaType == XGD4 || ctx->image_info.MediaType == PS3BD ||
                                  ctx->image_info.MediaType == PS4BD || ctx->image_info.MediaType == PS5BD))
            {
                if(ctx->sector_edc == NULL) ctx->sector_edc = calloc(1, 4 * total_sectors);
 
                memcpy(ctx->sector_edc + corrected_sector_address * 4, data + 2048, 4);
 
                return aaruf_write_sector(context, sector_address, negative, data, sector_status, 2048);
            }
 
            if(length != 2352)
            {
                FATAL("Incorrect sector size");
                TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            ctx->writing_long = true;
 
            if(!ctx->rewinded)
            {
                if(sector_address <= ctx->last_written_block)
                {
                    if(sector_address == 0 && !ctx->block_zero_written)
                        ctx->block_zero_written = true;
                    else
                    {
                        TRACE("Rewinded");
                        ctx->rewinded = true;
 
                        // Disable MD5 calculation
                        if(ctx->calculating_md5) ctx->calculating_md5 = false;
                        // Disable SHA1 calculation
                        if(ctx->calculating_sha1) ctx->calculating_sha1 = false;
                        // Disable SHA256 calculation
                        if(ctx->calculating_sha256) ctx->calculating_sha256 = false;
                        // Disable SpamSum calculation
                        if(ctx->calculating_spamsum) ctx->calculating_spamsum = false;
                        // Disable BLAKE3 calculation
                        if(ctx->calculating_blake3) ctx->calculating_blake3 = false;
                    }
                }
                else
                    ctx->last_written_block = sector_address;
            }
 
            // Calculate MD5 on-the-fly if requested and sector is within user sectors (not negative or overflow)
            if(ctx->calculating_md5 && !negative && sector_address <= ctx->image_info.Sectors)
                aaruf_md5_update(&ctx->md5_context, data, length);
            // Calculate SHA1 on-the-fly if requested and sector is within user sectors (not negative or overflow)
            if(ctx->calculating_sha1 && !negative && sector_address <= ctx->image_info.Sectors)
                aaruf_sha1_update(&ctx->sha1_context, data, length);
            // Calculate SHA256 on-the-fly if requested and sector is within user sectors (not negative or overflow)
            if(ctx->calculating_sha256 && !negative && sector_address <= ctx->image_info.Sectors)
                aaruf_sha256_update(&ctx->sha256_context, data, length);
            // Calculate SpamSum on-the-fly if requested and sector is within user sectors (not negative or overflow)
            if(ctx->calculating_spamsum && !negative && sector_address <= ctx->image_info.Sectors)
                aaruf_spamsum_update(ctx->spamsum_context, data, length);
            // Calculate BLAKE3 on-the-fly if requested and sector is within user sectors (not negative or overflow)
            if(ctx->calculating_blake3 && !negative && sector_address <= ctx->image_info.Sectors)
                blake3_hasher_update(ctx->blake3_context, data, length);
 
            bool prefix_correct;
 
            // Split raw cd sector data in prefix (sync, header), user data and suffix (edc, ecc p, ecc q)
            switch(track.type)
            {
                case kTrackTypeAudio:
                case kTrackTypeData:
                    return aaruf_write_sector(context, sector_address, negative, data, sector_status, length);
                case kTrackTypeCdMode1:
 
                    // If we do not have a DDT V2 for sector prefix, create one
                    if(ctx->sector_prefix_ddt2 == NULL)
                    {
                        ctx->sector_prefix_ddt2 =
                            calloc(1, sizeof(uint64_t) * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors +
                                                          ctx->user_data_ddt_header.overflow));
 
                        if(ctx->sector_prefix_ddt2 == NULL)
                        {
                            FATAL("Could not allocate memory for CD sector prefix DDT");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
                    }
 
                    // If we do not have a DDT V2 for sector suffix, create one
                    if(ctx->sector_suffix_ddt2 == NULL)
                    {
                        ctx->sector_suffix_ddt2 =
                            calloc(1, sizeof(uint64_t) * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors +
                                                          ctx->user_data_ddt_header.overflow));
 
                        if(ctx->sector_suffix_ddt2 == NULL)
                        {
                            FATAL("Could not allocate memory for CD sector prefix DDT");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
                    }
 
                    if(ctx->sector_prefix == NULL)
                    {
                        ctx->sector_prefix_length = 16 * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors +
                                                          ctx->user_data_ddt_header.overflow);
                        ctx->sector_prefix        = calloc(1, ctx->sector_prefix_length);
 
                        if(ctx->sector_prefix == NULL)
                        {
                            FATAL("Could not allocate memory for CD sector prefix buffer");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
                    }
 
                    if(ctx->sector_suffix == NULL)
                    {
                        ctx->sector_suffix_length =
                            288 * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors +
                                   ctx->user_data_ddt_header.overflow);
                        ctx->sector_suffix = calloc(1, ctx->sector_suffix_length);
 
                        if(ctx->sector_suffix == NULL)
                        {
                            FATAL("Could not allocate memory for CD sector suffix buffer");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
                    }
 
                    bool empty = true;
 
                    for(int i = 0; i < length; i++)
                        if(data[i] != 0)
                        {
                            empty = false;
                            break;
                        }
 
                    if(empty)
                    {
                        ctx->sector_prefix_ddt2[corrected_sector_address] = (uint64_t)SectorStatusNotDumped << 60;
                        ctx->sector_suffix_ddt2[corrected_sector_address] = (uint64_t)SectorStatusNotDumped << 60;
                        ctx->dirty_sector_prefix_ddt                      = true;  // Mark prefix DDT as dirty
                        ctx->dirty_sector_suffix_ddt                      = true;  // Mark suffix DDT as dirty
                        return aaruf_write_sector(context, sector_address, negative, data + 16, SectorStatusNotDumped,
                                                  2048);
                    }
 
                    prefix_correct = true;
 
                    if(data[0x00] != 0x00 || data[0x01] != 0xFF || data[0x02] != 0xFF || data[0x03] != 0xFF ||
                       data[0x04] != 0xFF || data[0x05] != 0xFF || data[0x06] != 0xFF || data[0x07] != 0xFF ||
                       data[0x08] != 0xFF || data[0x09] != 0xFF || data[0x0A] != 0xFF || data[0x0B] != 0x00 ||
                       data[0x0F] != 0x01)
                        prefix_correct = false;
 
                    if(prefix_correct) prefix_correct = cd_header_matches_lba(data, signed_lba);
 
                    if(prefix_correct)
                        ctx->sector_prefix_ddt2[corrected_sector_address] = (uint64_t)SectorStatusMode1Correct << 60;
                    else
                    {
                        // Copy CD prefix from data buffer to prefix buffer
                        if(grow_arena(&ctx->sector_prefix, &ctx->sector_prefix_length, ctx->sector_prefix_offset + 16,
                                      16 * total_sectors) != AARUF_STATUS_OK)
                        {
                            FATAL("Could not allocate memory for CD sector prefix buffer");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
 
                        memcpy(ctx->sector_prefix + ctx->sector_prefix_offset, data, 16);
                        ctx->sector_prefix_ddt2[corrected_sector_address] = (uint64_t)(ctx->sector_prefix_offset / 16);
                        ctx->sector_prefix_ddt2[corrected_sector_address] |= (uint64_t)SectorStatusErrored << 60;
                        ctx->sector_prefix_offset += 16;
                        ctx->dirty_sector_prefix_block = true;  // Mark prefix block as dirty
                    }
                    ctx->dirty_sector_prefix_ddt = true;  // Mark prefix DDT as dirty
 
                    const bool suffix_correct = aaruf_ecc_cd_is_suffix_correct(ctx->ecc_cd_context, data);
 
                    if(suffix_correct)
                        ctx->sector_suffix_ddt2[corrected_sector_address] = (uint64_t)SectorStatusMode1Correct << 60;
                    else
                    {
                        // Copy CD suffix from data buffer to suffix buffer
                        if(grow_arena(&ctx->sector_suffix, &ctx->sector_suffix_length, ctx->sector_suffix_offset + 288,
                                      288 * total_sectors) != AARUF_STATUS_OK)
                        {
                            FATAL("Could not allocate memory for CD sector suffix buffer");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
 
                        memcpy(ctx->sector_suffix + ctx->sector_suffix_offset, data + 2064, 288);
                        ctx->sector_suffix_ddt2[corrected_sector_address] = (uint64_t)(ctx->sector_suffix_offset / 288);
                        ctx->sector_suffix_ddt2[corrected_sector_address] |= (uint64_t)SectorStatusErrored << 60;
                        ctx->sector_suffix_offset += 288;
                        ctx->dirty_sector_suffix_block = true;  // Mark suffix block as dirty
                    }
                    ctx->dirty_sector_suffix_ddt = true;  // Mark suffix DDT as dirty
 
                    return aaruf_write_sector(context, sector_address, negative, data + 16,
                                              prefix_correct && suffix_correct ? SectorStatusMode1Correct
                                                                               : SectorStatusErrored,
                                              2048);
                case kTrackTypeCdMode2Form1:
                case kTrackTypeCdMode2Form2:
                case kTrackTypeCdMode2Formless:
                    // If we do not have a DDT V2 for sector prefix, create one
                    if(ctx->sector_prefix_ddt2 == NULL)
                    {
                        ctx->sector_prefix_ddt2 =
                            calloc(1, sizeof(uint64_t) * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors +
                                                          ctx->user_data_ddt_header.overflow));
 
                        if(ctx->sector_prefix_ddt2 == NULL)
                        {
                            FATAL("Could not allocate memory for CD sector prefix DDT");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
                    }
 
                    // If we do not have a DDT V2 for sector suffix, create one
                    if(ctx->sector_suffix_ddt2 == NULL)
                    {
                        ctx->sector_suffix_ddt2 =
                            calloc(1, sizeof(uint64_t) * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors +
                                                          ctx->user_data_ddt_header.overflow));
 
                        if(ctx->sector_suffix_ddt2 == NULL)
                        {
                            FATAL("Could not allocate memory for CD sector prefix DDT");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
                    }
 
                    if(ctx->sector_prefix == NULL)
                    {
                        ctx->sector_prefix_length = 16 * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors +
                                                          ctx->user_data_ddt_header.overflow);
                        ctx->sector_prefix        = calloc(1, ctx->sector_prefix_length);
 
                        if(ctx->sector_prefix == NULL)
                        {
                            FATAL("Could not allocate memory for CD sector prefix buffer");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
                    }
 
                    if(ctx->sector_suffix == NULL)
                    {
                        ctx->sector_suffix_length =
                            288 * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors +
                                   ctx->user_data_ddt_header.overflow);
                        ctx->sector_suffix = calloc(1, ctx->sector_suffix_length);
 
                        if(ctx->sector_suffix == NULL)
                        {
                            FATAL("Could not allocate memory for CD sector suffix buffer");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
                    }
 
                    empty = true;
 
                    for(int i = 0; i < length; i++)
                        if(data[i] != 0)
                        {
                            empty = false;
                            break;
                        }
 
                    if(empty)
                    {
                        ctx->sector_prefix_ddt2[corrected_sector_address] = (uint64_t)SectorStatusNotDumped << 60;
                        ctx->sector_suffix_ddt2[corrected_sector_address] = (uint64_t)SectorStatusNotDumped << 60;
                        ctx->dirty_sector_prefix_ddt                      = true;  // Mark prefix DDT as dirty
                        ctx->dirty_sector_suffix_ddt                      = true;  // Mark suffix DDT as dirty
                        return aaruf_write_sector(context, sector_address, negative, data + 16, SectorStatusNotDumped,
                                                  2328);
                    }
 
                    const bool form2 = (data[18] & 0x20) == 0x20 || (data[22] & 0x20) == 0x20;
 
                    prefix_correct = true;
 
                    if(data[0x00] != 0x00 || data[0x01] != 0xFF || data[0x02] != 0xFF || data[0x03] != 0xFF ||
                       data[0x04] != 0xFF || data[0x05] != 0xFF || data[0x06] != 0xFF || data[0x07] != 0xFF ||
                       data[0x08] != 0xFF || data[0x09] != 0xFF || data[0x0A] != 0xFF || data[0x0B] != 0x00 ||
                       data[0x0F] != 0x02)
                        prefix_correct = false;
 
                    if(prefix_correct) prefix_correct = cd_header_matches_lba(data, signed_lba);
 
                    if(prefix_correct)
                        ctx->sector_prefix_ddt2[corrected_sector_address] =
                            (uint64_t)(form2 ? SectorStatusMode2Form2Ok : SectorStatusMode2Form1Ok) << 60;
                    else
                    {
                        // Copy CD prefix from data buffer to prefix buffer
                        if(grow_arena(&ctx->sector_prefix, &ctx->sector_prefix_length, ctx->sector_prefix_offset + 16,
                                      16 * total_sectors) != AARUF_STATUS_OK)
                        {
                            FATAL("Could not allocate memory for CD sector prefix buffer");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
 
                        memcpy(ctx->sector_prefix + ctx->sector_prefix_offset, data, 16);
                        ctx->sector_prefix_ddt2[corrected_sector_address] = (uint64_t)(ctx->sector_prefix_offset / 16);
                        ctx->sector_prefix_ddt2[corrected_sector_address] |= (uint64_t)SectorStatusErrored << 60;
                        ctx->sector_prefix_offset += 16;
                        ctx->dirty_sector_prefix_block = true;  // Mark prefix block as dirty
                    }
                    ctx->dirty_sector_prefix_ddt = true;  // Mark prefix DDT as dirty
 
                    if(ctx->mode2_subheaders == NULL)
                    {
                        ctx->mode2_subheaders =
                            calloc(1, 8 * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors +
                                           ctx->user_data_ddt_header.overflow));
 
                        if(ctx->mode2_subheaders == NULL)
                        {
                            FATAL("Could not allocate memory for CD mode 2 subheader buffer");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
                    }
 
                    if(form2)
                    {
                        const uint32_t computed_edc = aaruf_edc_cd_compute(ctx->ecc_cd_context, 0, data, 0x91C, 0x10);
                        uint32_t       edc          = 0;
                        memcpy(&edc, data + 0x92C, sizeof(edc));
                        const bool correct_edc = computed_edc == edc;
 
                        if(correct_edc)
                            ctx->sector_suffix_ddt2[corrected_sector_address] = (uint64_t)SectorStatusMode2Form2Ok
                                                                                << 60;
                        else if(edc == 0)
                            ctx->sector_suffix_ddt2[corrected_sector_address] = (uint64_t)SectorStatusMode2Form2NoCrc
                                                                                << 60;
                        else
                        {
                            // Copy CD suffix from data buffer to suffix buffer
                            if(grow_arena(&ctx->sector_suffix, &ctx->sector_suffix_length,
                                          ctx->sector_suffix_offset + 288, 288 * total_sectors) != AARUF_STATUS_OK)
                            {
                                FATAL("Could not allocate memory for CD sector suffix buffer");
 
                                TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                            }
 
                            memset(ctx->sector_suffix + ctx->sector_suffix_offset, 0, 288);
                            memcpy(ctx->sector_suffix + ctx->sector_suffix_offset, data + 2348, 4);
                            ctx->sector_suffix_ddt2[corrected_sector_address] =
                                (uint64_t)(ctx->sector_suffix_offset / 288);
                            ctx->sector_suffix_ddt2[corrected_sector_address] |= (uint64_t)SectorStatusErrored << 60;
                            ctx->sector_suffix_offset += 288;
                            ctx->dirty_sector_suffix_block = true;  // Mark suffix block as dirty
                        }
 
                        // Copy subheader from data buffer to subheader buffer
                        memcpy(ctx->mode2_subheaders + corrected_sector_address * 8, data + 0x10, 8);
                        ctx->dirty_sector_prefix_ddt      = true;
                        ctx->dirty_sector_suffix_ddt      = true;
                        ctx->dirty_mode2_subheaders_block = true;
                        return aaruf_write_sector(context, sector_address, negative, data + 24,
                                                  edc == 0      ? SectorStatusMode2Form2NoCrc
                                                  : correct_edc ? SectorStatusMode2Form2Ok
                                                                : SectorStatusErrored,
                                                  2324);
                    }
 
                    const bool     correct_ecc  = aaruf_ecc_cd_is_suffix_correct_mode2(ctx->ecc_cd_context, data);
                    const uint32_t computed_edc = aaruf_edc_cd_compute(ctx->ecc_cd_context, 0, data, 0x808, 0x10);
                    uint32_t       edc          = 0;
                    memcpy(&edc, data + 0x818, sizeof(edc));
                    const bool correct_edc = computed_edc == edc;
 
                    if(correct_ecc && correct_edc)
                        ctx->sector_suffix_ddt2[corrected_sector_address] = (uint64_t)SectorStatusMode2Form1Ok << 60;
                    else
                    {
                        // Copy CD suffix from data buffer to suffix buffer
                        if(grow_arena(&ctx->sector_suffix, &ctx->sector_suffix_length, ctx->sector_suffix_offset + 288,
                                      288 * total_sectors) != AARUF_STATUS_OK)
                        {
                            FATAL("Could not allocate memory for CD sector suffix buffer");
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
 
                        memset(ctx->sector_suffix + ctx->sector_suffix_offset, 0, 288);
                        memcpy(ctx->sector_suffix + ctx->sector_suffix_offset, data + 2072, 280);
                        ctx->sector_suffix_ddt2[corrected_sector_address] = (uint64_t)(ctx->sector_suffix_offset / 288);
                        ctx->sector_suffix_ddt2[corrected_sector_address] |= (uint64_t)SectorStatusErrored << 60;
                        ctx->sector_suffix_offset += 288;
                        ctx->dirty_sector_suffix_block = true;  // Mark suffix block as dirty
                    }
 
                    // Copy subheader from data buffer to subheader buffer
                    memcpy(ctx->mode2_subheaders + corrected_sector_address * 8, data + 0x10, 8);
                    ctx->dirty_sector_prefix_ddt      = true;
                    ctx->dirty_sector_suffix_ddt      = true;
                    ctx->dirty_mode2_subheaders_block = true;
                    return aaruf_write_sector(
                        context, sector_address, negative, data + 24,
                        correct_edc && correct_ecc ? SectorStatusMode2Form1Ok : SectorStatusErrored, 2048);
            }
 
            break;
        }
        case BlockMedia:
            switch(ctx->image_info.MediaType)
            {
                case AppleFileWare:
                case AppleProfile:
                case AppleSonyDS:
                case AppleSonySS:
                case AppleWidget:
                case PriamDataTower:
                {
                    uint8_t *newTag;
                    int      newTagSize = 0;
 
                    switch(length - 512)
                    {
                        // Sony tag
                        case 12:
                        {
                            const sony_tag decoded_sony_tag = bytes_to_sony_tag(data + 512);
 
                            if(ctx->image_info.MediaType == AppleProfile || ctx->image_info.MediaType == AppleFileWare)
                            {
                                const profile_tag decoded_profile_tag = sony_tag_to_profile(decoded_sony_tag);
                                newTag                                = profile_tag_to_bytes(decoded_profile_tag);
                                newTagSize                            = 20;
                            }
                            else if(ctx->image_info.MediaType == PriamDataTower)
                            {
                                const priam_tag decoded_priam_tag = sony_tag_to_priam(decoded_sony_tag);
                                newTag                            = priam_tag_to_bytes(decoded_priam_tag);
                                newTagSize                        = 24;
                            }
                            else if(ctx->image_info.MediaType == AppleSonyDS ||
                                    ctx->image_info.MediaType == AppleSonySS)
                            {
                                newTag = malloc(12);
                                memcpy(newTag, data + 512, 12);
                                newTagSize = 12;
                            }
                            break;
                        }
                            // Profile tag
                        case 20:
                        {
                            const profile_tag decoded_profile_tag = bytes_to_profile_tag(data + 512);
 
                            if(ctx->image_info.MediaType == AppleProfile || ctx->image_info.MediaType == AppleFileWare)
                            {
                                newTag = malloc(20);
                                memcpy(newTag, data + 512, 20);
                                newTagSize = 20;
                            }
                            else if(ctx->image_info.MediaType == PriamDataTower)
                            {
                                const priam_tag decoded_priam_tag = profile_tag_to_priam(decoded_profile_tag);
                                newTag                            = priam_tag_to_bytes(decoded_priam_tag);
                                newTagSize                        = 24;
                            }
                            else if(ctx->image_info.MediaType == AppleSonyDS ||
                                    ctx->image_info.MediaType == AppleSonySS)
                            {
                                const sony_tag decoded_sony_tag = profile_tag_to_sony(decoded_profile_tag);
                                newTag                          = sony_tag_to_bytes(decoded_sony_tag);
                                newTagSize                      = 12;
                            }
                            break;
                        }
                            // Priam tag
                        case 24:
                        {
                            const priam_tag decoded_priam_tag = bytes_to_priam_tag(data + 512);
                            if(ctx->image_info.MediaType == AppleProfile || ctx->image_info.MediaType == AppleFileWare)
                            {
                                const profile_tag decoded_profile_tag = priam_tag_to_profile(decoded_priam_tag);
                                newTag                                = profile_tag_to_bytes(decoded_profile_tag);
                                newTagSize                            = 20;
                            }
                            else if(ctx->image_info.MediaType == PriamDataTower)
                            {
                                newTag = malloc(24);
                                memcpy(newTag, data + 512, 24);
                                newTagSize = 24;
                            }
                            else if(ctx->image_info.MediaType == AppleSonyDS ||
                                    ctx->image_info.MediaType == AppleSonySS)
                            {
                                const sony_tag decoded_sony_tag = priam_tag_to_sony(decoded_priam_tag);
                                newTag                          = sony_tag_to_bytes(decoded_sony_tag);
                                newTagSize                      = 12;
                            }
                            break;
                        }
                        case 0:
                            newTagSize = 0;
                            break;
                        default:
                            FATAL("Incorrect sector size");
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                            return AARUF_ERROR_INCORRECT_DATA_SIZE;
                    }
 
                    if(newTagSize == 0)
                        return aaruf_write_sector(context, sector_address, negative, data, sector_status, 512);
 
                    if(ctx->sector_subchannel == NULL)
                    {
                        ctx->sector_subchannel =
                            calloc(1, newTagSize * (ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow));
 
                        if(ctx->sector_subchannel == NULL)
                        {
                            FATAL("Could not allocate memory for sector subchannel DDT");
 
                            free(newTag);
 
                            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                        }
                    }
 
                    memcpy(ctx->sector_subchannel + sector_address * newTagSize, newTag, newTagSize);
                    ctx->dirty_sector_subchannel_block = true;  // Mark subchannel block as dirty
                    free(newTag);
 
                    return aaruf_write_sector(context, sector_address, negative, data, sector_status, 512);
                }
                default:
                    return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
        default:
            TRACE("Exiting aaruf_write_sector() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
            return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
    }
 
    // Fallback return when media type branch does not produce a value (satisfy non-void contract)
    return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
}

int32_t aaruf_close_current_block(aaruformat_context *ctx)
{
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC) return AARUF_ERROR_NOT_AARUFORMAT;
 
    // Check we are writing
    if(!ctx->is_writing) return AARUF_READ_ONLY;
 
    ctx->current_block_header.length = ctx->current_block_offset * ctx->current_block_header.sectorSize;
 
    TRACE("Initializing CRC64 context");
    ctx->crc64_context = aaruf_crc64_init();
    TRACE("Updating CRC64");
    aaruf_crc64_update(ctx->crc64_context, ctx->writing_buffer, ctx->current_block_header.length);
    aaruf_crc64_final(ctx->crc64_context, &ctx->current_block_header.crc64);
 
    uint8_t  lzma_properties[LZMA_PROPERTIES_LENGTH] = {0};
    uint8_t *cmp_buffer                              = NULL;
 
    switch(ctx->current_block_header.compression)
    {
        case kCompressionNone:
            break;
        case kCompressionFlac:
            cmp_buffer = malloc(ctx->current_block_header.length * 2);
            if(cmp_buffer == NULL)
            {
                FATAL("Could not allocate buffer for compressed data");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
            const uint32_t current_samples = ctx->current_block_offset * SAMPLES_PER_SECTOR;
            uint32_t       flac_block_size = ctx->current_block_offset * SAMPLES_PER_SECTOR;
 
            if(flac_block_size > MAX_FLAKE_BLOCK) flac_block_size = MAX_FLAKE_BLOCK;
            if(flac_block_size < MIN_FLAKE_BLOCK) flac_block_size = MIN_FLAKE_BLOCK;
 
            const long remaining = current_samples % flac_block_size;
 
            // Fill FLAC block
            if(remaining != 0)
                for(int r = 0; r < remaining * 4; r++) ctx->writing_buffer[ctx->writing_buffer_position + r] = 0;
 
            ctx->current_block_header.cmpLength = aaruf_flac_encode_redbook_buffer(
                cmp_buffer, ctx->current_block_header.length * 2, ctx->writing_buffer, ctx->current_block_header.length,
                flac_block_size, true, false, "hamming", 12, 15, true, false, 0, 8, "Aaru", 4);
 
            if(ctx->current_block_header.cmpLength >= ctx->current_block_header.length)
            {
                ctx->current_block_header.compression = kCompressionNone;
                free(cmp_buffer);
            }
 
            break;
        case kCompressionLzma:
            cmp_buffer = malloc(ctx->current_block_header.length * 2);
            if(cmp_buffer == NULL)
            {
                FATAL("Could not allocate buffer for compressed data");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            size_t dst_size   = ctx->current_block_header.length * 2;
            size_t props_size = LZMA_PROPERTIES_LENGTH;
            aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, ctx->writing_buffer, ctx->current_block_header.length,
                                     lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0, 2, 273, LZMA_THREADS(ctx));
 
            ctx->current_block_header.cmpLength = (uint32_t)dst_size;
 
            if(ctx->current_block_header.cmpLength >= ctx->current_block_header.length)
            {
                ctx->current_block_header.compression = kCompressionNone;
                free(cmp_buffer);
            }
 
            break;
        case kCompressionZstd:
            cmp_buffer = malloc(ctx->current_block_header.length * 2);
            if(cmp_buffer == NULL)
            {
                FATAL("Could not allocate buffer for compressed data");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            size_t zstd_dst_size =
                aaruf_zstd_encode_buffer(cmp_buffer, ctx->current_block_header.length * 2, ctx->writing_buffer,
                                         ctx->current_block_header.length, ctx->zstd_level, ctx->num_threads);
 
            if(zstd_dst_size == 0)
            {
                ctx->current_block_header.compression = kCompressionNone;
                free(cmp_buffer);
                cmp_buffer = NULL;
            }
            else
            {
                ctx->current_block_header.cmpLength = (uint32_t)zstd_dst_size;
 
                if(ctx->current_block_header.cmpLength >= ctx->current_block_header.length)
                {
                    ctx->current_block_header.compression = kCompressionNone;
                    free(cmp_buffer);
                    cmp_buffer = NULL;
                }
                else
                    ctx->has_zstd_blocks = true;
            }
 
            break;
        default:
            FATAL("Invalid compression type");
            return AARUF_ERROR_CANNOT_WRITE_BLOCK_DATA;
    }
 
    if(ctx->current_block_header.compression == kCompressionNone)
    {
        ctx->current_block_header.cmpCrc64  = ctx->current_block_header.crc64;
        ctx->current_block_header.cmpLength = ctx->current_block_header.length;
    }
    else
        ctx->current_block_header.cmpCrc64 = aaruf_crc64_data(cmp_buffer, ctx->current_block_header.cmpLength);
 
    if(ctx->current_block_header.compression == kCompressionLzma)
        ctx->current_block_header.cmpLength += LZMA_PROPERTIES_LENGTH;
 
    // Add to index
    TRACE("Adding block to index");
    IndexEntry index_entry;
    index_entry.blockType = DataBlock;
    index_entry.dataType  = kDataTypeUserData;
    index_entry.offset    = ctx->next_block_position;
 
    utarray_push_back(ctx->index_entries, &index_entry);
    ctx->dirty_index_block = true;  // Mark index block as dirty
    TRACE("Block added to index at offset %" PRIu64, index_entry.offset);
 
    // Write block header to file
 
    // Move to expected block position
    aaruf_fseek(ctx->imageStream, (aaru_off_t)ctx->next_block_position, SEEK_SET);
 
    // Write block header
    if(fwrite(&ctx->current_block_header, sizeof(BlockHeader), 1, ctx->imageStream) != 1)
        return AARUF_ERROR_CANNOT_WRITE_BLOCK_HEADER;
 
    // Write block data
    if(ctx->current_block_header.compression == kCompressionLzma &&
       fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream) != 1)
    {
        free(cmp_buffer);
        return AARUF_ERROR_CANNOT_WRITE_BLOCK_DATA;
    }
 
    if(ctx->current_block_header.compression == kCompressionNone)
    {
        if(fwrite(ctx->writing_buffer, ctx->current_block_header.length, 1, ctx->imageStream) != 1)
            return AARUF_ERROR_CANNOT_WRITE_BLOCK_DATA;
    }
    else
    {
        if(fwrite(cmp_buffer, ctx->current_block_header.cmpLength, 1, ctx->imageStream) != 1)
        {
            free(cmp_buffer);
            return AARUF_ERROR_CANNOT_WRITE_BLOCK_DATA;
        }
    }
 
    /* --- Erasure coding parity accumulation ---
     * Call BEFORE freeing cmp_buffer / writing_buffer.
     * For LZMA: cmpLength already includes LZMA_PROPERTIES_LENGTH, but the properties
     * were written separately. We pass them as lzma_props parameter.
     * For non-LZMA compressed: cmp_buffer holds all payload.
     * For uncompressed: writing_buffer holds payload. */
    if(ctx->ec_enabled)
    {
        const uint8_t *ec_payload;
        uint32_t ec_payload_size;
        const uint8_t *ec_lzma_props = NULL;
 
        if(ctx->current_block_header.compression == kCompressionNone)
        {
            ec_payload      = ctx->writing_buffer;
            ec_payload_size = ctx->current_block_header.length;
        }
        else if(ctx->current_block_header.compression == kCompressionLzma)
        {
            ec_payload      = cmp_buffer;
            ec_payload_size = ctx->current_block_header.cmpLength - LZMA_PROPERTIES_LENGTH;
            ec_lzma_props   = lzma_properties;
        }
        else
        {
            ec_payload      = cmp_buffer;
            ec_payload_size = ctx->current_block_header.cmpLength;
        }
 
        ec_accumulate_data_block(ctx, &ctx->current_block_header, ec_lzma_props,
                                 ec_payload, ec_payload_size, index_entry.offset);
    }
 
    /* Free compressed buffer (if compression was used) */
    if(ctx->current_block_header.compression != kCompressionNone)
        free(cmp_buffer);
 
    // Update nextBlockPosition to point to the next available aligned position
    const uint64_t block_total_size = sizeof(BlockHeader) + ctx->current_block_header.cmpLength;
    const uint64_t alignment_mask   = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1;
    ctx->next_block_position        = ctx->next_block_position + block_total_size + alignment_mask & ~alignment_mask;
    TRACE("Updated nextBlockPosition to %" PRIu64, ctx->next_block_position);
 
    // Clear values
    free(ctx->writing_buffer);
    ctx->writing_buffer       = NULL;
    ctx->current_block_offset = 0;
    memset(&ctx->current_block_header, 0, sizeof(BlockHeader));
    aaruf_crc64_free(ctx->crc64_context);
    ctx->writing_buffer_position = 0;
 
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_write_media_tag(void *context, const uint8_t *data, const int32_t type,
                                                    const uint32_t length)
{
    TRACE("Entering aaruf_write_media_tag(%p, %p, %d, %d)", context, data, type, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_write_media_tag() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    aaruformat_context *ctx = context;
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_write_media_tag() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_write_media_tag() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(data == NULL || length == 0)
    {
        FATAL("Invalid data or length");
        return AARUF_ERROR_INCORRECT_DATA_SIZE;
    }
 
    uint8_t *new_data = malloc(length);
 
    if(new_data == NULL)
    {
        FATAL("Could not allocate memory for media tag");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
    memcpy(new_data, data, length);
 
    mediaTagEntry *media_tag     = malloc(sizeof(mediaTagEntry));
    mediaTagEntry *old_media_tag = NULL;
 
    if(media_tag == NULL)
    {
        TRACE("Cannot allocate memory for media tag entry.");
        free(new_data);
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    memset(media_tag, 0, sizeof(mediaTagEntry));
 
    media_tag->type   = type;
    media_tag->data   = new_data;
    media_tag->length = length;
 
    HASH_REPLACE_INT(ctx->mediaTags, type, media_tag, old_media_tag);
 
    if(old_media_tag != NULL)
    {
        TRACE("Replaced media tag with type %d", old_media_tag->type);
        free(old_media_tag->data);
        free(old_media_tag);
        old_media_tag = NULL;
    }
 
    ctx->dirty_media_tags = true;  // Mark media tags as dirty
    TRACE("Exiting aaruf_write_media_tag() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_write_sector_tag(void *context, const uint64_t sector_address, const bool negative,
                                                     const uint8_t *data, const size_t length, const int32_t tag)
{
    TRACE("Entering aaruf_write_sector_tag(%p, %" PRIu64 ", %d, %p, %zu, %d)", context, sector_address, negative, data,
          length, tag);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    aaruformat_context *ctx = context;
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_write_sector_tag() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Flux-only images carry no DDT and no per-sector tag storage.
    if(ctx->no_user_data_ddt)
    {
        FATAL("Cannot write sector tag to flux-only image (no user-data DDT)");
 
        TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_USER_DATA_NOT_PRESENT");
        return AARUF_ERROR_USER_DATA_NOT_PRESENT;
    }
 
    if(negative && sector_address > ctx->user_data_ddt_header.negative)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    if(data == NULL || length == 0)
    {
        FATAL("Invalid data or length");
        return AARUF_ERROR_INCORRECT_DATA_SIZE;
    }
 
    uint64_t corrected_sector_address = sector_address;
 
    // Calculate positive or negative sector
    if(negative)
        corrected_sector_address = ctx->user_data_ddt_header.negative - sector_address;
    else
        corrected_sector_address += ctx->user_data_ddt_header.negative;
 
    const uint64_t total_sectors =
        ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow;
 
    switch(tag)
    {
        case kSectorTagCdTrackFlags:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 1)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            for(int i = 0; i < ctx->tracks_header.entries; i++)
                if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end)
                {
                    ctx->track_entries[i].flags = data[0];
                    ctx->dirty_tracks_block     = true;  // Mark tracks block as dirty
                    TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
                    return AARUF_STATUS_OK;
                }
 
            FATAL("Track not found");
            return AARUF_ERROR_TRACK_NOT_FOUND;
        case kSectorTagCdTrackIsrc:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 12)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            for(int i = 0; i < ctx->tracks_header.entries; i++)
                if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end)
                {
                    memcpy(ctx->track_entries[i].isrc, data, 12);
                    ctx->dirty_tracks_block = true;  // Mark tracks block as dirty
                    TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
                    return AARUF_STATUS_OK;
                }
 
            FATAL("Track not found");
            return AARUF_ERROR_TRACK_NOT_FOUND;
        case kSectorTagCdSubchannel:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 96)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_subchannel == NULL) ctx->sector_subchannel = calloc(1, 96 * total_sectors);
 
            if(ctx->sector_subchannel == NULL)
            {
                FATAL("Could not allocate memory for sector subchannel");
 
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(ctx->sector_subchannel + corrected_sector_address * 96, data, 96);
            ctx->dirty_sector_subchannel_block = true;  // Mark subchannel block as dirty
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case kSectorTagDvdCmi:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 1)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_cpr_mai == NULL) ctx->sector_cpr_mai = calloc(1, 6 * total_sectors);
 
            if(ctx->sector_cpr_mai == NULL)
            {
                FATAL("Could not allocate memory for sector CPR/MAI");
 
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(ctx->sector_cpr_mai + corrected_sector_address * 6, data, 1);
            ctx->dirty_dvd_long_sector_blocks = true;  // Mark DVD long sector blocks as dirty
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case kSectorTagDvdSectorInformation:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 1)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_id == NULL) ctx->sector_id = calloc(1, 4 * total_sectors);
 
            if(ctx->sector_id == NULL)
            {
                FATAL("Could not allocate memory for sector ID");
 
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(ctx->sector_id + corrected_sector_address * 4, data, 1);
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case kSectorTagDvdSectorNumber:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 3)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_id == NULL) ctx->sector_id = calloc(1, 4 * total_sectors);
 
            if(ctx->sector_id == NULL)
            {
                FATAL("Could not allocate memory for sector ID");
 
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(ctx->sector_id + corrected_sector_address * 4 + 1, data, 3);
            ctx->dirty_dvd_long_sector_blocks = true;  // Mark DVD long sector blocks as dirty
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case kSectorTagDvdSectorIed:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 2)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_ied == NULL) ctx->sector_ied = calloc(1, 2 * total_sectors);
 
            if(ctx->sector_ied == NULL)
            {
                FATAL("Could not allocate memory for sector IED");
 
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(ctx->sector_ied + corrected_sector_address * 2, data, 2);
            ctx->dirty_dvd_long_sector_blocks = true;  // Mark DVD long sector blocks as dirty
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case kSectorTagDvdSectorEdc:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 4)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_edc == NULL) ctx->sector_edc = calloc(1, 4 * total_sectors);
 
            if(ctx->sector_edc == NULL)
            {
                FATAL("Could not allocate memory for sector EDC");
 
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(ctx->sector_edc + corrected_sector_address * 4, data, 4);
            ctx->dirty_dvd_long_sector_blocks = true;  // Mark DVD long sector blocks as dirty
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case kSectorTagDvdTitleKeyDecrypted:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 5)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_decrypted_title_key == NULL) ctx->sector_decrypted_title_key = calloc(1, 5 * total_sectors);
 
            if(ctx->sector_decrypted_title_key == NULL)
            {
                FATAL("Could not allocate memory for sector decrypted title key");
 
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(ctx->sector_decrypted_title_key + corrected_sector_address * 5, data, 5);
            ctx->dirty_dvd_title_key_decrypted_block = true;  // Mark title key block as dirty
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case kSectorTagAppleSony:
            if(ctx->image_info.MetadataMediaType != BlockMedia)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 12)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_subchannel == NULL) ctx->sector_subchannel = calloc(1, 12 * total_sectors);
 
            if(ctx->sector_subchannel == NULL)
            {
                FATAL("Could not allocate memory for Apple Sony tag");
 
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(ctx->sector_subchannel + corrected_sector_address * 12, data, 12);
            ctx->dirty_sector_subchannel_block = true;  // Mark subchannel block as dirty
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case kSectorTagAppleProfile:
            if(ctx->image_info.MetadataMediaType != BlockMedia)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 20)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_subchannel == NULL) ctx->sector_subchannel = calloc(1, 20 * total_sectors);
 
            if(ctx->sector_subchannel == NULL)
            {
                FATAL("Could not allocate memory for Apple Profile tag");
 
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(ctx->sector_subchannel + corrected_sector_address * 20, data, 20);
            ctx->dirty_sector_subchannel_block = true;  // Mark subchannel block as dirty
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case kSectorTagPriamDataTower:
            if(ctx->image_info.MetadataMediaType != BlockMedia)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(length != 24)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_subchannel == NULL) ctx->sector_subchannel = calloc(1, 24 * total_sectors);
 
            if(ctx->sector_subchannel == NULL)
            {
                FATAL("Could not allocate memory for Priam Data Tower tag");
 
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            memcpy(ctx->sector_subchannel + corrected_sector_address * 24, data, 24);
            ctx->dirty_sector_subchannel_block = true;  // Mark subchannel block as dirty
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case kSectorTagBdSectorEdc:
            if(ctx->image_info.MetadataMediaType != BlockMedia)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
            
            if(length != 4)
            {
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
            
            if(ctx->sector_edc == NULL) ctx->sector_edc = calloc(1, 4 * total_sectors);
            
            if(ctx->sector_edc == NULL)
            {
                FATAL("Could not allocate memory for Blu-ray sector EDC");
                
                TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
            
            memcpy(ctx->sector_edc + corrected_sector_address * 4, data, 4);
            ctx->dirty_bd_sector_edc_block = true;  // Mark BD sector EDC block as dirty
            TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        default:
            TRACE("Do not know how to write sector tag %d", tag);
            return AARUF_ERROR_INVALID_TAG;
    }
}