advanced_process

Instructions

Implementation Reference

• src/tools/index.ts:655-682 (handler)

  Handler for the 'advanced_process' tool: constructs operations from input params and calls AdvancedAudioProcessor.processAudioFile to execute the processing.

  case 'advanced_process': {
    const input = args as any;
    const operations = {
      advanced: {
        pitch: input.pitch,
        tempo: input.tempo,
        spectral: input.spectral,
        dynamics: input.dynamics,
        spatial: input.spatial
      }
    };
    
    const result = await advancedProcessor.processAudioFile(
      input.inputFile,
      input.outputFile,
      operations,
      input.overwrite || false
    );
    
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(result, null, 2)
        }
      ]
    };
  }

• src/tools/index.ts:318-406 (schema)

  Tool definition including name, description, and detailed inputSchema for all advanced processing parameters.

  export const advancedProcessTool: Tool = {
    name: 'advanced_process',
    description: 'Apply advanced audio processing including pitch shifting, spectral processing, dynamics, and spatial effects',
    inputSchema: {
      type: 'object',
      properties: {
        inputFile: {
          type: 'string',
          description: 'Path to input audio file'
        },
        outputFile: {
          type: 'string',
          description: 'Path for output file'
        },
        pitch: {
          type: 'object',
          description: 'Pitch shifting operations',
          properties: {
            semitones: { type: 'number', minimum: -12, maximum: 12 },
            cents: { type: 'number', minimum: -100, maximum: 100 },
            preserveFormants: { type: 'boolean' }
          },
          optional: true
        },
        tempo: {
          type: 'object',
          description: 'Tempo adjustment operations',
          properties: {
            factor: { type: 'number', minimum: 0.5, maximum: 2.0 },
            preservePitch: { type: 'boolean' }
          },
          optional: true
        },
        spectral: {
          type: 'object',
          description: 'Spectral processing operations',
          properties: {
            bassBoost: { type: 'number', minimum: -12, maximum: 12 },
            trebleBoost: { type: 'number', minimum: -12, maximum: 12 },
            midCut: { type: 'number', minimum: -12, maximum: 12 },
            warmth: { type: 'number', minimum: 0, maximum: 1 },
            brightness: { type: 'number', minimum: 0, maximum: 1 }
          },
          optional: true
        },
        dynamics: {
          type: 'object',
          description: 'Dynamics processing operations',
          properties: {
            compressor: {
              type: 'object',
              properties: {
                threshold: { type: 'number', minimum: -60, maximum: 0 },
                ratio: { type: 'number', minimum: 1, maximum: 20 },
                attack: { type: 'number', minimum: 0.1, maximum: 100 },
                release: { type: 'number', minimum: 1, maximum: 1000 }
              }
            },
            gate: {
              type: 'object',
              properties: {
                threshold: { type: 'number', minimum: -80, maximum: 0 },
                ratio: { type: 'number', minimum: 1, maximum: 20 }
              }
            }
          },
          optional: true
        },
        spatial: {
          type: 'object',
          description: 'Spatial processing operations',
          properties: {
            stereoWidth: { type: 'number', minimum: 0, maximum: 2 },
            panPosition: { type: 'number', minimum: -1, maximum: 1 },
            reverbSend: { type: 'number', minimum: 0, maximum: 1 },
            delayTime: { type: 'number', minimum: 0, maximum: 1000 },
            delayFeedback: { type: 'number', minimum: 0, maximum: 0.95 }
          },
          optional: true
        },
        overwrite: {
          type: 'boolean',
          description: 'Whether to overwrite existing output files',
          default: false
        }
      },
      required: ['inputFile', 'outputFile']
    }
  };

• src/tools/index.ts:732-742 (registration)

  Registration of advancedProcessTool in the exported tools array used by registerTools function.

  export const tools = [
    processAudioFileTool,
    batchProcessAudioTool,
    applyPresetTool,
    listPresetsTool,
    getQueueStatusTool,
    generateVariationsTool,
    createHarmonicsTool,
    advancedProcessTool,
    layerSoundsTool
  ];

• src/services/advanced-audio-processor.ts:207-247 (helper)

  Core implementation: applyAdvancedOperations builds and applies FFmpeg audio filters for pitch, tempo, spectral EQ, dynamics, and spatial effects based on tool input.

  protected applyAdvancedOperations(command: any, advanced: AdvancedEffectsOperation): void {
    const filters: string[] = [];
    
    // Pitch shifting
    if (advanced.pitch) {
      filters.push(this.buildPitchFilter(advanced.pitch));
    }
    
    // Tempo adjustment
    if (advanced.tempo) {
      filters.push(this.buildTempoFilter(advanced.tempo));
    }
    
    // Spectral processing
    if (advanced.spectral) {
      const spectralFilter = this.buildSpectralFilter(advanced.spectral);
      if (spectralFilter) {
        filters.push(spectralFilter);
      }
    }
    
    // Dynamics processing
    if (advanced.dynamics) {
      filters.push(...this.buildDynamicsFilters(advanced.dynamics));
    }
    
    // Spatial processing
    if (advanced.spatial) {
      filters.push(...this.buildSpatialFilters(advanced.spatial));
    }
    
    // Modulation effects
    if (advanced.modulation) {
      filters.push(...this.buildModulationFilters(advanced.modulation));
    }
    
    // Apply all filters
    if (filters.length > 0) {
      command.audioFilters(filters);
    }
  }

• src/tools/index.ts:14-14 (helper)

  Instantiation of AdvancedAudioProcessor used by the advanced_process handler.

  const advancedProcessor = new AdvancedAudioProcessor();