docs: def validate_mutations(vcffile, bams, reffa, chr_reffa, samples, output_format, outfile,
                         mpileup_parameters=mpileup_parser.MPILEUP_DEFAULT_PARAMS):
      """Check if mutations in vcf are in bam"""
      output_header = "sample chrom pos ref cov A C G T * - + " \
          "val_ref val_alt val_al_type val_al_count val_maf "\
          "most_common_indel most_common_indel_count most_common_indel_maf most_common_indel_type most_common_al " \
          "most_common_al_count most_common_al_maf most_common_count most_common_maf".split()
  
      # for backwards compatibility
      # if bam or samples is a string, convert to list instead
      if isinstance(samples, six.string_types):
          samples = [samples]
      if isinstance(bams, six.string_types):
          bams = [bams]
  
      if output_format == 'vcf':
          vcf_reader = vcf.Reader(open(vcffile))
          vcf_reader.samples = samples
          vcf_reader.formats['GT'] = vcf.parser._Format(id='GT', num=1, type='String', desc="Genotype")
          vcf_reader.formats['AD'] = vcf.parser._Format(id='AD', num='R', type='Integer', desc="Allelic depth")
          vcf_reader.formats['DP'] = vcf.parser._Format(id='DP', num=1, type='Integer', desc="Depth")
          vcf_writer = vcf.Writer(outfile, vcf_reader)
      else:
          vcf_reader = open(vcffile)
  
  
      if output_format == "sufam":
          outfile.write("\t".join(output_header))
          outfile.write("\n")
      for record in vcf_reader:
          if output_format != 'vcf':
              line = record
              if line.startswith("#CHROM"):
                  header = line[1:].rstrip('\n').split("\t")
                  # create spoof pyvcf record if vcf_reader is not used
                  _Record = namedtuple('Record', header)
              if line.startswith("#"):
                  continue
              if len(header) == 0:
                  raise(Exception("No header found in vcf file #CHROM not found"))
              # zip all column values, except alt (needs to be list in pyvcf)
              record_args = dict(zip(header, line.rstrip('\n').split("\t")))
              record_args['ALT'] = [record_args['ALT']]
              record = _Record(**record_args)
  
          # determine type of mutation
          record_type = "snv"
          if len(record.ALT) > 1:
              warnings.warn("Multiple ALT in one record is not implemented - using first")
          if len(record.REF) > len(record.ALT[0]):
              record_type = "deletion"
          elif len(record.ALT[0]) > len(record.REF):
              record_type = "insertion"
  
          # no coverage results
          no_cov = pd.Series({
              "chrom": str(record.CHROM), "pos": str(record.POS),
              "ref": str(record.REF),
              "cov": 0, "A": 0, "C": 0, "G": 0, "T": 0,
              "val_ref": str(record.REF), "val_alt": str(record.ALT[0]),
              "val_al_type": record_type, "val_al_count": 0, "val_maf": 0})
  
          # collect mpileup baseparser results per bam
          bps = []
          for i, bam in enumerate(bams):
              sample = samples[i]
              no_cov['sample'] = sample
              bp_lines = mpileup_parser.run_and_parse(bam, str(record.CHROM), str(record.POS), str(record.POS), reffa,
                                                      chr_reffa, mpileup_parameters)
              bpdf = get_baseparser_extended_df(sample, bp_lines, str(record.REF), str(record.ALT[0]))
              if bpdf is None:
                  bp = no_cov
              else:
                  bp = bpdf.ix[0, :]
              bps += [bp]
  
          # output call
          if output_format == "vcf":
              _write_bp_vcf(outfile, bps, vcf_writer, record)
          else:
              # only one bam file supported for outputs other than vcf
              _write_bp(outfile, bps[0], output_header, output_format)