content: from __future__ import division
  
  import array
  import os
  import subprocess
  from tempfile import NamedTemporaryFile
  import wave
  import sys
  import struct
  from .logging_utils import log_conversion, log_subprocess_output
  from .utils import mediainfo_json, fsdecode
  import base64
  from collections import namedtuple
  
  try:
      from StringIO import StringIO
  except:
      from io import StringIO
  
  from io import BytesIO
  
  try:
      from itertools import izip
  except:
      izip = zip
  
  from .utils import (
      _fd_or_path_or_tempfile,
      db_to_float,
      ratio_to_db,
      get_encoder_name,
      get_array_type,
      audioop,
  )
  from .exceptions import (
      TooManyMissingFrames,
      InvalidDuration,
      InvalidID3TagVersion,
      InvalidTag,
      CouldntDecodeError,
      CouldntEncodeError,
      MissingAudioParameter,
  )
  
  if sys.version_info >= (3, 0):
      basestring = str
      xrange = range
      StringIO = BytesIO
  
  
  class ClassPropertyDescriptor(object):
  
      def __init__(self, fget, fset=None):
          self.fget = fget
          self.fset = fset
  
      def __get__(self, obj, klass=None):
          if klass is None:
              klass = type(obj)
          return self.fget.__get__(obj, klass)()
  
      def __set__(self, obj, value):
          if not self.fset:
              raise AttributeError("can't set attribute")
          type_ = type(obj)
          return self.fset.__get__(obj, type_)(value)
  
      def setter(self, func):
          if not isinstance(func, (classmethod, staticmethod)):
              func = classmethod(func)
          self.fset = func
          return self
  
  
  def classproperty(func):
      if not isinstance(func, (classmethod, staticmethod)):
          func = classmethod(func)
  
      return ClassPropertyDescriptor(func)
  
  
  AUDIO_FILE_EXT_ALIASES = {
      "m4a": "mp4",
      "wave": "wav",
  }
  
  WavSubChunk = namedtuple('WavSubChunk', ['id', 'position', 'size'])
  WavData = namedtuple('WavData', ['audio_format', 'channels', 'sample_rate',
                                   'bits_per_sample', 'raw_data'])
  
  
  def extract_wav_headers(data):
      # def search_subchunk(data, subchunk_id):
      pos = 12  # The size of the RIFF chunk descriptor
      subchunks = []
      while pos + 8 <= len(data) and len(subchunks) < 10:
          subchunk_id = data[pos:pos + 4]
          subchunk_size = struct.unpack_from('<I', data[pos + 4:pos + 8])[0]
          subchunks.append(WavSubChunk(subchunk_id, pos, subchunk_size))
          if subchunk_id == b'data':
              # 'data' is the last subchunk
              break
          pos += subchunk_size + 8
  
      return subchunks
  
  
  def read_wav_audio(data, headers=None):
      if not headers:
          headers = extract_wav_headers(data)
  
      fmt = [x for x in headers if x.id == b'fmt ']
      if not fmt or fmt[0].size < 16:
          raise CouldntDecodeError("Couldn't find fmt header in wav data")
      fmt = fmt[0]
      pos = fmt.position + 8
      audio_format = struct.unpack_from('<H', data[pos:pos + 2])[0]
      if audio_format != 1 and audio_format != 0xFFFE:
          raise CouldntDecodeError("Unknown audio format 0x%X in wav data" %
                                   audio_format)
  
      channels = struct.unpack_from('<H', data[pos + 2:pos + 4])[0]
      sample_rate = struct.unpack_from('<I', data[pos + 4:pos + 8])[0]
      bits_per_sample = struct.unpack_from('<H', data[pos + 14:pos + 16])[0]
  
      data_hdr = headers[-1]
      if data_hdr.id != b'data':
          raise CouldntDecodeError("Couldn't find data header in wav data")
  
      pos = data_hdr.position + 8
      return WavData(audio_format, channels, sample_rate, bits_per_sample,
                     data[pos:pos + data_hdr.size])
  
  
  def fix_wav_headers(data):
      headers = extract_wav_headers(data)
      if not headers or headers[-1].id != b'data':
          return
  
      # TODO: Handle huge files in some other way
      if len(data) > 2**32:
          raise CouldntDecodeError("Unable to process >4GB files")
  
      # Set the file size in the RIFF chunk descriptor
      data[4:8] = struct.pack('<I', len(data) - 8)
  
      # Set the data size in the data subchunk
      pos = headers[-1].position
      data[pos + 4:pos + 8] = struct.pack('<I', len(data) - pos - 8)
  
  
  class AudioSegment(object):
      """
      AudioSegments are *immutable* objects representing segments of audio
      that can be manipulated using python code.
  
      AudioSegments are slicable using milliseconds.
      for example:
          a = AudioSegment.from_mp3(mp3file)
          first_second = a[:1000] # get the first second of an mp3
          slice = a[5000:10000] # get a slice from 5 to 10 seconds of an mp3
      """
      converter = get_encoder_name()  # either ffmpeg or avconv
  
      # TODO: remove in 1.0 release
      # maintain backwards compatibility for ffmpeg attr (now called converter)
      @classproperty
      def ffmpeg(cls):
          return cls.converter
  
      @ffmpeg.setter
      def ffmpeg(cls, val):
          cls.converter = val
  
      DEFAULT_CODECS = {
          "ogg": "libvorbis"
      }
  
      def __init__(self, data=None, *args, **kwargs):
          self.sample_width = kwargs.pop("sample_width", None)
          self.frame_rate = kwargs.pop("frame_rate", None)
          self.channels = kwargs.pop("channels", None)
  
          audio_params = (self.sample_width, self.frame_rate, self.channels)
  
          if isinstance(data, array.array):
              try:
                  data = data.tobytes()
              except:
                  data = data.tostring()
  
          # prevent partial specification of arguments
          if any(audio_params) and None in audio_params:
              raise MissingAudioParameter("Either all audio parameters or no parameter must be specified")
  
          # all arguments are given
          elif self.sample_width is not None:
              if len(data) % (self.sample_width * self.channels) != 0:
                  raise ValueError("data length must be a multiple of '(sample_width * channels)'")
  
              self.frame_width = self.channels * self.sample_width
              self._data = data
  
          # keep support for 'metadata' until audio params are used everywhere
          elif kwargs.get('metadata', False):
              # internal use only
              self._data = data
              for attr, val in kwargs.pop('metadata').items():
                  setattr(self, attr, val)
          else:
              # normal construction
              try:
                  data = data if isinstance(data, (basestring, bytes)) else data.read()
              except(OSError):
                  d = b''
                  reader = data.read(2 ** 31 - 1)
                  while reader:
                      d += reader
                      reader = data.read(2 ** 31 - 1)
                  data = d
  
              wav_data = read_wav_audio(data)
              if not wav_data:
                  raise CouldntDecodeError("Couldn't read wav audio from data")
  
              self.channels = wav_data.channels
              self.sample_width = wav_data.bits_per_sample // 8
              self.frame_rate = wav_data.sample_rate
              self.frame_width = self.channels * self.sample_width
              self._data = wav_data.raw_data
              if self.sample_width == 1:
                  # convert from unsigned integers in wav
                  self._data = audioop.bias(self._data, 1, -128)
  
          # Convert 24-bit audio to 32-bit audio.
          # (stdlib audioop and array modules do not support 24-bit data)
          if self.sample_width == 3:
              byte_buffer = BytesIO()
  
              # Workaround for python 2 vs python 3. _data in 2.x are length-1 strings,
              # And in 3.x are ints.
              pack_fmt = 'BBB' if isinstance(self._data[0], int) else 'ccc'
  
              # This conversion maintains the 24 bit values.  The values are
              # not scaled up to the 32 bit range.  Other conversions could be
              # implemented.
              i = iter(self._data)
              padding = {False: b'\x00', True: b'\xFF'}
              for b0, b1, b2 in izip(i, i, i):
                  byte_buffer.write(padding[b2 > b'\x7f'[0]])
                  old_bytes = struct.pack(pack_fmt, b0, b1, b2)
                  byte_buffer.write(old_bytes)
  
              self._data = byte_buffer.getvalue()
              self.sample_width = 4
              self.frame_width = self.channels * self.sample_width
  
          super(AudioSegment, self).__init__(*args, **kwargs)
  
      @property
      def raw_data(self):
          """
          public access to the raw audio data as a bytestring
          """
          return self._data
  
      def get_array_of_samples(self, array_type_override=None):
          """
          returns the raw_data as an array of samples
          """
          if array_type_override is None:
              array_type_override = self.array_type
          return array.array(array_type_override, self._data)
  
      @property
      def array_type(self):
          return get_array_type(self.sample_width * 8)
  
      def __len__(self):
          """
          returns the length of this audio segment in milliseconds
          """
          return round(1000 * (self.frame_count() / self.frame_rate))
  
      def __eq__(self, other):
          try:
              return self._data == other._data
          except:
              return False
  
      def __hash__(self):
          return hash(AudioSegment) ^ hash((self.channels, self.frame_rate, self.sample_width, self._data))
  
      def __ne__(self, other):
          return not (self == other)
  
      def __iter__(self):
          return (self[i] for i in xrange(len(self)))
  
      def __getitem__(self, millisecond):
          if isinstance(millisecond, slice):
              if millisecond.step:
                  return (
                      self[i:i + millisecond.step]
                      for i in xrange(*millisecond.indices(len(self)))
                  )
  
              start = millisecond.start if millisecond.start is not None else 0
              end = millisecond.stop if millisecond.stop is not None \
                  else len(self)
  
              start = min(start, len(self))
              end = min(end, len(self))
          else:
              start = millisecond
              end = millisecond + 1
  
          start = self._parse_position(start) * self.frame_width
          end = self._parse_position(end) * self.frame_width
          data = self._data[start:end]
  
          # ensure the output is as long as the requester is expecting
          expected_length = end - start
          missing_frames = (expected_length - len(data)) // self.frame_width
          if missing_frames:
              if missing_frames > self.frame_count(ms=2):
                  raise TooManyMissingFrames(
                      "You should never be filling in "
                      "   more than 2 ms with silence here, "
                      "missing frames: %s" % missing_frames)
              silence = audioop.mul(data[:self.frame_width],
                                    self.sample_width, 0)
              data += (silence * missing_frames)
  
          return self._spawn(data)
  
      def get_sample_slice(self, start_sample=None, end_sample=None):
          """
          Get a section of the audio segment by sample index.
  
          NOTE: Negative indices do *not* address samples backword
          from the end of the audio segment like a python list.
          This is intentional.
          """
          max_val = int(self.frame_count())
  
          def bounded(val, default):
              if val is None:
                  return default
              if val < 0:
                  return 0
              if val > max_val:
                  return max_val
              return val
  
          start_i = bounded(start_sample, 0) * self.frame_width
          end_i = bounded(end_sample, max_val) * self.frame_width
  
          data = self._data[start_i:end_i]
          return self._spawn(data)
  
      def __add__(self, arg):
          if isinstance(arg, AudioSegment):
              return self.append(arg, crossfade=0)
          else:
              return self.apply_gain(arg)
  
      def __radd__(self, rarg):
          """
          Permit use of sum() builtin with an iterable of AudioSegments
          """
          if rarg == 0:
              return self
          raise TypeError("Gains must be the second addend after the "
                          "AudioSegment")
  
      def __sub__(self, arg):
          if isinstance(arg, AudioSegment):
              raise TypeError("AudioSegment objects can't be subtracted from "
                              "each other")
          else:
              return self.apply_gain(-arg)
  
      def __mul__(self, arg):
          """
          If the argument is an AudioSegment, overlay the multiplied audio
          segment.
  
          If it's a number, just use the string multiply operation to repeat the
          audio.
  
          The following would return an AudioSegment that contains the
          audio of audio_seg eight times
  
          `audio_seg * 8`
          """
          if isinstance(arg, AudioSegment):
              return self.overlay(arg, position=0, loop=True)
          else:
              return self._spawn(data=self._data * arg)
  
      def _spawn(self, data, overrides={}):
          """
          Creates a new audio segment using the metadata from the current one
          and the data passed in. Should be used whenever an AudioSegment is
          being returned by an operation that would alters the current one,
          since AudioSegment objects are immutable.
          """
          # accept lists of data chunks
          if isinstance(data, list):
              data = b''.join(data)
  
          if isinstance(data, array.array):
              try:
                  data = data.tobytes()
              except:
                  data = data.tostring()
  
          # accept file-like objects
          if hasattr(data, 'read'):
              if hasattr(data, 'seek'):
                  data.seek(0)
              data = data.read()
  
          metadata = {
              'sample_width': self.sample_width,
              'frame_rate': self.frame_rate,
              'frame_width': self.frame_width,
              'channels': self.channels
          }
          metadata.update(overrides)
          return self.__class__(data=data, metadata=metadata)
  
      @classmethod
      def _sync(cls, *segs):
          channels = max(seg.channels for seg in segs)
          frame_rate = max(seg.frame_rate for seg in segs)
          sample_width = max(seg.sample_width for seg in segs)
  
          return tuple(
              seg.set_channels(channels).set_frame_rate(frame_rate).set_sample_width(sample_width)
              for seg in segs
          )
  
      def _parse_position(self, val):
          if val < 0:
              val = len(self) - abs(val)
          val = self.frame_count(ms=len(self)) if val == float("inf") else \
              self.frame_count(ms=val)
          return int(val)
  
      @classmethod
      def empty(cls):
          return cls(b'', metadata={
              "channels": 1,
              "sample_width": 1,
              "frame_rate": 1,
              "frame_width": 1
          })
  
      @classmethod
      def silent(cls, duration=1000, frame_rate=11025):
          """
          Generate a silent audio segment.
          duration specified in milliseconds (default duration: 1000ms, default frame_rate: 11025).
          """
          frames = int(frame_rate * (duration / 1000.0))
          data = b"\0\0" * frames
          return cls(data, metadata={"channels": 1,
                                     "sample_width": 2,
                                     "frame_rate": frame_rate,
                                     "frame_width": 2})
  
      @classmethod
      def from_mono_audiosegments(cls, *mono_segments):
          if not len(mono_segments):
              raise ValueError("At least one AudioSegment instance is required")
  
          segs = cls._sync(*mono_segments)
  
          if segs[0].channels != 1:
              raise ValueError(
                  "AudioSegment.from_mono_audiosegments requires all arguments are mono AudioSegment instances")
  
          channels = len(segs)
          sample_width = segs[0].sample_width
          frame_rate = segs[0].frame_rate
  
          frame_count = max(int(seg.frame_count()) for seg in segs)
          data = array.array(
              segs[0].array_type,
              b'\0' * (frame_count * sample_width * channels)
          )
  
          for i, seg in enumerate(segs):
              data[i::channels] = seg.get_array_of_samples()
  
          return cls(
              data,
              channels=channels,
              sample_width=sample_width,
              frame_rate=frame_rate,
          )
  
      @classmethod
      def from_file_using_temporary_files(cls, file, format=None, codec=None, parameters=None, start_second=None, duration=None, **kwargs):
          orig_file = file
          file, close_file = _fd_or_path_or_tempfile(file, 'rb', tempfile=False)
  
          if format:
              format = format.lower()
              format = AUDIO_FILE_EXT_ALIASES.get(format, format)
  
          def is_format(f):
              f = f.lower()
              if format == f:
                  return True
              if isinstance(orig_file, basestring):
                  return orig_file.lower().endswith(".{0}".format(f))
              if isinstance(orig_file, bytes):
                  return orig_file.lower().endswith((".{0}".format(f)).encode('utf8'))
              return False
  
          if is_format("wav"):
              try:
                  obj = cls._from_safe_wav(file)
                  if close_file:
                      file.close()
                  if start_second is None and duration is None:
                      return obj
                  elif start_second is not None and duration is None:
                      return obj[start_second*1000:]
                  elif start_second is None and duration is not None:
                      return obj[:duration*1000]
                  else:
                      return obj[start_second*1000:(start_second+duration)*1000]
              except:
                  file.seek(0)
          elif is_format("raw") or is_format("pcm"):
              sample_width = kwargs['sample_width']
              frame_rate = kwargs['frame_rate']
              channels = kwargs['channels']
              metadata = {
                  'sample_width': sample_width,
                  'frame_rate': frame_rate,
                  'channels': channels,
                  'frame_width': channels * sample_width
              }
              obj = cls(data=file.read(), metadata=metadata)
              if close_file:
                  file.close()
              if start_second is None and duration is None:
                  return obj
              elif start_second is not None and duration is None:
                  return obj[start_second * 1000:]
              elif start_second is None and duration is not None:
                  return obj[:duration * 1000]
              else:
                  return obj[start_second * 1000:(start_second + duration) * 1000]
  
          input_file = NamedTemporaryFile(mode='wb', delete=False)
          try:
              input_file.write(file.read())
          except(OSError):
              input_file.flush()
              input_file.close()
              input_file = NamedTemporaryFile(mode='wb', delete=False, buffering=2 ** 31 - 1)
              if close_file:
                  file.close()
              close_file = True
              file = open(orig_file, buffering=2 ** 13 - 1, mode='rb')
              reader = file.read(2 ** 31 - 1)
              while reader:
                  input_file.write(reader)
                  reader = file.read(2 ** 31 - 1)
          input_file.flush()
          if close_file:
              file.close()
  
          output = NamedTemporaryFile(mode="rb", delete=False)
  
          conversion_command = [cls.converter,
                                '-y',  # always overwrite existing files
                                ]
  
          # If format is not defined
          # ffmpeg/avconv will detect it automatically
          if format:
              conversion_command += ["-f", format]
  
          if codec:
              # force audio decoder
              conversion_command += ["-acodec", codec]
  
          conversion_command += [
              "-i", input_file.name,  # input_file options (filename last)
              "-vn",  # Drop any video streams if there are any
              "-f", "wav"  # output options (filename last)
          ]
  
          if start_second is not None:
              conversion_command += ["-ss", str(start_second)]
  
          if duration is not None:
              conversion_command += ["-t", str(duration)]
  
          conversion_command += [output.name]
  
          if parameters is not None:
              # extend arguments with arbitrary set
              conversion_command.extend(parameters)
  
          log_conversion(conversion_command)
  
          with open(os.devnull, 'rb') as devnull:
              p = subprocess.Popen(conversion_command, stdin=devnull, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
          p_out, p_err = p.communicate()
  
          log_subprocess_output(p_out)
          log_subprocess_output(p_err)
  
          try:
              if p.returncode != 0:
                  raise CouldntDecodeError(
                      "Decoding failed. ffmpeg returned error code: {0}\n\nOutput from ffmpeg/avlib:\n\n{1}".format(
                          p.returncode, p_err.decode(errors='ignore') ))
              obj = cls._from_safe_wav(output)
          finally:
              input_file.close()
              output.close()
              os.unlink(input_file.name)
              os.unlink(output.name)
  
          if start_second is None and duration is None:
              return obj
          elif start_second is not None and duration is None:
              return obj[0:]
          elif start_second is None and duration is not None:
              return obj[:duration * 1000]
          else:
              return obj[0:duration * 1000]
  
  
      @classmethod
      def from_file(cls, file, format=None, codec=None, parameters=None, start_second=None, duration=None, **kwargs):
          orig_file = file
          try:
              filename = fsdecode(file)
          except TypeError:
              filename = None
          file, close_file = _fd_or_path_or_tempfile(file, 'rb', tempfile=False)
  
          if format:
              format = format.lower()
              format = AUDIO_FILE_EXT_ALIASES.get(format, format)
  
          def is_format(f):
              f = f.lower()
              if format == f:
                  return True
  
              if filename:
                  return filename.lower().endswith(".{0}".format(f))
  
              return False
  
          if is_format("wav"):
              try:
                  if start_second is None and duration is None:
                      return cls._from_safe_wav(file)
                  elif start_second is not None and duration is None:
                      return cls._from_safe_wav(file)[start_second*1000:]
                  elif start_second is None and duration is not None:
                      return cls._from_safe_wav(file)[:duration*1000]
                  else:
                      return cls._from_safe_wav(file)[start_second*1000:(start_second+duration)*1000]
              except:
                  file.seek(0)
          elif is_format("raw") or is_format("pcm"):
              sample_width = kwargs['sample_width']
              frame_rate = kwargs['frame_rate']
              channels = kwargs['channels']
              metadata = {
                  'sample_width': sample_width,
                  'frame_rate': frame_rate,
                  'channels': channels,
                  'frame_width': channels * sample_width
              }
              if start_second is None and duration is None:
                  return cls(data=file.read(), metadata=metadata)
              elif start_second is not None and duration is None:
                  return cls(data=file.read(), metadata=metadata)[start_second*1000:]
              elif start_second is None and duration is not None:
                  return cls(data=file.read(), metadata=metadata)[:duration*1000]
              else:
                  return cls(data=file.read(), metadata=metadata)[start_second*1000:(start_second+duration)*1000]
  
          conversion_command = [cls.converter,
                                '-y',  # always overwrite existing files
                                ]
  
          # If format is not defined
          # ffmpeg/avconv will detect it automatically
          if format:
              conversion_command += ["-f", format]
  
          if codec:
              # force audio decoder
              conversion_command += ["-acodec", codec]
  
          read_ahead_limit = kwargs.get('read_ahead_limit', -1)
          if filename:
              conversion_command += ["-i", filename]
              stdin_parameter = None
              stdin_data = None
          else:
              if cls.converter == 'ffmpeg':
                  conversion_command += ["-read_ahead_limit", str(read_ahead_limit),
                                         "-i", "cache:pipe:0"]
              else:
                  conversion_command += ["-i", "-"]
              stdin_parameter = subprocess.PIPE
              stdin_data = file.read()
  
          if codec:
              info = None
          else:
              info = mediainfo_json(orig_file, read_ahead_limit=read_ahead_limit)
          if info:
              audio_streams = [x for x in info['streams']
                               if x['codec_type'] == 'audio']
              # This is a workaround for some ffprobe versions that always say
              # that mp3/mp4/aac/webm/ogg files contain fltp samples
              audio_codec = audio_streams[0].get('codec_name')
              if (audio_streams[0].get('sample_fmt') == 'fltp' and
                      audio_codec in ['mp3', 'mp4', 'aac', 'webm', 'ogg']):
                  bits_per_sample = 16
              else:
                  bits_per_sample = audio_streams[0]['bits_per_sample']
              if bits_per_sample == 8:
                  acodec = 'pcm_u8'
              else:
                  acodec = 'pcm_s%dle' % bits_per_sample
  
              conversion_command += ["-acodec", acodec]
  
          conversion_command += [
              "-vn",  # Drop any video streams if there are any
              "-f", "wav"  # output options (filename last)
          ]
  
          if start_second is not None:
              conversion_command += ["-ss", str(start_second)]
  
          if duration is not None:
              conversion_command += ["-t", str(duration)]
  
          conversion_command += ["-"]
  
          if parameters is not None:
              # extend arguments with arbitrary set
              conversion_command.extend(parameters)
  
          log_conversion(conversion_command)
  
          p = subprocess.Popen(conversion_command, stdin=stdin_parameter,
                               stdout=subprocess.PIPE, stderr=subprocess.PIPE)
          p_out, p_err = p.communicate(input=stdin_data)
  
          if p.returncode != 0 or len(p_out) == 0:
              if close_file:
                  file.close()
              raise CouldntDecodeError(
                  "Decoding failed. ffmpeg returned error code: {0}\n\nOutput from ffmpeg/avlib:\n\n{1}".format(
                      p.returncode, p_err.decode(errors='ignore') ))
  
          p_out = bytearray(p_out)
          fix_wav_headers(p_out)
          p_out = bytes(p_out)
          obj = cls(p_out)
  
          if close_file:
              file.close()
  
          if start_second is None and duration is None:
              return obj
          elif start_second is not None and duration is None:
              return obj[0:]
          elif start_second is None and duration is not None:
              return obj[:duration * 1000]
          else:
              return obj[0:duration * 1000]
  
      @classmethod
      def from_mp3(cls, file, parameters=None):
          return cls.from_file(file, 'mp3', parameters=parameters)
  
      @classmethod
      def from_flv(cls, file, parameters=None):
          return cls.from_file(file, 'flv', parameters=parameters)
  
      @classmethod
      def from_ogg(cls, file, parameters=None):
          return cls.from_file(file, 'ogg', parameters=parameters)
  
      @classmethod
      def from_wav(cls, file, parameters=None):
          return cls.from_file(file, 'wav', parameters=parameters)
  
      @classmethod
      def from_raw(cls, file, **kwargs):
          return cls.from_file(file, 'raw', sample_width=kwargs['sample_width'], frame_rate=kwargs['frame_rate'],
                               channels=kwargs['channels'])
  
      @classmethod
      def _from_safe_wav(cls, file):
          file, close_file = _fd_or_path_or_tempfile(file, 'rb', tempfile=False)
          file.seek(0)
          obj = cls(data=file)
          if close_file:
              file.close()
          return obj
  
      def export(self, out_f=None, format='mp3', codec=None, bitrate=None, parameters=None, tags=None, id3v2_version='4',
                 cover=None):
          """
          Export an AudioSegment to a file with given options
  
          out_f (string):
              Path to destination audio file. Also accepts os.PathLike objects on
              python >= 3.6
  
          format (string)
              Format for destination audio file.
              ('mp3', 'wav', 'raw', 'ogg' or other ffmpeg/avconv supported files)
  
          codec (string)
              Codec used to encode the destination file.
  
          bitrate (string)
              Bitrate used when encoding destination file. (64, 92, 128, 256, 312k...)
              Each codec accepts different bitrate arguments so take a look at the
              ffmpeg documentation for details (bitrate usually shown as -b, -ba or
              -a:b).
  
          parameters (list of strings)
              Aditional ffmpeg/avconv parameters
  
          tags (dict)
              Set metadata information to destination files
              usually used as tags. ({title='Song Title', artist='Song Artist'})
  
          id3v2_version (string)
              Set ID3v2 version for tags. (default: '4')
  
          cover (file)
              Set cover for audio file from image file. (png or jpg)
          """
          id3v2_allowed_versions = ['3', '4']
  
          if format == "raw" and (codec is not None or parameters is not None):
              raise AttributeError(
                      'Can not invoke ffmpeg when export format is "raw"; '
                      'specify an ffmpeg raw format like format="s16le" instead '
                      'or call export(format="raw") with no codec or parameters')
  
          out_f, _ = _fd_or_path_or_tempfile(out_f, 'wb+')
          out_f.seek(0)
  
          if format == "raw":
              out_f.write(self._data)
              out_f.seek(0)
              return out_f
  
          # wav with no ffmpeg parameters can just be written directly to out_f
          easy_wav = format == "wav" and codec is None and parameters is None
  
          if easy_wav:
              data = out_f
          else:
              data = NamedTemporaryFile(mode="wb", delete=False)
  
          pcm_for_wav = self._data
          if self.sample_width == 1:
              # convert to unsigned integers for wav
              pcm_for_wav = audioop.bias(self._data, 1, 128)
  
          wave_data = wave.open(data, 'wb')
          wave_data.setnchannels(self.channels)
          wave_data.setsampwidth(self.sample_width)
          wave_data.setframerate(self.frame_rate)
          # For some reason packing the wave header struct with
          # a float in python 2 doesn't throw an exception
          wave_data.setnframes(int(self.frame_count()))
          wave_data.writeframesraw(pcm_for_wav)
          wave_data.close()
  
          # for easy wav files, we're done (wav data is written directly to out_f)
          if easy_wav:
              out_f.seek(0)
              return out_f
  
          output = NamedTemporaryFile(mode="w+b", delete=False)
  
          # build converter command to export
          conversion_command = [
              self.converter,
              '-y',  # always overwrite existing files
              "-f", "wav", "-i", data.name,  # input options (filename last)
          ]
  
          if codec is None:
              codec = self.DEFAULT_CODECS.get(format, None)
  
          if cover is not None:
              if cover.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tif', '.tiff')) and format == "mp3":
                  conversion_command.extend(["-i", cover, "-map", "0", "-map", "1", "-c:v", "mjpeg"])
              else:
                  raise AttributeError(
                      "Currently cover images are only supported by MP3 files. The allowed image formats are: .tif, .jpg, .bmp, .jpeg and .png.")
  
          if codec is not None:
              # force audio encoder
              conversion_command.extend(["-acodec", codec])
  
          if bitrate is not None:
              conversion_command.extend(["-b:a", bitrate])
  
          if parameters is not None:
              # extend arguments with arbitrary set
              conversion_command.extend(parameters)
  
          if tags is not None:
              if not isinstance(tags, dict):
                  raise InvalidTag("Tags must be a dictionary.")
              else:
                  # Extend converter command with tags
                  # print(tags)
                  for key, value in tags.items():
                      conversion_command.extend(
                          ['-metadata', '{0}={1}'.format(key, value)])
  
                  if format == 'mp3':
                      # set id3v2 tag version
  