code: def mfcc(
      waveform: Tensor,
      blackman_coeff: float = 0.42,
      cepstral_lifter: float = 22.0,
      channel: int = -1,
      dither: float = 0.0,
      energy_floor: float = 1.0,
      frame_length: float = 25.0,
      frame_shift: float = 10.0,
      high_freq: float = 0.0,
      htk_compat: bool = False,
      low_freq: float = 20.0,
      num_ceps: int = 13,
      min_duration: float = 0.0,
      num_mel_bins: int = 23,
      preemphasis_coefficient: float = 0.97,
      raw_energy: bool = True,
      remove_dc_offset: bool = True,
      round_to_power_of_two: bool = True,
      sample_frequency: float = 16000.0,
      snip_edges: bool = True,
      subtract_mean: bool = False,
      use_energy: bool = False,
      vtln_high: float = -500.0,
      vtln_low: float = 100.0,
      vtln_warp: float = 1.0,
      window_type: str = POVEY,
  ) -> Tensor:
      r"""Create a mfcc from a raw audio signal. This matches the input/output of Kaldi's
      compute-mfcc-feats.
  
      Args:
          waveform (Tensor): Tensor of audio of size (c, n) where c is in the range [0,2)
          blackman_coeff (float, optional): Constant coefficient for generalized Blackman window. (Default: ``0.42``)
          cepstral_lifter (float, optional): Constant that controls scaling of MFCCs (Default: ``22.0``)
          channel (int, optional): Channel to extract (-1 -> expect mono, 0 -> left, 1 -> right) (Default: ``-1``)
          dither (float, optional): Dithering constant (0.0 means no dither). If you turn this off, you should set
              the energy_floor option, e.g. to 1.0 or 0.1 (Default: ``0.0``)
          energy_floor (float, optional): Floor on energy (absolute, not relative) in Spectrogram computation.  Caution:
              this floor is applied to the zeroth component, representing the total signal energy.  The floor on the
              individual spectrogram elements is fixed at std::numeric_limits<float>::epsilon(). (Default: ``1.0``)
          frame_length (float, optional): Frame length in milliseconds (Default: ``25.0``)
          frame_shift (float, optional): Frame shift in milliseconds (Default: ``10.0``)
          high_freq (float, optional): High cutoff frequency for mel bins (if <= 0, offset from Nyquist)
           (Default: ``0.0``)
          htk_compat (bool, optional): If true, put energy last.  Warning: not sufficient to get HTK compatible
           features (need to change other parameters). (Default: ``False``)
          low_freq (float, optional): Low cutoff frequency for mel bins (Default: ``20.0``)
          num_ceps (int, optional): Number of cepstra in MFCC computation (including C0) (Default: ``13``)
          min_duration (float, optional): Minimum duration of segments to process (in seconds). (Default: ``0.0``)
          num_mel_bins (int, optional): Number of triangular mel-frequency bins (Default: ``23``)
          preemphasis_coefficient (float, optional): Coefficient for use in signal preemphasis (Default: ``0.97``)
          raw_energy (bool, optional): If True, compute energy before preemphasis and windowing (Default: ``True``)
          remove_dc_offset (bool, optional): Subtract mean from waveform on each frame (Default: ``True``)
          round_to_power_of_two (bool, optional): If True, round window size to power of two by zero-padding input
              to FFT. (Default: ``True``)
          sample_frequency (float, optional): Waveform data sample frequency (must match the waveform file, if
              specified there) (Default: ``16000.0``)
          snip_edges (bool, optional): If True, end effects will be handled by outputting only frames that completely fit
              in the file, and the number of frames depends on the frame_length.  If False, the number of frames
              depends only on the frame_shift, and we reflect the data at the ends. (Default: ``True``)
          subtract_mean (bool, optional): Subtract mean of each feature file [CMS]; not recommended to do
              it this way.  (Default: ``False``)
          use_energy (bool, optional): Add an extra dimension with energy to the FBANK output. (Default: ``False``)
          vtln_high (float, optional): High inflection point in piecewise linear VTLN warping function (if
              negative, offset from high-mel-freq (Default: ``-500.0``)
          vtln_low (float, optional): Low inflection point in piecewise linear VTLN warping function (Default: ``100.0``)
          vtln_warp (float, optional): Vtln warp factor (only applicable if vtln_map not specified) (Default: ``1.0``)
          window_type (str, optional): Type of window ('hamming'|'hanning'|'povey'|'rectangular'|'blackman')
           (Default: ``"povey"``)
  
      Returns:
          Tensor: A mfcc identical to what Kaldi would output. The shape is (m, ``num_ceps``)
          where m is calculated in _get_strided
      """
      assert (
          num_ceps <= num_mel_bins
      ), "num_ceps cannot be larger than num_mel_bins: %d vs %d" % (
          num_ceps,
          num_mel_bins,
      )
  
      device, dtype = waveform.device, waveform.dtype
  
      # The mel_energies should not be squared (use_power=True), not have mean subtracted
      # (subtract_mean=False), and use log (use_log_fbank=True).
      # size (m, num_mel_bins + use_energy)
      feature = fbank(
          waveform=waveform,
          blackman_coeff=blackman_coeff,
          channel=channel,
          dither=dither,
          energy_floor=energy_floor,
          frame_length=frame_length,
          frame_shift=frame_shift,
          high_freq=high_freq,
          htk_compat=htk_compat,
          low_freq=low_freq,
          min_duration=min_duration,
          num_mel_bins=num_mel_bins,
          preemphasis_coefficient=preemphasis_coefficient,
          raw_energy=raw_energy,
          remove_dc_offset=remove_dc_offset,
          round_to_power_of_two=round_to_power_of_two,
          sample_frequency=sample_frequency,
          snip_edges=snip_edges,
          subtract_mean=False,
          use_energy=use_energy,
          use_log_fbank=True,
          use_power=True,
          vtln_high=vtln_high,
          vtln_low=vtln_low,
          vtln_warp=vtln_warp,
          window_type=window_type,
      )
  
      if use_energy:
          # size (m)
          signal_log_energy = feature[
              :, num_mel_bins if htk_compat else 0
          ]
          # offset is 0 if htk_compat==True else 1
          mel_offset = int(not htk_compat)
          feature = feature[:, mel_offset : (num_mel_bins + mel_offset)]
  
      # size (num_mel_bins, num_ceps)
      dct_matrix = _get_dct_matrix(num_ceps, num_mel_bins).to(
          dtype=dtype, device=device
      )
  
      # size (m, num_ceps)
      feature = feature.matmul(dct_matrix)
  
      if cepstral_lifter != 0.0:
          # size (1, num_ceps)
          lifter_coeffs = _get_lifter_coeffs(
              num_ceps, cepstral_lifter
          ).unsqueeze(0)
          feature *= lifter_coeffs.to(device=device, dtype=dtype)
  
      # if use_energy then replace the last column for htk_compat == true else first column
      if use_energy:
          feature[:, 0] = signal_log_energy
  
      if htk_compat:
          energy = feature[:, 0].unsqueeze(1)  # size (m, 1)
          feature = feature[:, 1:]  # size (m, num_ceps - 1)
          if not use_energy:
              # scale on C0 (actually removing a scale we previously added that's
              # part of one common definition of the cosine transform.)
              energy *= math.sqrt(2)
  
          feature = torch.cat((feature, energy), dim=1)
  
      feature = _subtract_column_mean(feature, subtract_mean)
      return feature
  
imports: import math
  from typing import Tuple
  import torch
  import torchaudio
  from torch import Tensor
label_desc: Use image node_id 20 for calling a global function with example usage: mfcc(waveform, blackman_coeff, cepstral_lifter, channel, dither, energy_floor, frame_length, frame_shift, high_freq, htk_compat, low_freq, num_ceps, min_duration, num_mel_bins, preemphasis_coefficient, raw_energy, remove_dc_offset, round_to_power_of_two, sample_frequency, snip_edges, subtract_mean, use_energy, vtln_high, vtln_low, vtln_warp, window_type) and returns: feature