Task 455: .NPR File Format

File Format Specifications for .NPR

The .NPR file format is a proprietary binary format used by Steinberg Nuendo for audio project files. It stores project data including audio track information, loops, effects, and mixing settings. It is based on the RIFF (Resource Interchange File Format) structure, which is a chunk-based format commonly used in multimedia files like WAV or AVI. The RIFF type for .NPR is "NUND". The format is not publicly documented in detail, so full decoding requires reverse engineering. The header is identical to that of Cubase .CPR files (which use the same RIFF structure but with potential differences in chunks).

List of all properties of this file format intrinsic to its file system:

• Magic number: 'RIFF' (4 bytes, ASCII).
• Chunk size: 4-byte little-endian unsigned integer representing the size of the entire file minus 8 bytes (header size).
• Format type: 'NUND' (4 bytes, ASCII, identifying it as a Nuendo project).
• Chunks: Variable-length RIFF chunks following the header, each with a 4-byte chunk ID, 4-byte size, and data. These contain proprietary data such as audio events, track settings, plugin parameters, and references to external audio files (e.g., WAV paths). Specific chunk IDs and structures are not publicly specified, but common ones may include lists of tracks, automation data, and metadata.

Two direct download links for files of format .NPR:

• https://flux-shared.s3.amazonaws.com/RESSOURCES/PRODUCTS TEMPLATES/Nuendo/NUENDO - SPAT tuto template.zip (ZIP archive containing a sample .NPR Nuendo tutorial project file).
• https://flux-shared.s3.amazonaws.com/RESSOURCES/PRODUCTS TEMPLATES/Nuendo/NUENDO - SPAT Basic template.zip (ZIP archive containing a basic music .NPR Nuendo project file).

Ghost blog embedded HTML JavaScript for drag-and-drop .NPR file dump:

1. Python class for .NPR file handling:

import struct
import os

class NPRFile:
    def __init__(self, filepath):
        self.filepath = filepath
        self.magic = None
        self.chunk_size = None
        self.format_type = None

    def read(self):
        with open(self.filepath, 'rb') as f:
            header = f.read(12)
            if len(header) < 12:
                raise ValueError("File too small for .NPR header")
            self.magic = header[0:4].decode('ascii')
            self.chunk_size = struct.unpack('<I', header[4:8])[0]
            self.format_type = header[8:12].decode('ascii')
            # Further chunks would be parsed here if specs were available

    def print_properties(self):
        if not self.magic:
            self.read()
        print(f"Magic number: {self.magic}")
        print(f"Chunk size: {self.chunk_size}")
        print(f"Format type: {self.format_type}")
        print("(Note: Further chunks are proprietary and not printed here.)")

    def write(self, new_filepath=None):
        if not new_filepath:
            new_filepath = self.filepath + '.new'
        with open(new_filepath, 'wb') as f:
            f.write(self.magic.encode('ascii') if self.magic else b'RIFF')
            f.write(struct.pack('<I', self.chunk_size if self.chunk_size else 4))  # Minimal size for empty file
            f.write(self.format_type.encode('ascii') if self.format_type else b'NUND')
            # Add proprietary chunks here if needed; this writes a minimal header

# Example usage:
# npr = NPRFile('example.npr')
# npr.read()
# npr.print_properties()
# npr.write('example_modified.npr')

1. Java class for .NPR file handling:

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

public class NPRFile {
    private String filepath;
    private String magic;
    private int chunkSize;
    private String formatType;

    public NPRFile(String filepath) {
        this.filepath = filepath;
    }

    public void read() throws IOException {
        try (FileInputStream fis = new FileInputStream(filepath);
             DataInputStream dis = new DataInputStream(fis)) {
            byte[] header = new byte[12];
            if (dis.read(header) < 12) {
                throw new IOException("File too small for .NPR header");
            }
            ByteBuffer bb = ByteBuffer.wrap(header).order(ByteOrder.LITTLE_ENDIAN);
            magic = new String(header, 0, 4);
            chunkSize = bb.getInt(4);
            formatType = new String(header, 8, 4);
            // Further chunks would be parsed here if specs were available
        }
    }

    public void printProperties() throws IOException {
        if (magic == null) {
            read();
        }
        System.out.println("Magic number: " + magic);
        System.out.println("Chunk size: " + chunkSize);
        System.out.println("Format type: " + formatType);
        System.out.println("(Note: Further chunks are proprietary and not printed here.)");
    }

    public void write(String newFilepath) throws IOException {
        if (newFilepath == null) {
            newFilepath = filepath + ".new";
        }
        try (FileOutputStream fos = new FileOutputStream(newFilepath);
             DataOutputStream dos = new DataOutputStream(fos)) {
            dos.writeBytes(magic != null ? magic : "RIFF");
            dos.writeInt(Integer.reverseBytes(chunkSize != 0 ? chunkSize : 4));  // Little-endian
            dos.writeBytes(formatType != null ? formatType : "NUND");
            // Add proprietary chunks here if needed; this writes a minimal header
        }
    }

    // Example usage:
    // public static void main(String[] args) throws IOException {
    //     NPRFile npr = new NPRFile("example.npr");
    //     npr.read();
    //     npr.printProperties();
    //     npr.write("example_modified.npr");
    // }
}

1. JavaScript class for .NPR file handling:

class NPRFile {
    constructor(filepath) {
        this.filepath = filepath;
        this.magic = null;
        this.chunkSize = null;
        this.formatType = null;
    }

    async read() {
        // Note: In Node.js, use fs module
        const fs = require('fs');
        const buffer = fs.readFileSync(this.filepath);
        if (buffer.length < 12) {
            throw new Error('File too small for .NPR header');
        }
        this.magic = buffer.toString('ascii', 0, 4);
        this.chunkSize = buffer.readUInt32LE(4);
        this.formatType = buffer.toString('ascii', 8, 12);
        // Further chunks would be parsed here if specs were available
    }

    printProperties() {
        if (!this.magic) {
            throw new Error('Call read() first');
        }
        console.log(`Magic number: ${this.magic}`);
        console.log(`Chunk size: ${this.chunkSize}`);
        console.log(`Format type: ${this.formatType}`);
        console.log('(Note: Further chunks are proprietary and not printed here.)');
    }

    write(newFilepath = this.filepath + '.new') {
        const fs = require('fs');
        const buffer = Buffer.alloc(12);
        buffer.write(this.magic || 'RIFF', 0, 4, 'ascii');
        buffer.writeUInt32LE(this.chunkSize || 4, 4);
        buffer.write(this.formatType || 'NUND', 8, 4, 'ascii');
        fs.writeFileSync(newFilepath, buffer);
        // Add proprietary chunks here if needed; this writes a minimal header
    }
}

// Example usage (Node.js):
// const npr = new NPRFile('example.npr');
// await npr.read();
// npr.printProperties();
// npr.write('example_modified.npr');

1. C "class" (using struct) for .NPR file handling:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>  // For uint32_t

typedef struct {
    char *filepath;
    char magic[5];
    uint32_t chunk_size;
    char format_type[5];
} NPRFile;

NPRFile* npr_create(const char *filepath) {
    NPRFile *npr = malloc(sizeof(NPRFile));
    npr->filepath = strdup(filepath);
    memset(npr->magic, 0, 5);
    npr->chunk_size = 0;
    memset(npr->format_type, 0, 5);
    return npr;
}

void npr_read(NPRFile *npr) {
    FILE *f = fopen(npr->filepath, "rb");
    if (!f) {
        perror("Failed to open file");
        return;
    }
    char header[12];
    if (fread(header, 1, 12, f) < 12) {
        fprintf(stderr, "File too small for .NPR header\n");
        fclose(f);
        return;
    }
    fclose(f);
    strncpy(npr->magic, header, 4);
    memcpy(&npr->chunk_size, header + 4, 4);  // Assume little-endian host
    strncpy(npr->format_type, header + 8, 4);
    // Further chunks would be parsed here if specs were available
}

void npr_print_properties(const NPRFile *npr) {
    printf("Magic number: %s\n", npr->magic);
    printf("Chunk size: %u\n", npr->chunk_size);
    printf("Format type: %s\n", npr->format_type);
    printf("(Note: Further chunks are proprietary and not printed here.)\n");
}

void npr_write(const NPRFile *npr, const char *new_filepath) {
    char *path = new_filepath ? strdup(new_filepath) : strcat(strdup(npr->filepath), ".new");
    FILE *f = fopen(path, "wb");
    if (!f) {
        perror("Failed to write file");
        free(path);
        return;
    }
    fwrite(npr->magic[0] ? npr->magic : "RIFF", 1, 4, f);
    uint32_t size = npr->chunk_size ? npr->chunk_size : 4;
    fwrite(&size, 4, 1, f);  // Little-endian
    fwrite(npr->format_type[0] ? npr->format_type : "NUND", 1, 4, f);
    fclose(f);
    free(path);
    // Add proprietary chunks here if needed; this writes a minimal header
}

void npr_destroy(NPRFile *npr) {
    free(npr->filepath);
    free(npr);
}

// Example usage:
// int main() {
//     NPRFile *npr = npr_create("example.npr");
//     npr_read(npr);
//     npr_print_properties(npr);
//     npr_write(npr, "example_modified.npr");
//     npr_destroy(npr);
//     return 0;
// }