taglib-wasm 0.2.4 → 0.2.6

package/src/taglib.ts

@@ -5,6 +5,7 @@
 import type {
   AudioFormat,
   AudioProperties,
+  BitrateControlMode,
   ExtendedTag,
   FieldMapping,
   Picture,
@@ -12,7 +13,11 @@ import type {
   Tag,
   TagLibConfig,
 } from "./types.ts";
-import { METADATA_MAPPINGS } from "./types.ts";
+import { 
+  BITRATE_CONTROL_MODE_NAMES,
+  BITRATE_CONTROL_MODE_VALUES,
+  METADATA_MAPPINGS 
+} from "./types.ts";
 import {
   cStringToJS,
   jsToCString,
@@ -168,6 +173,150 @@ export class AudioFile {
     this.module._taglib_tag_set_track(this.tagPtr, track);
   }
 
+  /**
+   * Get all properties as a PropertyMap
+   */
+  properties(): PropertyMap {
+    const jsonPtr = this.module._taglib_file_properties_json(this.fileId);
+    if (jsonPtr === 0) return {};
+    
+    const jsonStr = cStringToJS(this.module, jsonPtr);
+    try {
+      return JSON.parse(jsonStr);
+    } catch {
+      return {};
+    }
+  }
+
+  /**
+   * Set properties from a PropertyMap
+   */
+  setProperties(properties: PropertyMap): boolean {
+    const jsonStr = JSON.stringify(properties);
+    const jsonPtr = jsToCString(this.module, jsonStr);
+    try {
+      return this.module._taglib_file_set_properties_json(this.fileId, jsonPtr) !== 0;
+    } finally {
+      this.module._free(jsonPtr);
+    }
+  }
+
+  /**
+   * Get a specific property value
+   */
+  getProperty(key: string): string[] | undefined {
+    const keyPtr = jsToCString(this.module, key);
+    try {
+      const valuePtr = this.module._taglib_file_get_property(this.fileId, keyPtr);
+      if (valuePtr === 0) return undefined;
+      
+      const value = cStringToJS(this.module, valuePtr);
+      return value ? [value] : undefined;
+    } finally {
+      this.module._free(keyPtr);
+    }
+  }
+
+  /**
+   * Set a specific property value
+   */
+  setProperty(key: string, values: string | string[]): boolean {
+    const value = Array.isArray(values) ? values[0] : values;
+    if (!value) return false;
+    
+    const keyPtr = jsToCString(this.module, key);
+    const valuePtr = jsToCString(this.module, value);
+    try {
+      return this.module._taglib_file_set_property(this.fileId, keyPtr, valuePtr) !== 0;
+    } finally {
+      this.module._free(keyPtr);
+      this.module._free(valuePtr);
+    }
+  }
+
+  /**
+   * Check if this is an MP4 file
+   */
+  isMP4(): boolean {
+    return this.module._taglib_file_is_mp4(this.fileId) !== 0;
+  }
+
+  /**
+   * Get MP4-specific item (for custom atoms)
+   */
+  getMP4Item(key: string): string | undefined {
+    if (!this.isMP4()) return undefined;
+    
+    const keyPtr = jsToCString(this.module, key);
+    try {
+      const valuePtr = this.module._taglib_mp4_get_item(this.fileId, keyPtr);
+      if (valuePtr === 0) return undefined;
+      
+      return cStringToJS(this.module, valuePtr);
+    } finally {
+      this.module._free(keyPtr);
+    }
+  }
+
+  /**
+   * Set MP4-specific item (for custom atoms)
+   */
+  setMP4Item(key: string, value: string): boolean {
+    if (!this.isMP4()) return false;
+    
+    const keyPtr = jsToCString(this.module, key);
+    const valuePtr = jsToCString(this.module, value);
+    try {
+      return this.module._taglib_mp4_set_item(this.fileId, keyPtr, valuePtr) !== 0;
+    } finally {
+      this.module._free(keyPtr);
+      this.module._free(valuePtr);
+    }
+  }
+
+  /**
+   * Remove MP4-specific item
+   */
+  removeMP4Item(key: string): boolean {
+    if (!this.isMP4()) return false;
+    
+    const keyPtr = jsToCString(this.module, key);
+    try {
+      return this.module._taglib_mp4_remove_item(this.fileId, keyPtr) !== 0;
+    } finally {
+      this.module._free(keyPtr);
+    }
+  }
+
+  /**
+   * Get bitrate control mode (MP4/M4A specific)
+   * Reads from the 'acbf' atom
+   */
+  getBitrateControlMode(): BitrateControlMode | undefined {
+    if (!this.isMP4()) return undefined;
+    
+    const value = this.getMP4Item("acbf");
+    if (!value) return undefined;
+    
+    const numValue = parseInt(value, 10);
+    if (isNaN(numValue) || numValue < 0 || numValue > 3) return undefined;
+    
+    return BITRATE_CONTROL_MODE_NAMES[numValue];
+  }
+
+  /**
+   * Set bitrate control mode (MP4/M4A specific)
+   * Writes to the 'acbf' atom
+   */
+  setBitrateControlMode(mode: BitrateControlMode): boolean {
+    if (!this.isMP4()) return false;
+    
+    const numValue = BITRATE_CONTROL_MODE_VALUES[mode];
+    if (numValue === undefined) return false;
+    
+    return this.setMP4Item("acbf", numValue.toString());
+  }
+
   /**
    * Save changes to the file
    */

package/src/types.ts

@@ -1,5 +1,5 @@
 /**
- * @fileoverview TypeScript type definitions for TagLib WASM
+ * @fileoverview TypeScript type definitions for taglib-wasm
  */
 
 // Re-export commonly used classes from other modules
@@ -341,6 +341,35 @@ export enum PictureType {
   PublisherLogo = 20,
 }
 
+/**
+ * Bitrate control modes for audio encoding (MP4/M4A specific)
+ */
+export type BitrateControlMode = 
+  | "Constant"
+  | "LongTermAverage" 
+  | "VariableConstrained"
+  | "Variable";
+
+/**
+ * Map of bitrate control mode names to their numeric values
+ */
+export const BITRATE_CONTROL_MODE_VALUES: Record<BitrateControlMode, number> = {
+  Constant: 0,
+  LongTermAverage: 1,
+  VariableConstrained: 2,
+  Variable: 3,
+};
+
+/**
+ * Map of numeric values to bitrate control mode names
+ */
+export const BITRATE_CONTROL_MODE_NAMES: Record<number, BitrateControlMode> = {
+  0: "Constant",
+  1: "LongTermAverage",
+  2: "VariableConstrained",
+  3: "Variable",
+};
+
 /**
  * Configuration options for TagLib initialization
  */

package/src/wasm-embind.ts

@@ -0,0 +1,55 @@
+/**
+ * WebAssembly module interface for Embind version
+ */
+export interface WasmModule {
+  // Memory access
+  HEAP8: Int8Array;
+  HEAP16: Int16Array;
+  HEAP32: Int32Array;
+  HEAPU8: Uint8Array;
+  HEAPU16: Uint16Array;
+  HEAPU32: Uint32Array;
+  HEAPF32: Float32Array;
+  HEAPF64: Float64Array;
+
+  // Runtime methods
+  allocate: (size: number, type: number) => number;
+  _malloc: (size: number) => number;
+  _free: (ptr: number) => void;
+  getValue: (ptr: number, type: string) => number;
+  setValue: (ptr: number, value: number, type: string) => void;
+  UTF8ToString: (ptr: number) => string;
+  stringToUTF8: (str: string, outPtr: number, maxBytesToWrite: number) => void;
+  lengthBytesUTF8: (str: string) => number;
+
+  // Allocation types
+  ALLOC_NORMAL: number;
+  ALLOC_STACK: number;
+
+  // Embind classes (these will be available after module loads)
+  FileHandle: any;
+  TagWrapper: any;
+  AudioPropertiesWrapper: any;
+  createFileHandle: () => any;
+}
+
+/**
+ * Extended module interface with our Embind classes
+ */
+export interface TagLibModule extends WasmModule {
+  // These are the actual class constructors from Embind
+  FileHandle: {
+    new(): any;
+  };
+  
+  TagWrapper: {
+    new(tagPtr: number): any;
+  };
+  
+  AudioPropertiesWrapper: {
+    new(propsPtr: number): any;
+  };
+  
+  // Factory function
+  createFileHandle: () => any;
+}

package/src/wasm-jsr.ts

@@ -59,54 +59,144 @@ export interface TagLibModule {
   _taglib_audioproperties_bitrate: (props: number) => number;
   _taglib_audioproperties_samplerate: (props: number) => number;
   _taglib_audioproperties_channels: (props: number) => number;
+
+  // PropertyMap operations
+  _taglib_file_properties_json: (fileId: number) => number;
+  _taglib_file_set_properties_json: (fileId: number, json: number) => number;
+  _taglib_file_get_property: (fileId: number, key: number) => number;
+  _taglib_file_set_property: (fileId: number, key: number, value: number) => number;
+
+  // MP4-specific operations
+  _taglib_file_is_mp4: (fileId: number) => number;
+  _taglib_mp4_get_item: (fileId: number, key: number) => number;
+  _taglib_mp4_set_item: (fileId: number, key: number, value: number) => number;
+  _taglib_mp4_remove_item: (fileId: number, key: number) => number;
 }
 
 /**
- * Load TagLib WASM module for JSR
+ * Load taglib-wasm module for JSR
  */
 export async function loadTagLibModuleJSR(
   config?: TagLibConfig,
 ): Promise<TagLibModule> {
-  // Load WASM file as bytes
+  // Load WASM file as bytes (same file for all platforms)
   const wasmUrl = new URL("../build/taglib.wasm", import.meta.url);
   const wasmBytes = await fetch(wasmUrl).then((r) => r.arrayBuffer());
 
-  // Minimal WebAssembly instantiation
-  const wasmModule = await WebAssembly.instantiate(wasmBytes, {
-    env: {
-      // Minimal environment for WASM
-      memory: new WebAssembly.Memory({ initial: 256, maximum: 512 }),
-      __handle_stack_overflow: () => {},
-      emscripten_notify_memory_growth: () => {},
+  // Create memory
+  const memory = new WebAssembly.Memory({ initial: 256, maximum: 4096 });
+  
+  // Create heap views (initialized after memory is created)
+  let HEAP8!: Int8Array;
+  let HEAPU8!: Uint8Array;
+  let HEAP16!: Int16Array;
+  let HEAPU16!: Uint16Array;
+  let HEAP32!: Int32Array;
+  let HEAPU32!: Uint32Array;
+  let HEAPF32!: Float32Array;
+  let HEAPF64!: Float64Array;
+  
+  function updateMemoryViews() {
+    const buffer = memory.buffer;
+    HEAP8 = new Int8Array(buffer);
+    HEAPU8 = new Uint8Array(buffer);
+    HEAP16 = new Int16Array(buffer);
+    HEAPU16 = new Uint16Array(buffer);
+    HEAP32 = new Int32Array(buffer);
+    HEAPU32 = new Uint32Array(buffer);
+    HEAPF32 = new Float32Array(buffer);
+    HEAPF64 = new Float64Array(buffer);
+  }
+  
+  updateMemoryViews();
+  
+  // Import functions expected by the WASM module (still minified with -O3)
+  const wasmImports = {
+    a: {
+      // a: ___cxa_throw
+      a: (ptr: number, type: number, destructor: number) => {
+        throw new Error('Exception thrown from WASM');
+      },
+      // e: __abort_js  
+      e: () => {
+        throw new Error('Abort called from WASM');
+      },
+      // b: __tzset_js
+      b: (timezone: number, daylight: number, std_name: number, dst_name: number) => {
+        // Minimal timezone implementation
+      },
+      // f: _emscripten_resize_heap
+      f: (requestedSize: number) => {
+        const oldSize = HEAPU8.length;
+        const newSize = Math.max(oldSize, requestedSize);
+        const pages = Math.ceil((newSize - memory.buffer.byteLength) / 65536);
+        try {
+          memory.grow(pages);
+          updateMemoryViews();
+          return 1;
+        } catch (e) {
+          return 0;
+        }
+      },
+      // c: _environ_get
+      c: (__environ: number, environ_buf: number) => 0,
+      // d: _environ_sizes_get
+      d: (penviron_count: number, penviron_buf_size: number) => {
+        HEAPU32[penviron_count >> 2] = 0;
+        HEAPU32[penviron_buf_size >> 2] = 0;
+        return 0;
+      },
+      // g: memory
+      g: memory,
     },
-  });
-
-  const instance = wasmModule.instance;
-  const exports = instance.exports as any;
+  };
+  
+  // Instantiate WASM with the expected imports
+  const wasmModule = await WebAssembly.instantiate(wasmBytes, wasmImports);
 
-  // Create memory views
-  const memory = exports.memory || new WebAssembly.Memory({ initial: 256 });
-  const buffer = memory.buffer;
+  const exports = wasmModule.instance.exports as any;
+  
+  // Update memory reference from exports (g is memory in minified version)
+  if (exports.g) {
+    updateMemoryViews();
+  }
+  
+  // Initialize runtime (h is the init function in minified version)
+  if (exports.h) {
+    exports.h();
+  }
 
   // Build the module interface
   const module: TagLibModule = {
     // Memory arrays
-    HEAPU8: new Uint8Array(buffer),
-    HEAP8: new Int8Array(buffer),
-    HEAP16: new Int16Array(buffer),
-    HEAP32: new Int32Array(buffer),
-    HEAPU16: new Uint16Array(buffer),
-    HEAPU32: new Uint32Array(buffer),
-    HEAPF32: new Float32Array(buffer),
-    HEAPF64: new Float64Array(buffer),
-
-    // Standard functions
-    _malloc: exports._malloc || (() => {
+    HEAPU8,
+    HEAP8,
+    HEAP16,
+    HEAP32,
+    HEAPU16,
+    HEAPU32,
+    HEAPF32,
+    HEAPF64,
+
+    // Standard functions (minified with -O3)
+    _malloc: exports.P || (() => {
       throw new Error("malloc not available");
     }),
-    _free: exports._free || (() => {}),
+    _free: exports.Q || (() => {}),
     allocate: (array: Uint8Array, type: number) => {
       const ptr = module._malloc(array.length);
+      // Ensure we have the latest memory view
+      if (memory.buffer !== module.HEAPU8.buffer) {
+        updateMemoryViews();
+        module.HEAPU8 = HEAPU8;
+        module.HEAP8 = HEAP8;
+        module.HEAP16 = HEAP16;
+        module.HEAP32 = HEAP32;
+        module.HEAPU16 = HEAPU16;
+        module.HEAPU32 = HEAPU32;
+        module.HEAPF32 = HEAPF32;
+        module.HEAPF64 = HEAPF64;
+      }
       module.HEAPU8.set(array, ptr);
       return ptr;
     },
@@ -118,33 +208,44 @@ export async function loadTagLibModuleJSR(
     ALLOC_DYNAMIC: 3,
     ALLOC_NONE: 4,
 
-    // TagLib functions - map from WASM exports
-    _taglib_file_new_from_buffer: exports._taglib_file_new_from_buffer,
-    _taglib_file_delete: exports._taglib_file_delete,
-    _taglib_file_save: exports._taglib_file_save,
-    _taglib_file_is_valid: exports._taglib_file_is_valid,
-    _taglib_file_format: exports._taglib_file_format,
-    _taglib_file_tag: exports._taglib_file_tag,
-    _taglib_tag_title: exports._taglib_tag_title,
-    _taglib_tag_artist: exports._taglib_tag_artist,
-    _taglib_tag_album: exports._taglib_tag_album,
-    _taglib_tag_comment: exports._taglib_tag_comment,
-    _taglib_tag_genre: exports._taglib_tag_genre,
-    _taglib_tag_year: exports._taglib_tag_year,
-    _taglib_tag_track: exports._taglib_tag_track,
-    _taglib_tag_set_title: exports._taglib_tag_set_title,
-    _taglib_tag_set_artist: exports._taglib_tag_set_artist,
-    _taglib_tag_set_album: exports._taglib_tag_set_album,
-    _taglib_tag_set_comment: exports._taglib_tag_set_comment,
-    _taglib_tag_set_genre: exports._taglib_tag_set_genre,
-    _taglib_tag_set_year: exports._taglib_tag_set_year,
-    _taglib_tag_set_track: exports._taglib_tag_set_track,
-    _taglib_file_audioproperties: exports._taglib_file_audioproperties,
-    _taglib_audioproperties_length: exports._taglib_audioproperties_length,
-    _taglib_audioproperties_bitrate: exports._taglib_audioproperties_bitrate,
-    _taglib_audioproperties_samplerate:
-      exports._taglib_audioproperties_samplerate,
-    _taglib_audioproperties_channels: exports._taglib_audioproperties_channels,
+    // TagLib functions - map from minified WASM exports (with -O3)
+    _taglib_file_new_from_buffer: exports.i,
+    _taglib_file_delete: exports.j,
+    _taglib_file_save: exports.k,
+    _taglib_file_is_valid: exports.l,
+    _taglib_file_format: exports.m,
+    _taglib_file_tag: exports.n,
+    _taglib_tag_title: exports.o,
+    _taglib_tag_artist: exports.p,
+    _taglib_tag_album: exports.q,
+    _taglib_tag_comment: exports.r,
+    _taglib_tag_genre: exports.s,
+    _taglib_tag_year: exports.t,
+    _taglib_tag_track: exports.u,
+    _taglib_tag_set_title: exports.v,
+    _taglib_tag_set_artist: exports.w,
+    _taglib_tag_set_album: exports.x,
+    _taglib_tag_set_comment: exports.y,
+    _taglib_tag_set_genre: exports.z,
+    _taglib_tag_set_year: exports.A,
+    _taglib_tag_set_track: exports.B,
+    _taglib_file_audioproperties: exports.C,
+    _taglib_audioproperties_length: exports.D,
+    _taglib_audioproperties_bitrate: exports.E,
+    _taglib_audioproperties_samplerate: exports.F,
+    _taglib_audioproperties_channels: exports.G,
+
+    // PropertyMap operations
+    _taglib_file_properties_json: exports.H,
+    _taglib_file_set_properties_json: exports.I,
+    _taglib_file_get_property: exports.J,
+    _taglib_file_set_property: exports.K,
+
+    // MP4-specific operations
+    _taglib_file_is_mp4: exports.L,
+    _taglib_mp4_get_item: exports.M,
+    _taglib_mp4_set_item: exports.N,
+    _taglib_mp4_remove_item: exports.O,
   };
 
   return module;

package/src/wasm-workers.ts

@@ -8,7 +8,7 @@ import type { TagLibConfig, TagLibModule } from "./types.ts";
 export type { TagLibModule };
 
 /**
- * Default configuration for TagLib WASM module in Workers environment
+ * Default configuration for taglib-wasm module in Workers environment
  * Reduced memory limits to fit within Workers constraints
  */
 const DEFAULT_WORKERS_CONFIG: Required<TagLibConfig> = {
@@ -50,7 +50,7 @@ export async function loadTagLibModuleForWorkers(
     printErr: mergedConfig.debug ? console.error : () => {},
     onRuntimeInitialized: () => {
       if (mergedConfig.debug) {
-        console.log("TagLib WASM module initialized in Workers");
+        console.log("taglib-wasm module initialized in Workers");
       }
     },
     // Workers-specific settings
@@ -69,7 +69,7 @@ export async function loadTagLibModuleForWorkers(
     const TagLibWASM = await createWorkersCompatibleModule();
 
     if (typeof TagLibWASM !== "function") {
-      throw new Error("Failed to load TagLib WASM module for Workers");
+      throw new Error("Failed to load taglib-wasm module for Workers");
     }
 
     const wasmInstance = await TagLibWASM(moduleConfig);
@@ -92,7 +92,7 @@ export async function loadTagLibModuleForWorkers(
     return wasmInstance as TagLibModule;
   } catch (error) {
     throw new Error(
-      `Failed to load TagLib WASM for Workers: ${(error as Error).message}`,
+      `Failed to load taglib-wasm for Workers: ${(error as Error).message}`,
     );
   }
 }

package/src/wasm.ts

@@ -5,7 +5,7 @@
 import type { TagLibConfig } from "./types.ts";
 
 /**
- * Emscripten module interface for TagLib WASM
+ * Emscripten module interface for taglib-wasm
  */
 export interface TagLibModule {
   // Emscripten standard properties
@@ -75,6 +75,18 @@ export interface TagLibModule {
   _taglib_audioproperties_samplerate: (props: number) => number;
   _taglib_audioproperties_channels: (props: number) => number;
 
+  // PropertyMap operations
+  _taglib_file_properties_json: (fileId: number) => number;
+  _taglib_file_set_properties_json: (fileId: number, json: number) => number;
+  _taglib_file_get_property: (fileId: number, key: number) => number;
+  _taglib_file_set_property: (fileId: number, key: number, value: number) => number;
+
+  // MP4-specific operations
+  _taglib_file_is_mp4: (fileId: number) => number;
+  _taglib_mp4_get_item: (fileId: number, key: number) => number;
+  _taglib_mp4_set_item: (fileId: number, key: number, value: number) => number;
+  _taglib_mp4_remove_item: (fileId: number, key: number) => number;
+
   // String utilities
   _taglib_string_new: (str: number) => number;
   _taglib_string_delete: (str: number) => void;
@@ -84,7 +96,7 @@ export interface TagLibModule {
 }
 
 /**
- * Default configuration for TagLib WASM module
+ * Default configuration for taglib-wasm module
  */
 const DEFAULT_CONFIG: Required<TagLibConfig> = {
   memory: {
@@ -144,7 +156,7 @@ export async function loadTagLibModule(
     printErr: mergedConfig.debug ? console.error : () => {},
     onRuntimeInitialized: () => {
       if (mergedConfig.debug) {
-        console.log("TagLib WASM module initialized");
+        console.log("taglib-wasm module initialized");
       }
     },
   };
@@ -201,7 +213,7 @@ export async function loadTagLibModule(
     }
 
     if (typeof TagLibWASM !== "function") {
-      throw new Error("Failed to load TagLib WASM module");
+      throw new Error("Failed to load taglib-wasm module");
     }
 
     const wasmInstance = await TagLibWASM(moduleConfig);
@@ -224,7 +236,7 @@ export async function loadTagLibModule(
 
     return wasmInstance as TagLibModule;
   } catch (error) {
-    throw new Error(`Failed to load TagLib WASM: ${(error as Error).message}`);
+    throw new Error(`Failed to load taglib-wasm: ${(error as Error).message}`);
   }
 }