Full Code of tuffy/python-audio-tools for AI

gitextract_4hj81sl5/

├── COPYING
├── INSTALL
├── MANIFEST.in
├── Makefile
├── TODO
├── audiotools/
│   ├── __init__.py
│   ├── accuraterip.py
│   ├── aiff.py
│   ├── ape.py
│   ├── au.py
│   ├── cdtoc.py
│   ├── coverartarchive.py
│   ├── cue/
│   │   ├── __init__.py
│   │   ├── tokrules.py
│   │   └── yaccrules.py
│   ├── flac.py
│   ├── freedb.py
│   ├── id3.py
│   ├── id3v1.py
│   ├── image.py
│   ├── m4a.py
│   ├── m4a_atoms.py
│   ├── mp3.py
│   ├── mpc.py
│   ├── musicbrainz.py
│   ├── ogg.py
│   ├── opus.py
│   ├── player.py
│   ├── ply/
│   │   ├── README
│   │   ├── __init__.py
│   │   ├── lex.py
│   │   └── yacc.py
│   ├── speex.py
│   ├── text.py
│   ├── toc/
│   │   ├── __init__.py
│   │   ├── tokrules.py
│   │   └── yaccrules.py
│   ├── tta.py
│   ├── ui.py
│   ├── vorbis.py
│   ├── vorbiscomment.py
│   ├── wav.py
│   └── wavpack.py
├── audiotools-config
├── cdda2track
├── cddainfo
├── cddaplay
├── coverbrowse
├── coverdump
├── covertag
├── docs/
│   ├── COPYING
│   ├── Makefile
│   ├── audiotools-config.xml
│   ├── audiotools.cfg.xml
│   ├── cdda2track.xml
│   ├── cddainfo.xml
│   ├── cddaplay.xml
│   ├── coverbrowse.xml
│   ├── coverdump.xml
│   ├── covertag.xml
│   ├── dvda2track.xml
│   ├── dvdainfo.xml
│   ├── manpagexml.py
│   ├── programming/
│   │   ├── Makefile
│   │   └── source/
│   │       ├── audiotools.rst
│   │       ├── audiotools_accuraterip.rst
│   │       ├── audiotools_bitstream.rst
│   │       ├── audiotools_cdio.rst
│   │       ├── audiotools_cue.rst
│   │       ├── audiotools_dvda.rst
│   │       ├── audiotools_freedb.rst
│   │       ├── audiotools_musicbrainz.rst
│   │       ├── audiotools_pcm.rst
│   │       ├── audiotools_pcmconverter.rst
│   │       ├── audiotools_player.rst
│   │       ├── audiotools_replaygain.rst
│   │       ├── audiotools_toc.rst
│   │       ├── audiotools_ui.rst
│   │       ├── conf.py
│   │       ├── huffman.dot
│   │       ├── index.rst
│   │       └── metadata.rst
│   ├── track2cdda.xml
│   ├── track2track.xml
│   ├── trackcat.xml
│   ├── trackcmp.xml
│   ├── trackinfo.xml
│   ├── tracklength.xml
│   ├── tracklint.xml
│   ├── trackplay.xml
│   ├── trackrename.xml
│   ├── tracksplit.xml
│   ├── tracktag.xml
│   └── trackverify.xml
├── dvda2track
├── dvdainfo
├── setup.cfg
├── setup.py
├── src/
│   ├── COPYING.LESSERv3
│   ├── Makefile
│   ├── accuraterip.c
│   ├── accuraterip.h
│   ├── bitstream-table.c
│   ├── bitstream.c
│   ├── bitstream.h
│   ├── buffer.c
│   ├── buffer.h
│   ├── cdiomodule.c
│   ├── cdiomodule.h
│   ├── common/
│   │   ├── flac_crc.c
│   │   ├── flac_crc.h
│   │   ├── m4a_atoms.c
│   │   ├── m4a_atoms.h
│   │   ├── md5.c
│   │   ├── md5.h
│   │   ├── tta_crc.c
│   │   └── tta_crc.h
│   ├── decoders/
│   │   ├── NOTES.rst
│   │   ├── alac.c
│   │   ├── alac.h
│   │   ├── alac_residual.h
│   │   ├── alac_residual.json
│   │   ├── flac.c
│   │   ├── flac.h
│   │   ├── mp3.c
│   │   ├── mp3.h
│   │   ├── mpc.c
│   │   ├── mpc.h
│   │   ├── oggflac.c
│   │   ├── oggflac.h
│   │   ├── opus.c
│   │   ├── opus.h
│   │   ├── sine.c
│   │   ├── sine.h
│   │   ├── tta.c
│   │   ├── tta.h
│   │   ├── vorbis.c
│   │   ├── vorbis.h
│   │   ├── wavpack.c
│   │   └── wavpack.h
│   ├── decoders.c
│   ├── decoders.h
│   ├── dither.c
│   ├── dvdamodule.c
│   ├── dvdamodule.h
│   ├── encoders/
│   │   ├── NOTES.rst
│   │   ├── alac.c
│   │   ├── alac.h
│   │   ├── flac.c
│   │   ├── flac.h
│   │   ├── mp2.c
│   │   ├── mp3.c
│   │   ├── mpc.c
│   │   ├── opus.c
│   │   ├── tta.c
│   │   ├── tta.h
│   │   ├── vorbis.c
│   │   ├── wavpack.c
│   │   └── wavpack.h
│   ├── encoders.c
│   ├── encoders.h
│   ├── framelist.c
│   ├── framelist.h
│   ├── func_io.c
│   ├── func_io.h
│   ├── huffman.c
│   ├── huffman.h
│   ├── libmpcdec/
│   │   ├── AUTHORS
│   │   ├── COPYING
│   │   ├── ChangeLog
│   │   ├── README
│   │   ├── decoder.h
│   │   ├── huffman.c
│   │   ├── huffman.h
│   │   ├── internal.h
│   │   ├── mpc_bits_reader.c
│   │   ├── mpc_bits_reader.h
│   │   ├── mpc_decoder.c
│   │   ├── mpc_demux.c
│   │   ├── mpc_reader.c
│   │   ├── mpcdec_math.h
│   │   ├── requant.c
│   │   ├── requant.h
│   │   ├── streaminfo.c
│   │   └── synth_filter.c
│   ├── libmpcenc/
│   │   ├── analy_filter.c
│   │   ├── bitstream.c
│   │   ├── encode_sv7.c
│   │   ├── huffsv7.c
│   │   ├── libmpcenc.h
│   │   └── quant.c
│   ├── libmpcpsy/
│   │   ├── ans.c
│   │   ├── cvd.c
│   │   ├── fft4g.c
│   │   ├── fft_routines.c
│   │   ├── libmpcpsy.h
│   │   ├── profile.c
│   │   ├── psy.c
│   │   └── psy_tab.c
│   ├── mini-gmp.c
│   ├── mini-gmp.h
│   ├── mod_bitstream.c
│   ├── mod_bitstream.h
│   ├── mod_defs.h
│   ├── mod_ogg.c
│   ├── mod_ogg.h
│   ├── mpc/
│   │   ├── datatypes.h
│   │   ├── minimax.h
│   │   ├── mpc_crc32.c
│   │   ├── mpc_types.h
│   │   ├── mpcdec.h
│   │   ├── mpcmath.h
│   │   ├── reader.h
│   │   └── streaminfo.h
│   ├── ogg.c
│   ├── ogg.h
│   ├── ogg_crc.c
│   ├── ogg_crc.h
│   ├── output/
│   │   ├── alsa.c
│   │   ├── alsa.h
│   │   ├── core_audio.c
│   │   ├── core_audio.h
│   │   ├── pulseaudio.c
│   │   ├── pulseaudio.h
│   │   ├── sfifo.c
│   │   └── sfifo.h
│   ├── output.c
│   ├── parson.c
│   ├── parson.h
│   ├── pcm.c
│   ├── pcm.h
│   ├── pcm_conv.c
│   ├── pcm_conv.h
│   ├── pcmconverter.c
│   ├── pcmconverter.h
│   ├── pcmreader.c
│   ├── pcmreader.h
│   ├── read_bits_table_be.h
│   ├── read_bits_table_le.h
│   ├── read_unary_table_be.h
│   ├── read_unary_table_le.h
│   ├── replaygain.c
│   ├── replaygain.h
│   ├── samplerate/
│   │   ├── common.h
│   │   ├── fastest_coeffs.h
│   │   ├── float_cast.h
│   │   ├── high_qual_coeffs.h
│   │   ├── mid_qual_coeffs.h
│   │   ├── samplerate.c
│   │   ├── samplerate.h
│   │   ├── src_linear.c
│   │   ├── src_sinc.c
│   │   └── src_zoh.c
│   ├── unread_bit_table_be.h
│   └── unread_bit_table_le.h
├── test/
│   ├── 1h.flac
│   ├── 1m.flac
│   ├── 1s.flac
│   ├── aiff-1ch.aiff
│   ├── aiff-2ch.aiff
│   ├── aiff-6ch.aiff
│   ├── aiff-8bit.aiff
│   ├── aiff-metadata.aiff
│   ├── aiff-misordered.aiff
│   ├── aiff-nossnd.aiff
│   ├── alac-allframes.m4a
│   ├── apptest.sh
│   ├── autotag.sh
│   ├── cdda_test.cue
│   ├── cdtoc1.flac
│   ├── cdtoc2.flac
│   ├── error.py
│   ├── flac-allframes.flac
│   ├── flac-disordered.flac
│   ├── flac-id3-2.flac
│   ├── flac-id3.flac
│   ├── flac-nomask1.flac
│   ├── flac-nomask2.flac
│   ├── flac-nomask3.flac
│   ├── flac-nomask4.flac
│   ├── flac-nonmd5.flac
│   ├── flac-noseektable.flac
│   ├── flac-seektable.flac
│   ├── freedb_test_discid-1.cue
│   ├── freedb_test_discid-2.cue
│   ├── freedb_test_discid-3.cue
│   ├── freedb_test_discid-4.cue
│   ├── freedb_test_discid-5.cue
│   ├── huge.bmp.bz2
│   ├── image_test_metrics-6.tiff
│   ├── imagetiff_setup.tiff
│   ├── m4a-faac.m4a
│   ├── m4a-faac2.m4a
│   ├── m4a-faac3.m4a
│   ├── m4a-itunes.m4a
│   ├── m4a-nero.m4a
│   ├── m4a-nero2.m4a
│   ├── m4a-nero3.m4a
│   ├── metadata_flac_cuesheet-1.cue
│   ├── metadata_flac_cuesheet-2.cue
│   ├── metadata_flac_cuesheet-3.cue
│   ├── shorten-frames.shn
│   ├── shorten-lpc.shn
│   ├── silence.wv
│   ├── sine.mp2
│   ├── test.cfg
│   ├── test.py
│   ├── test_cdrdao.py
│   ├── test_cdrecord.py
│   ├── test_core.py
│   ├── test_formats.py
│   ├── test_metadata.py
│   ├── test_streams.py
│   ├── test_utils.py
│   ├── tone.flac
│   ├── tone1.flac
│   ├── tone2.flac
│   ├── tone3.flac
│   ├── tone4.flac
│   ├── tone5.flac
│   ├── tone6.flac
│   ├── tone7.flac
│   ├── tone8.flac
│   ├── trackcat_pre_gap.cue
│   ├── trackcat_pre_gap2.cue
│   ├── trueaudio.tta
│   └── wavpack-combo.wv
├── track2cdda
├── track2track
├── trackcat
├── trackcmp
├── trackinfo
├── tracklength
├── tracklint
├── trackplay
├── trackrename
├── tracksplit
├── tracktag
└── trackverify

SYMBOL INDEX (5779 symbols across 175 files)

FILE: audiotools/__init__.py
  class RawConfigParser (line 39) | class RawConfigParser(RawConfigParser):
    method get_default (line 42) | def get_default(self, section, option, default):
    method set_default (line 57) | def set_default(self, section, option, value):
    method getint_default (line 69) | def getint_default(self, section, option, default):
    method getboolean_default (line 84) | def getboolean_default(self, section, option, default):
  class __system_binaries__ (line 109) | class __system_binaries__(object):
    method __init__ (line 110) | def __init__(self, config):
    method __getitem__ (line 113) | def __getitem__(self, command):
    method can_execute (line 126) | def can_execute(self, command):
  function __format_fields__ (line 168) | def __format_fields__():
  function __default_quality__ (line 257) | def __default_quality__(audio_type):
  class Messenger (line 278) | class Messenger(object):
    method __init__ (line 281) | def __init__(self, silent=False):
    method output_isatty (line 295) | def output_isatty(self):
    method info_isatty (line 298) | def info_isatty(self):
    method error_isatty (line 301) | def error_isatty(self):
    method __print_silent__ (line 304) | def __print_silent__(self, string, stream, add_newline, flush):
    method __print_py2__ (line 313) | def __print_py2__(self, string, stream, add_newline, flush):
    method __print_py3__ (line 327) | def __print_py3__(self, string, stream, add_newline, flush):
    method output (line 339) | def output(self, s):
    method partial_output (line 349) | def partial_output(self, s):
    method info (line 359) | def info(self, s):
    method partial_info (line 369) | def partial_info(self, s):
    method error (line 388) | def error(self, s):
    method os_error (line 398) | def os_error(self, oserror):
    method warning (line 408) | def warning(self, s):
    method ansi_clearline (line 418) | def ansi_clearline(self):
    method ansi_uplines (line 435) | def ansi_uplines(self, lines):
    method ansi_cleardown (line 441) | def ansi_cleardown(self):
    method ansi_clearscreen (line 447) | def ansi_clearscreen(self):
    method terminal_size (line 453) | def terminal_size(self, fd):
  class SilentMessenger (line 470) | class SilentMessenger(Messenger):
    method __init__ (line 471) | def __init__(self):
  function khz (line 475) | def khz(hz):
  function hex_string (line 489) | def hex_string(byte_string):
  class output_text (line 500) | class output_text(tuple):
    method __new__ (line 517) | def __new__(cls, unicode_string, fg_color=None, bg_color=None, style=N...
    method __construct__ (line 553) | def __construct__(cls,
    method __repr__ (line 584) | def __repr__(self):
    method __open_codes__ (line 593) | def __open_codes__(cls, fg_color, bg_color, style):
    method __close_codes__ (line 637) | def __close_codes__(cls, fg_color, bg_color, style):
    method __str__ (line 667) | def __str__(self):
    method __str__ (line 670) | def __str__(self):
    method __unicode__ (line 673) | def __unicode__(self):
    method char_widths (line 676) | def char_widths(self):
    method __len__ (line 682) | def __len__(self):
    method fg_color (line 685) | def fg_color(self):
    method bg_color (line 690) | def bg_color(self):
    method style (line 695) | def style(self):
    method set_string (line 700) | def set_string(self, unicode_string, char_widths):
    method set_format (line 713) | def set_format(self, fg_color=None, bg_color=None, style=None):
    method has_formatting (line 729) | def has_formatting(self):
    method format (line 736) | def format(self, is_tty=False):
    method head (line 744) | def head(self, display_characters):
    method tail (line 770) | def tail(self, display_characters):
    method split (line 799) | def split(self, display_characters):
    method join (line 830) | def join(self, output_texts):
  class output_list (line 842) | class output_list(output_text):
    method __new__ (line 852) | def __new__(cls, output_texts, fg_color=None, bg_color=None, style=None):
    method __construct__ (line 873) | def __construct__(cls,
    method __unicode__ (line 903) | def __unicode__(self):
    method char_widths (line 906) | def char_widths(self):
    method __len__ (line 913) | def __len__(self):
    method fg_color (line 916) | def fg_color(self):
    method bg_color (line 921) | def bg_color(self):
    method style (line 926) | def style(self):
    method set_string (line 931) | def set_string(self, output_texts):
    method set_format (line 943) | def set_format(self, fg_color=None, bg_color=None, style=None):
    method has_formatting (line 958) | def has_formatting(self):
    method format (line 965) | def format(self, is_tty=False):
    method head (line 980) | def head(self, display_characters):
    method tail (line 1003) | def tail(self, display_characters):
    method split (line 1026) | def split(self, display_characters):
  class output_table (line 1058) | class output_table(object):
    method __init__ (line 1059) | def __init__(self):
    method row (line 1064) | def row(self):
    method blank_row (line 1071) | def blank_row(self):
    method divider_row (line 1076) | def divider_row(self, dividers):
    method format (line 1083) | def format(self, is_tty=False):
  class output_table_blank (line 1108) | class output_table_blank(object):
    method __init__ (line 1111) | def __init__(self):
    method blank (line 1114) | def blank(self):
    method column_width (line 1117) | def column_width(self, column):
    method format (line 1120) | def format(self, column_widths, is_tty=False):
  class output_table_divider (line 1126) | class output_table_divider(output_table_blank):
    method __init__ (line 1129) | def __init__(self, dividers):
    method blank (line 1132) | def blank(self):
    method __len__ (line 1135) | def __len__(self):
    method column_width (line 1138) | def column_width(self, column):
    method format (line 1141) | def format(self, column_widths, is_tty=False):
  class output_table_row (line 1151) | class output_table_row(output_table_divider):
    method __init__ (line 1152) | def __init__(self):
    method __len__ (line 1157) | def __len__(self):
    method column_width (line 1160) | def column_width(self, column):
    method format (line 1163) | def format(self, column_widths, is_tty=False):
    method add_column (line 1172) | def add_column(self, text, alignment="left", colspan=1):
  class output_table_col (line 1191) | class output_table_col(object):
    method __init__ (line 1192) | def __init__(self, text, alignment="left"):
    method minimum_width (line 1211) | def minimum_width(self):
    method __format_left__ (line 1214) | def __format_left__(self, column_width, is_tty):
    method __format_center__ (line 1225) | def __format_center__(self, column_width, is_tty):
    method __format_right__ (line 1240) | def __format_right__(self, column_width, is_tty):
  class output_table_multicol_accumulator (line 1252) | class output_table_multicol_accumulator(output_table_col):
    method __init__ (line 1253) | def __init__(self):
    method minimum_width (line 1256) | def minimum_width(self):
    method actual_width (line 1259) | def actual_width(self):
    method format (line 1262) | def format(self, column_width, is_tty):
  class output_table_multicol (line 1267) | class output_table_multicol(output_table_col):
    method __init__ (line 1268) | def __init__(self, accumulators, text, alignment="left"):
    method minimum_width (line 1272) | def minimum_width(self):
    method format (line 1275) | def format(self, column_width, is_tty):
  class ProgressDisplay (line 1281) | class ProgressDisplay(object):
    method __init__ (line 1284) | def __init__(self, messenger):
    method add_row (line 1294) | def add_row(self, output_line):
    method remove_row (line 1312) | def remove_row(self, row_index):
    method display_rows (line 1318) | def display_rows(self):
    method clear_rows (line 1331) | def clear_rows(self):
    method output_line (line 1340) | def output_line(self, line):
  class ProgressRow (line 1348) | class ProgressRow(object):
    method __init__ (line 1354) | def __init__(self, progress_display, row_index, output_line):
    method update (line 1369) | def update(self, progress):
    method finish (line 1374) | def finish(self):
    method unicode (line 1379) | def unicode(self, width):
  class SingleProgressDisplay (line 1425) | class SingleProgressDisplay(ProgressDisplay):
    method __init__ (line 1428) | def __init__(self, messenger, progress_text):
    method update (line 1439) | def update(self, progress):
  class ReplayGainProgressDisplay (line 1450) | class ReplayGainProgressDisplay(ProgressDisplay):
    method __init__ (line 1453) | def __init__(self, messenger):
    method initial_message_tty (line 1475) | def initial_message_tty(self):
    method initial_message_nontty (line 1480) | def initial_message_nontty(self):
    method update_tty (line 1487) | def update_tty(self, progress):
    method update_nontty (line 1497) | def update_nontty(self, progress):
    method final_message_tty (line 1502) | def final_message_tty(self):
    method final_message_nontty (line 1510) | def final_message_nontty(self):
  class UnsupportedFile (line 1516) | class UnsupportedFile(Exception):
  class InvalidFile (line 1522) | class InvalidFile(Exception):
  class EncodingError (line 1528) | class EncodingError(IOError):
    method __init__ (line 1532) | def __init__(self, error_message):
    method __str__ (line 1538) | def __str__(self):
    method __str__ (line 1541) | def __str__(self):
    method __unicode__ (line 1544) | def __unicode__(self):
  class UnsupportedChannelMask (line 1548) | class UnsupportedChannelMask(EncodingError):
    method __init__ (line 1551) | def __init__(self, filename, mask):
    method __reduce__ (line 1562) | def __reduce__(self):
  class UnsupportedChannelCount (line 1566) | class UnsupportedChannelCount(EncodingError):
    method __init__ (line 1569) | def __init__(self, filename, count):
    method __reduce__ (line 1580) | def __reduce__(self):
  class UnsupportedBitsPerSample (line 1584) | class UnsupportedBitsPerSample(EncodingError):
    method __init__ (line 1587) | def __init__(self, filename, bits_per_sample):
    method __reduce__ (line 1598) | def __reduce__(self):
  class DecodingError (line 1603) | class DecodingError(IOError):
    method __init__ (line 1609) | def __init__(self, error_message):
    method __str__ (line 1615) | def __str__(self):
    method __str__ (line 1618) | def __str__(self):
    method __unicode__ (line 1621) | def __unicode__(self):
  function file_type (line 1625) | def file_type(file):
  function open (line 1771) | def open(filename):
  class DuplicateFile (line 1792) | class DuplicateFile(Exception):
    method __init__ (line 1795) | def __init__(self, filename):
  class DuplicateOutputFile (line 1803) | class DuplicateOutputFile(Exception):
    method __init__ (line 1806) | def __init__(self, filename):
  class OutputFileIsInput (line 1814) | class OutputFileIsInput(Exception):
    method __init__ (line 1817) | def __init__(self, filename):
  class Filename (line 1825) | class Filename(tuple):
    method __new__ (line 1826) | def __new__(cls, filename):
    method from_unicode (line 1847) | def from_unicode(cls, unicode_string):
    method open (line 1854) | def open(self, mode):
    method disk_file (line 1860) | def disk_file(self):
    method dirname (line 1865) | def dirname(self):
    method basename (line 1870) | def basename(self):
    method expanduser (line 1875) | def expanduser(self):
    method abspath (line 1880) | def abspath(self):
    method __repr__ (line 1885) | def __repr__(self):
    method __eq__ (line 1888) | def __eq__(self, filename):
    method __ne__ (line 1905) | def __ne__(self, filename):
    method __hash__ (line 1908) | def __hash__(self):
    method __str__ (line 1914) | def __str__(self):
    method __unicode__ (line 1918) | def __unicode__(self):
    method __unicode__ (line 1921) | def __unicode__(self):
  function sorted_tracks (line 1925) | def sorted_tracks(audiofiles):
  function open_files (line 1934) | def open_files(filename_list, sorted=True, messenger=None,
  function open_directory (line 1992) | def open_directory(directory, sorted=True, messenger=None):
  function group_tracks (line 2011) | def group_tracks(tracks):
  class UnknownAudioType (line 2037) | class UnknownAudioType(Exception):
    method __init__ (line 2040) | def __init__(self, suffix):
    method error_msg (line 2043) | def error_msg(self, messenger):
  class AmbiguousAudioType (line 2049) | class AmbiguousAudioType(UnknownAudioType):
    method __init__ (line 2052) | def __init__(self, suffix, type_list):
    method error_msg (line 2056) | def error_msg(self, messenger):
  function filename_to_type (line 2067) | def filename_to_type(path):
  class ChannelMask (line 2095) | class ChannelMask(object):
    method __init__ (line 2190) | def __init__(self, mask):
    method __repr__ (line 2198) | def __repr__(self):
    method __str__ (line 2205) | def __str__(self):
    method __str__ (line 2208) | def __str__(self):
    method __unicode__ (line 2211) | def __unicode__(self):
    method __int__ (line 2218) | def __int__(self):
    method __eq__ (line 2228) | def __eq__(self, v):
    method __ne__ (line 2231) | def __ne__(self, v):
    method __len__ (line 2234) | def __len__(self):
    method defined (line 2238) | def defined(self):
    method undefined (line 2243) | def undefined(self):
    method channels (line 2248) | def channels(self):
    method index (line 2263) | def index(self, channel_name):
    method from_fields (line 2273) | def from_fields(cls, **fields):
    method from_channels (line 2292) | def from_channels(cls, channel_count):
  class PCMReader (line 2306) | class PCMReader(object):
    method __init__ (line 2307) | def __init__(self, sample_rate, channels, channel_mask, bits_per_sample):
    method __enter__ (line 2345) | def __enter__(self):
    method __exit__ (line 2348) | def __exit__(self, exc_type, exc_value, traceback):
    method read (line 2351) | def read(self, pcm_frames):
    method close (line 2367) | def close(self):
  class PCMFileReader (line 2375) | class PCMFileReader(PCMReader):
    method __init__ (line 2378) | def __init__(self, file,
    method read (line 2409) | def read(self, pcm_frames):
    method close (line 2440) | def close(self):
    method __del__ (line 2450) | def __del__(self):
  class PCMReaderError (line 2456) | class PCMReaderError(PCMReader):
    method __init__ (line 2462) | def __init__(self, error_message,
    method read (line 2471) | def read(self, pcm_frames):
    method close (line 2476) | def close(self):
  function to_pcm_progress (line 2482) | def to_pcm_progress(audiofile, progress):
  class PCMReaderProgress (line 2491) | class PCMReaderProgress(PCMReader):
    method __init__ (line 2492) | def __init__(self, pcmreader, total_frames, progress, current_frames=0):
    method read (line 2512) | def read(self, pcm_frames):
    method close (line 2518) | def close(self):
  class ReorderedPCMReader (line 2522) | class ReorderedPCMReader(PCMReader):
    method __init__ (line 2525) | def __init__(self, pcmreader, channel_order, channel_mask=None):
    method read (line 2554) | def read(self, pcm_frames):
    method close (line 2562) | def close(self):
  class ThreadedPCMReader (line 2568) | class ThreadedPCMReader(PCMReader):
    method __init__ (line 2577) | def __init__(self, pcmreader):
    method read (line 2615) | def read(self, pcm_frames):
    method close (line 2633) | def close(self):
  function transfer_data (line 2644) | def transfer_data(from_function, to_function):
  function transfer_framelist_data (line 2660) | def transfer_framelist_data(pcmreader, to_function,
  function pcm_cmp (line 2682) | def pcm_cmp(pcmreader1, pcmreader2):
  function pcm_frame_cmp (line 2694) | def pcm_frame_cmp(pcmreader1, pcmreader2):
  class PCMCat (line 2754) | class PCMCat(PCMReader):
    method __init__ (line 2757) | def __init__(self, pcmreaders):
    method read (line 2788) | def read(self, pcm_frames):
    method read_closed (line 2807) | def read_closed(self, pcm_frames):
    method close (line 2810) | def close(self):
  class CounterPCMReader (line 2821) | class CounterPCMReader(PCMReader):
    method __init__ (line 2824) | def __init__(self, pcmreader):
    method bytes_written (line 2833) | def bytes_written(self):
    method read (line 2838) | def read(self, pcm_frames):
    method close (line 2843) | def close(self):
  class LimitedFileReader (line 2847) | class LimitedFileReader(object):
    method __init__ (line 2848) | def __init__(self, file, total_bytes):
    method read (line 2852) | def read(self, x):
    method close (line 2865) | def close(self):
  class LimitedPCMReader (line 2869) | class LimitedPCMReader(PCMReader):
    method __init__ (line 2870) | def __init__(self, buffered_pcmreader, total_pcm_frames):
    method read (line 2886) | def read(self, pcm_frames):
    method read_closed (line 2894) | def read_closed(self, pcm_frames):
    method close (line 2897) | def close(self):
  function PCMConverter (line 2901) | def PCMConverter(pcmreader,
  class ReplayGainCalculator (line 2977) | class ReplayGainCalculator:
    method __init__ (line 2978) | def __init__(self, sample_rate):
    method sample_rate (line 2984) | def sample_rate(self):
    method __iter__ (line 2987) | def __iter__(self):
    method to_pcm (line 2999) | def to_pcm(self, pcmreader):
  class ReplayGainCalculatorReader (line 3013) | class ReplayGainCalculatorReader(PCMReader):
    method __init__ (line 3014) | def __init__(self, replaygain, pcmreader):
    method read (line 3025) | def read(self, pcm_frames):
    method close (line 3030) | def close(self):
    method title_gain (line 3040) | def title_gain(self):
    method title_peak (line 3046) | def title_peak(self):
  function resampled_frame_count (line 3053) | def resampled_frame_count(initial_frame_count,
  function calculate_replay_gain (line 3071) | def calculate_replay_gain(tracks, progress=None):
  function add_replay_gain (line 3122) | def add_replay_gain(tracks, progress=None):
  function ignore_sigint (line 3139) | def ignore_sigint():
  function make_dirs (line 3152) | def make_dirs(destination_path):
  class MetaData (line 3163) | class MetaData(object):
    method __init__ (line 3286) | def __init__(self,
    method __repr__ (line 3361) | def __repr__(self):
    method __delattr__ (line 3368) | def __delattr__(self, field):
    method fields (line 3377) | def fields(self):
    method filled_fields (line 3383) | def filled_fields(self):
    method empty_fields (line 3391) | def empty_fields(self):
    method __str__ (line 3400) | def __str__(self):
    method __str__ (line 3403) | def __str__(self):
    method __unicode__ (line 3406) | def __unicode__(self):
    method raw_info (line 3489) | def raw_info(self):
    method __eq__ (line 3500) | def __eq__(self, metadata):
    method __ne__ (line 3508) | def __ne__(self, metadata):
    method converted (line 3512) | def converted(cls, metadata):
    method supports_images (line 3530) | def supports_images(cls):
    method images (line 3535) | def images(self):
    method front_covers (line 3542) | def front_covers(self):
    method back_covers (line 3547) | def back_covers(self):
    method leaflet_pages (line 3552) | def leaflet_pages(self):
    method media_images (line 3557) | def media_images(self):
    method other_images (line 3562) | def other_images(self):
    method add_image (line 3567) | def add_image(self, image):
    method delete_image (line 3582) | def delete_image(self, image):
    method clean (line 3597) | def clean(self):
    method intersection (line 3613) | def intersection(self, metadata):
  class Image (line 3638) | class Image(object):
    method __init__ (line 3641) | def __init__(self, data, mime_type, width, height,
    method suffix (line 3678) | def suffix(self):
    method type_string (line 3691) | def type_string(self):
    method __repr__ (line 3703) | def __repr__(self):
    method __str__ (line 3715) | def __str__(self):
    method __str__ (line 3718) | def __str__(self):
    method __unicode__ (line 3721) | def __unicode__(self):
    method new (line 3728) | def new(cls, image_data, description, type):
    method __eq__ (line 3753) | def __eq__(self, image):
    method __ne__ (line 3762) | def __ne__(self, image):
  class InvalidImage (line 3766) | class InvalidImage(Exception):
  class ReplayGain (line 3770) | class ReplayGain(object):
    method __init__ (line 3773) | def __init__(self, track_gain, track_peak, album_gain, album_peak):
    method __repr__ (line 3789) | def __repr__(self):
    method __eq__ (line 3795) | def __eq__(self, rg):
    method __ne__ (line 3804) | def __ne__(self, rg):
  class UnsupportedTracknameField (line 3808) | class UnsupportedTracknameField(Exception):
    method __init__ (line 3812) | def __init__(self, field):
    method error_msg (line 3815) | def error_msg(self, messenger):
  class InvalidFilenameFormat (line 3831) | class InvalidFilenameFormat(Exception):
    method __init__ (line 3835) | def __init__(self, *args):
  class AudioFile (line 3840) | class AudioFile(object):
    method __init__ (line 3856) | def __init__(self, filename):
    method __repr__ (line 3863) | def __repr__(self):
    method __sort_key__ (line 3871) | def __sort_key__(self):
    method __eq__ (line 3881) | def __eq__(self, audiofile):
    method __ne__ (line 3888) | def __ne__(self, audiofile):
    method __lt__ (line 3891) | def __lt__(self, audiofile):
    method __le__ (line 3898) | def __le__(self, audiofile):
    method __gt__ (line 3905) | def __gt__(self, audiofile):
    method __ge__ (line 3912) | def __ge__(self, audiofile):
    method __gt__ (line 3919) | def __gt__(self, audiofile):
    method bits_per_sample (line 3926) | def bits_per_sample(self):
    method channels (line 3931) | def channels(self):
    method channel_mask (line 3936) | def channel_mask(self):
    method lossless (line 3946) | def lossless(self):
    method supports_metadata (line 3952) | def supports_metadata(cls):
    method update_metadata (line 3957) | def update_metadata(self, metadata):
    method set_metadata (line 3974) | def set_metadata(self, metadata):
    method get_metadata (line 3987) | def get_metadata(self):
    method delete_metadata (line 3994) | def delete_metadata(self):
    method total_frames (line 4002) | def total_frames(self):
    method cd_frames (line 4007) | def cd_frames(self):
    method seconds_length (line 4017) | def seconds_length(self):
    method sample_rate (line 4028) | def sample_rate(self):
    method supports_to_pcm (line 4034) | def supports_to_pcm(cls):
    method to_pcm (line 4040) | def to_pcm(self):
    method supports_from_pcm (line 4049) | def supports_from_pcm(cls):
    method from_pcm (line 4056) | def from_pcm(cls, filename, pcmreader,
    method convert (line 4088) | def convert(self, target_path, target_class,
    method seekable (line 4104) | def seekable(self):
    method __unlink__ (line 4114) | def __unlink__(cls, filename):
    method track_name (line 4121) | def track_name(cls, file_path, track_metadata=None, format=None,
    method supports_replay_gain (line 4235) | def supports_replay_gain(cls):
    method get_replay_gain (line 4241) | def get_replay_gain(self):
    method set_replay_gain (line 4251) | def set_replay_gain(self, replaygain):
    method delete_replay_gain (line 4259) | def delete_replay_gain(self):
    method supports_cuesheet (line 4268) | def supports_cuesheet(self):
    method set_cuesheet (line 4273) | def set_cuesheet(self, cuesheet):
    method get_cuesheet (line 4280) | def get_cuesheet(self):
    method delete_cuesheet (line 4287) | def delete_cuesheet(self):
    method verify (line 4294) | def verify(self, progress=None):
    method clean (line 4319) | def clean(self, output_filename=None):
  class WaveContainer (line 4360) | class WaveContainer(AudioFile):
    method has_foreign_wave_chunks (line 4361) | def has_foreign_wave_chunks(self):
    method wave_header_footer (line 4368) | def wave_header_footer(self):
    method from_wave (line 4381) | def from_wave(cls, filename, header, pcmreader, footer, compression=No...
    method convert (line 4400) | def convert(self, target_path, target_class, compression=None,
  class AiffContainer (line 4433) | class AiffContainer(AudioFile):
    method has_foreign_aiff_chunks (line 4434) | def has_foreign_aiff_chunks(self):
    method aiff_header_footer (line 4441) | def aiff_header_footer(self):
    method from_aiff (line 4453) | def from_aiff(cls, filename, header, pcmreader, footer, compression=No...
    method convert (line 4472) | def convert(self, target_path, target_class, compression=None,
  class SheetException (line 4506) | class SheetException(ValueError):
  function read_sheet (line 4512) | def read_sheet(filename):
  function read_sheet_string (line 4525) | def read_sheet_string(sheet_string):
  class Sheet (line 4544) | class Sheet(object):
    method __init__ (line 4548) | def __init__(self, sheet_tracks, metadata=None):
    method converted (line 4556) | def converted(cls, sheet):
    method from_cddareader (line 4563) | def from_cddareader(cls, cddareader, filename=u"CDImage.wav"):
    method from_tracks (line 4585) | def from_tracks(cls, audiofiles, filename=u"CDImage.wav"):
    method __repr__ (line 4634) | def __repr__(self):
    method __len__ (line 4638) | def __len__(self):
    method __getitem__ (line 4641) | def __getitem__(self, index):
    method __eq__ (line 4644) | def __eq__(self, sheet):
    method track_numbers (line 4658) | def track_numbers(self):
    method track (line 4663) | def track(self, track_number):
    method pre_gap (line 4673) | def pre_gap(self):
    method track_offset (line 4684) | def track_offset(self, track_number):
    method track_length (line 4693) | def track_length(self, track_number, total_length=None):
    method image_formatted (line 4714) | def image_formatted(self):
    method get_metadata (line 4735) | def get_metadata(self):
  class SheetTrack (line 4743) | class SheetTrack(object):
    method __init__ (line 4744) | def __init__(self, number,
    method converted (line 4775) | def converted(cls, sheet_track):
    method __repr__ (line 4787) | def __repr__(self):
    method __len__ (line 4799) | def __len__(self):
    method __getitem__ (line 4802) | def __getitem__(self, i):
    method indexes (line 4805) | def indexes(self):
    method index (line 4810) | def index(self, index_number):
    method __eq__ (line 4820) | def __eq__(self, sheet_track):
    method __ne__ (line 4839) | def __ne__(self, sheet_track):
    method number (line 4842) | def number(self):
    method get_metadata (line 4847) | def get_metadata(self):
    method filename (line 4852) | def filename(self):
    method is_audio (line 4857) | def is_audio(self):
    method pre_emphasis (line 4862) | def pre_emphasis(self):
    method copy_permitted (line 4867) | def copy_permitted(self):
  class SheetIndex (line 4873) | class SheetIndex(object):
    method __init__ (line 4874) | def __init__(self, number, offset):
    method converted (line 4884) | def converted(cls, sheet_index):
    method __repr__ (line 4890) | def __repr__(self):
    method __eq__ (line 4894) | def __eq__(self, sheet_index):
    method __ne__ (line 4901) | def __ne__(self, sheet_index):
    method number (line 4904) | def number(self):
    method offset (line 4907) | def offset(self):
  function has_pre_gap_track (line 4911) | def has_pre_gap_track(audiofiles):
  function iter_first (line 4945) | def iter_first(iterator):
  function iter_last (line 4957) | def iter_last(iterator):
  function PCMReaderWindow (line 4982) | def PCMReaderWindow(pcmreader, initial_offset, pcm_frames, forward_close...
  class PCMReaderHead (line 5007) | class PCMReaderHead(PCMReader):
    method __init__ (line 5010) | def __init__(self, pcmreader, pcm_frames, forward_close=True):
    method __repr__ (line 5037) | def __repr__(self):
    method read (line 5041) | def read(self, pcm_frames):
    method read_closed (line 5072) | def read_closed(self, pcm_frames):
    method close (line 5075) | def close(self):
  class PCMReaderDeHead (line 5081) | class PCMReaderDeHead(PCMReader):
    method __init__ (line 5084) | def __init__(self, pcmreader, pcm_frames, forward_close=True):
    method __repr__ (line 5108) | def __repr__(self):
    method read (line 5112) | def read(self, pcm_frames):
    method read_closed (line 5147) | def read_closed(self, pcm_frames):
    method close (line 5150) | def close(self):
  function most_numerous (line 5157) | def most_numerous(item_list, empty_list=None, all_differ=None):
  function metadata_lookup (line 5179) | def metadata_lookup(musicbrainz_disc_id,
  function cddareader_metadata_lookup (line 5221) | def cddareader_metadata_lookup(cddareader,
  function track_metadata_lookup (line 5244) | def track_metadata_lookup(audiofiles,
  function sheet_metadata_lookup (line 5297) | def sheet_metadata_lookup(sheet,
  function accuraterip_lookup (line 5327) | def accuraterip_lookup(sorted_tracks,
  function accuraterip_sheet_lookup (line 5351) | def accuraterip_sheet_lookup(sheet, total_pcm_frames, sample_rate,
  function output_progress (line 5373) | def output_progress(u, current, total):
  class ExecProgressQueue (line 5385) | class ExecProgressQueue(object):
    method __init__ (line 5388) | def __init__(self, messenger):
    method execute (line 5398) | def execute(self, function,
    method run (line 5425) | def run(self, max_processes=1):
    method __run_serial__ (line 5439) | def __run_serial__(self):
    method __run_parallel__ (line 5485) | def __run_parallel__(self, max_processes=1):
  class __ProgressQueueJob__ (line 5631) | class __ProgressQueueJob__(object):
    method __init__ (line 5634) | def __init__(self,
    method job_fd (line 5666) | def job_fd(self):
    method progress (line 5671) | def progress(self):
    method spawn (line 5681) | def spawn(cls,
    method result (line 5757) | def result(self):
  class TemporaryFile (line 5768) | class TemporaryFile(object):
    method __init__ (line 5771) | def __init__(self, original_filename):
    method __del__ (line 5783) | def __del__(self):
    method write (line 5788) | def write(self, data):
    method flush (line 5793) | def flush(self):
    method tell (line 5798) | def tell(self):
    method seek (line 5803) | def seek(self, offset, whence=None):
    method close (line 5811) | def close(self):

FILE: audiotools/accuraterip.py
  class __Checksum__ (line 23) | class __Checksum__(object):
    method __init__ (line 26) | def __init__(self, total_pcm_frames,
    method update (line 53) | def update(self, framelist):
    method checksums_v1 (line 79) | def checksums_v1(self):
    method checksums_v2 (line 93) | def checksums_v2(self):
  function match_offset (line 111) | def match_offset(ar_matches, checksums, initial_offset):
  class DiscID (line 150) | class DiscID(object):
    method __init__ (line 151) | def __init__(self, track_numbers, track_offsets,
    method from_cddareader (line 171) | def from_cddareader(cls, cddareader):
    method from_tracks (line 184) | def from_tracks(cls, tracks):
    method from_sheet (line 211) | def from_sheet(cls, sheet, total_pcm_frames, sample_rate):
    method track_numbers (line 227) | def track_numbers(self):
    method id1 (line 230) | def id1(self):
    method id2 (line 233) | def id2(self):
    method freedb_disc_id (line 238) | def freedb_disc_id(self):
    method __str__ (line 242) | def __str__(self):
    method __str__ (line 245) | def __str__(self):
    method __unicode__ (line 248) | def __unicode__(self):
    method __repr__ (line 255) | def __repr__(self):
  function perform_lookup (line 265) | def perform_lookup(disc_id,

FILE: audiotools/aiff.py
  function parse_ieee_extended (line 24) | def parse_ieee_extended(bitstream):
  function build_ieee_extended (line 38) | def build_ieee_extended(bitstream, value):
  function pad_data (line 61) | def pad_data(pcm_frames, channels, bits_per_sample):
  function validate_header (line 68) | def validate_header(header):
  function validate_footer (line 156) | def validate_footer(footer, ssnd_bytes_written):
  class AIFF_Chunk (line 205) | class AIFF_Chunk(object):
    method __init__ (line 208) | def __init__(self, chunk_id, chunk_size, chunk_data):
    method __repr__ (line 219) | def __repr__(self):
    method size (line 222) | def size(self):
    method total_size (line 228) | def total_size(self):
    method data (line 237) | def data(self):
    method verify (line 244) | def verify(self):
    method write (line 249) | def write(self, f):
  class AIFF_File_Chunk (line 262) | class AIFF_File_Chunk(AIFF_Chunk):
    method __init__ (line 265) | def __init__(self, chunk_id, chunk_size, aiff_file, chunk_data_offset):
    method __del__ (line 278) | def __del__(self):
    method __repr__ (line 281) | def __repr__(self):
    method data (line 284) | def data(self):
    method verify (line 292) | def verify(self):
    method write (line 305) | def write(self, f):
  function parse_comm (line 324) | def parse_comm(comm):
  class AiffReader (line 347) | class AiffReader(object):
    method __init__ (line 350) | def __init__(self, aiff_filename):
    method __enter__ (line 431) | def __enter__(self):
    method __exit__ (line 434) | def __exit__(self, exc_type, exc_value, traceback):
    method read (line 437) | def read(self, pcm_frames):
    method read_closed (line 461) | def read_closed(self, pcm_frames):
    method seek (line 464) | def seek(self, pcm_frame_offset):
    method seek_closed (line 484) | def seek_closed(self, pcm_frame_offset):
    method close (line 487) | def close(self):
  function aiff_header (line 495) | def aiff_header(sample_rate,
  class InvalidAIFF (line 528) | class InvalidAIFF(InvalidFile):
  class AiffAudio (line 534) | class AiffAudio(AiffContainer):
    method __init__ (line 546) | def __init__(self, filename):
    method bits_per_sample (line 577) | def bits_per_sample(self):
    method channels (line 582) | def channels(self):
    method channel_mask (line 587) | def channel_mask(self):
    method lossless (line 592) | def lossless(self):
    method total_frames (line 597) | def total_frames(self):
    method sample_rate (line 602) | def sample_rate(self):
    method seekable (line 607) | def seekable(self):
    method chunks (line 612) | def chunks(self):
    method aiff_from_chunks (line 670) | def aiff_from_chunks(cls, aiff_file, chunk_iter):
    method supports_metadata (line 693) | def supports_metadata(cls):
    method get_metadata (line 698) | def get_metadata(self):
    method update_metadata (line 713) | def update_metadata(self, metadata):
    method set_metadata (line 751) | def set_metadata(self, metadata):
    method delete_metadata (line 788) | def delete_metadata(self):
    method supports_to_pcm (line 808) | def supports_to_pcm(cls):
    method to_pcm (line 814) | def to_pcm(self):
    method supports_from_pcm (line 829) | def supports_from_pcm(cls):
    method from_pcm (line 836) | def from_pcm(cls, filename, pcmreader,
    method has_foreign_aiff_chunks (line 906) | def has_foreign_aiff_chunks(self):
    method aiff_header_footer (line 911) | def aiff_header_footer(self):
    method from_aiff (line 975) | def from_aiff(cls, filename, header, pcmreader, footer, compression=No...
    method verify (line 1045) | def verify(self, progress=None):
    method clean (line 1098) | def clean(self, output_filename=None):

FILE: audiotools/ape.py
  function __number_pair__ (line 27) | def __number_pair__(current, total):
  function limited_transfer_data (line 45) | def limited_transfer_data(from_function, to_function, max_bytes):
  class ApeTagItem (line 59) | class ApeTagItem(object):
    method __init__ (line 64) | def __init__(self, item_type, read_only, key, data):
    method __eq__ (line 81) | def __eq__(self, item):
    method total_size (line 89) | def total_size(self):
    method copy (line 94) | def copy(self):
    method __repr__ (line 102) | def __repr__(self):
    method raw_info_pair (line 108) | def raw_info_pair(self):
    method __str__ (line 128) | def __str__(self):
    method __str__ (line 131) | def __str__(self):
    method __unicode__ (line 134) | def __unicode__(self):
    method number (line 137) | def number(self):
    method total (line 162) | def total(self):
    method parse (line 180) | def parse(cls, reader):
    method build (line 197) | def build(self, writer):
    method binary (line 209) | def binary(cls, key, data):
    method external (line 217) | def external(cls, key, data):
    method string (line 225) | def string(cls, key, data):
  class ApeTag (line 237) | class ApeTag(MetaData):
    method __init__ (line 266) | def __init__(self, tags, contains_header=True, contains_footer=True):
    method __repr__ (line 275) | def __repr__(self):
    method total_size (line 280) | def total_size(self):
    method __eq__ (line 292) | def __eq__(self, metadata):
    method keys (line 310) | def keys(self):
    method __contains__ (line 313) | def __contains__(self, key):
    method __getitem__ (line 320) | def __getitem__(self, key):
    method get (line 329) | def get(self, key, default):
    method __setitem__ (line 337) | def __setitem__(self, key, value):
    method index (line 347) | def index(self, key):
    method __delitem__ (line 356) | def __delitem__(self, key):
    method __getattr__ (line 365) | def __getattr__(self, attr):
    method __setattr__ (line 385) | def __setattr__(self, attr, value):
    method __delattr__ (line 427) | def __delattr__(self, attr):
    method converted (line 476) | def converted(cls, metadata):
    method raw_info (line 497) | def raw_info(self):
    method supports_images (line 516) | def supports_images(cls):
    method __parse_image__ (line 521) | def __parse_image__(self, key, type):
    method add_image (line 536) | def add_image(self, image):
    method delete_image (line 554) | def delete_image(self, image):
    method images (line 562) | def images(self):
    method read (line 579) | def read(cls, apefile):
    method build (line 613) | def build(self, writer):
    method clean (line 645) | def clean(self):
    method intersection (line 734) | def intersection(self, metadata):
  class ApeTaggedAudio (line 756) | class ApeTaggedAudio(object):
    method supports_metadata (line 763) | def supports_metadata(cls):
    method get_metadata (line 768) | def get_metadata(self):
    method update_metadata (line 776) | def update_metadata(self, metadata):
    method set_metadata (line 906) | def set_metadata(self, metadata):
    method delete_metadata (line 964) | def delete_metadata(self):
  class ApeGainedAudio (line 1021) | class ApeGainedAudio(object):
    method supports_replay_gain (line 1023) | def supports_replay_gain(cls):
    method get_replay_gain (line 1028) | def get_replay_gain(self):
    method set_replay_gain (line 1057) | def set_replay_gain(self, replaygain):
    method delete_replay_gain (line 1084) | def delete_replay_gain(self):

FILE: audiotools/au.py
  class InvalidAU (line 23) | class InvalidAU(InvalidFile):
  class AuReader (line 27) | class AuReader(object):
    method __init__ (line 28) | def __init__(self, au_filename):
    method __enter__ (line 56) | def __enter__(self):
    method __exit__ (line 59) | def __exit__(self, exc_type, exc_value, traceback):
    method read (line 62) | def read(self, pcm_frames):
    method read_closed (line 84) | def read_closed(self, pcm_frames):
    method seek (line 87) | def seek(self, pcm_frame_offset):
    method seek_closed (line 105) | def seek_closed(self, pcm_frame_offset):
    method close (line 108) | def close(self):
  function au_header (line 114) | def au_header(sample_rate,
  class AuAudio (line 142) | class AuAudio(AudioFile):
    method __init__ (line 149) | def __init__(self, filename):
    method lossless (line 174) | def lossless(self):
    method bits_per_sample (line 179) | def bits_per_sample(self):
    method channels (line 184) | def channels(self):
    method channel_mask (line 189) | def channel_mask(self):
    method sample_rate (line 199) | def sample_rate(self):
    method total_frames (line 204) | def total_frames(self):
    method seekable (line 211) | def seekable(self):
    method supports_to_pcm (line 217) | def supports_to_pcm(cls):
    method to_pcm (line 223) | def to_pcm(self):
    method pcm_split (line 228) | def pcm_split(self):
    method supports_from_pcm (line 243) | def supports_from_pcm(cls):
    method from_pcm (line 250) | def from_pcm(cls, filename, pcmreader,
    method track_name (line 316) | def track_name(cls, file_path, track_metadata=None, format=None,

FILE: audiotools/cdtoc.py
  class CDTOC (line 21) | class CDTOC(Sheet):
    method __init__ (line 24) | def __init__(self, cdtoc_tracks, lead_out):
    method __repr__ (line 31) | def __repr__(self):
    method __str__ (line 36) | def __str__(self):
    method __str__ (line 39) | def __str__(self):
    method __unicode__ (line 42) | def __unicode__(self):
    method from_unicode (line 49) | def from_unicode(cls, u):
    method converted (line 91) | def converted(cls, sheet, seconds_length):
    method __len__ (line 114) | def __len__(self):
    method __getitem__ (line 117) | def __getitem__(self, index):
    method track_length (line 120) | def track_length(self, track_number, total_length=None):
    method get_metadata (line 141) | def get_metadata(self):
  class CDTOC_DataAudio (line 145) | class CDTOC_DataAudio(CDTOC):
    method __init__ (line 146) | def __init__(self, cdtoc_tracks, lead_out):
    method __unicode__ (line 156) | def __unicode__(self):
    method __repr__ (line 162) | def __repr__(self):
  class CDTOC_Track (line 167) | class CDTOC_Track(SheetTrack):
    method __init__ (line 168) | def __init__(self, number, address, is_audio=True):
    method converted (line 182) | def converted(cls, sheet_track):
    method __len__ (line 190) | def __len__(self):
    method __getitem__ (line 193) | def __getitem__(self, i):
    method __str__ (line 197) | def __str__(self):
    method __str__ (line 200) | def __str__(self):
    method __unicode__ (line 203) | def __unicode__(self):
    method __repr__ (line 206) | def __repr__(self):
    method number (line 210) | def number(self):
    method get_metadata (line 215) | def get_metadata(self):
    method filename (line 220) | def filename(self):
    method is_audio (line 225) | def is_audio(self):
    method pre_emphasis (line 230) | def pre_emphasis(self):
    method copy_permitted (line 235) | def copy_permitted(self):
  class CDTOC_Index (line 241) | class CDTOC_Index(SheetIndex):
    method __init__ (line 242) | def __init__(self, number, address):
    method __str__ (line 247) | def __str__(self):
    method __str__ (line 250) | def __str__(self):
    method __unicode__ (line 253) | def __unicode__(self):
    method __repr__ (line 256) | def __repr__(self):
    method number (line 260) | def number(self):
    method offset (line 263) | def offset(self):

FILE: audiotools/coverartarchive.py
  function perform_lookup (line 19) | def perform_lookup(mbid,

FILE: audiotools/cue/__init__.py
  class Cuesheet (line 23) | class Cuesheet(Sheet):
    method __init__ (line 24) | def __init__(self, files,
    method __repr__ (line 46) | def __repr__(self):
    method converted (line 58) | def converted(cls, sheet, filename=None):
    method __len__ (line 95) | def __len__(self):
    method __getitem__ (line 98) | def __getitem__(self, index):
    method get_metadata (line 108) | def get_metadata(self):
    method build (line 130) | def build(self):
  class File (line 159) | class File(object):
    method __init__ (line 160) | def __init__(self, filename, file_type, tracks):
    method __len__ (line 173) | def __len__(self):
    method __getitem__ (line 176) | def __getitem__(self, index):
    method __repr__ (line 179) | def __repr__(self):
    method filename (line 185) | def filename(self):
    method build (line 188) | def build(self):
  class Track (line 197) | class Track(SheetTrack):
    method __init__ (line 198) | def __init__(self, number,
    method __repr__ (line 235) | def __repr__(self):
    method converted (line 251) | def converted(cls, sheettrack):
    method __len__ (line 276) | def __len__(self):
    method __getitem__ (line 279) | def __getitem__(self, index):
    method number (line 282) | def number(self):
    method get_metadata (line 287) | def get_metadata(self):
    method filename (line 307) | def filename(self):
    method is_audio (line 315) | def is_audio(self):
    method pre_emphasis (line 320) | def pre_emphasis(self):
    method copy_permitted (line 328) | def copy_permitted(self):
    method build (line 336) | def build(self):
  class Index (line 378) | class Index(SheetIndex):
    method __init__ (line 379) | def __init__(self, number, timestamp):
    method __repr__ (line 383) | def __repr__(self):
    method converted (line 388) | def converted(cls, index):
    method build (line 394) | def build(self):
    method number (line 400) | def number(self):
    method offset (line 405) | def offset(self):
  function format_string (line 414) | def format_string(s):
  function format_timestamp (line 418) | def format_timestamp(t):
  function read_cuesheet (line 424) | def read_cuesheet(filename):
  function read_cuesheet_string (line 439) | def read_cuesheet_string(cuesheet):
  function write_cuesheet (line 467) | def write_cuesheet(sheet, filename, file):

FILE: audiotools/cue/tokrules.py
  function t_REM (line 52) | def t_REM(t):
  function t_ISRC (line 57) | def t_ISRC(t):
  function t_TIMESTAMP (line 62) | def t_TIMESTAMP(t):
  function t_MP3 (line 69) | def t_MP3(t):
  function t_MODE (line 74) | def t_MODE(t):
  function t_CDI (line 79) | def t_CDI(t):
  function t_NUMBER (line 84) | def t_NUMBER(t):
  function t_ID (line 90) | def t_ID(t):
  function t_STRING (line 99) | def t_STRING(t):
  function t_newline (line 108) | def t_newline(t):
  function t_error (line 113) | def t_error(t):

FILE: audiotools/cue/yaccrules.py
  function p_cuesheet (line 21) | def p_cuesheet(t):
  function p_cuesheet_items (line 37) | def p_cuesheet_items(t):
  function p_cuesheet_item (line 46) | def p_cuesheet_item(t):
  function p_catalog_string (line 55) | def p_catalog_string(t):
  function p_catalog_number (line 61) | def p_catalog_number(t):
  function p_title (line 67) | def p_title(t):
  function p_performer (line 72) | def p_performer(t):
  function p_songwriter (line 77) | def p_songwriter(t):
  function p_cdtextfile (line 82) | def p_cdtextfile(t):
  function p_files (line 87) | def p_files(t):
  function p_file (line 96) | def p_file(t):
  function p_filetype (line 108) | def p_filetype(t):
  function p_tracks (line 118) | def p_tracks(t):
  function p_track (line 127) | def p_track(t):
  function p_tracktype (line 149) | def p_tracktype(t):
  function p_indexes (line 158) | def p_indexes(t):
  function p_trackitem (line 167) | def p_trackitem(t):
  function p_index (line 179) | def p_index(t):
  function p_isrc (line 187) | def p_isrc(t):
  function p_pregap (line 193) | def p_pregap(t):
  function p_postgap (line 198) | def p_postgap(t):
  function p_flags (line 203) | def p_flags(t):
  function p_flaglist (line 208) | def p_flaglist(t):
  function p_flag (line 217) | def p_flag(t):
  function p_error (line 224) | def p_error(t):

FILE: audiotools/flac.py
  class InvalidFLAC (line 29) | class InvalidFLAC(InvalidFile):
  class FlacMetaDataBlockTooLarge (line 33) | class FlacMetaDataBlockTooLarge(Exception):
  class FlacMetaData (line 39) | class FlacMetaData(MetaData):
    method __init__ (line 42) | def __init__(self, blocks):
    method has_block (line 45) | def has_block(self, block_id):
    method add_block (line 50) | def add_block(self, block):
    method get_block (line 74) | def get_block(self, block_id):
    method get_blocks (line 85) | def get_blocks(self, block_id):
    method replace_blocks (line 90) | def replace_blocks(self, block_id, blocks):
    method __setattr__ (line 117) | def __setattr__(self, attr, value):
    method __getattr__ (line 134) | def __getattr__(self, attr):
    method __delattr__ (line 145) | def __delattr__(self, attr):
    method converted (line 156) | def converted(cls, metadata):
    method add_image (line 169) | def add_image(self, image):
    method delete_image (line 174) | def delete_image(self, image):
    method images (line 181) | def images(self):
    method supports_images (line 187) | def supports_images(cls):
    method clean (line 192) | def clean(self):
    method __repr__ (line 262) | def __repr__(self):
    method intersection (line 265) | def intersection(self, metadata):
    method parse (line 295) | def parse(cls, reader):
    method raw_info (line 336) | def raw_info(self):
    method blocks (line 344) | def blocks(self):
    method build (line 350) | def build(self, writer):
    method size (line 366) | def size(self):
  class Flac_STREAMINFO (line 374) | class Flac_STREAMINFO(object):
    method __init__ (line 377) | def __init__(self, minimum_block_size, maximum_block_size,
    method copy (line 394) | def copy(self):
    method __eq__ (line 407) | def __eq__(self, block):
    method __repr__ (line 423) | def __repr__(self):
    method raw_info (line 436) | def raw_info(self):
    method parse (line 456) | def parse(cls, reader):
    method build (line 464) | def build(self, writer):
    method size (line 478) | def size(self):
  class Flac_PADDING (line 485) | class Flac_PADDING(object):
    method __init__ (line 488) | def __init__(self, length):
    method copy (line 491) | def copy(self):
    method __eq__ (line 496) | def __eq__(self, block):
    method __repr__ (line 502) | def __repr__(self):
    method raw_info (line 505) | def raw_info(self):
    method parse (line 516) | def parse(cls, reader, block_length):
    method build (line 522) | def build(self, writer):
    method size (line 527) | def size(self):
  class Flac_APPLICATION (line 534) | class Flac_APPLICATION(object):
    method __init__ (line 537) | def __init__(self, application_id, data):
    method __eq__ (line 541) | def __eq__(self, block):
    method copy (line 549) | def copy(self):
    method __repr__ (line 555) | def __repr__(self):
    method raw_info (line 559) | def raw_info(self):
    method parse (line 571) | def parse(cls, reader, block_length):
    method build (line 577) | def build(self, writer):
    method size (line 583) | def size(self):
  class Flac_SEEKTABLE (line 590) | class Flac_SEEKTABLE(object):
    method __init__ (line 593) | def __init__(self, seekpoints):
    method __eq__ (line 598) | def __eq__(self, block):
    method copy (line 604) | def copy(self):
    method __repr__ (line 609) | def __repr__(self):
    method raw_info (line 612) | def raw_info(self):
    method parse (line 627) | def parse(cls, reader, total_seekpoints):
    method build (line 633) | def build(self, writer):
    method size (line 639) | def size(self):
    method clean (line 647) | def clean(self):
  class Flac_VORBISCOMMENT (line 670) | class Flac_VORBISCOMMENT(VorbisComment):
    method copy (line 673) | def copy(self):
    method __repr__ (line 679) | def __repr__(self):
    method raw_info (line 683) | def raw_info(self):
    method converted (line 713) | def converted(cls, metadata):
    method parse (line 726) | def parse(cls, reader):
    method build (line 741) | def build(self, writer):
    method size (line 757) | def size(self):
  class Flac_CUESHEET (line 767) | class Flac_CUESHEET(Sheet):
    method __init__ (line 770) | def __init__(self, catalog_number, lead_in_samples, is_cdda, tracks):
    method copy (line 786) | def copy(self):
    method __eq__ (line 794) | def __eq__(self, cuesheet):
    method __repr__ (line 805) | def __repr__(self):
    method raw_info (line 813) | def raw_info(self):
    method parse (line 828) | def parse(cls, reader):
    method build (line 841) | def build(self, writer):
    method size (line 852) | def size(self):
    method __len__ (line 859) | def __len__(self):
    method __getitem__ (line 863) | def __getitem__(self, index):
    method track_length (line 867) | def track_length(self, track_number, total_length=None):
    method get_metadata (line 893) | def get_metadata(self):
    method set_track (line 906) | def set_track(self, audiofile):
    method converted (line 917) | def converted(cls, sheet, total_pcm_frames, sample_rate, is_cdda=True):
  class Flac_CUESHEET_track (line 950) | class Flac_CUESHEET_track(SheetTrack):
    method __init__ (line 951) | def __init__(self, offset, number, ISRC, track_type, pre_emphasis,
    method converted (line 977) | def converted(cls, sheet_track, sample_rate):
    method copy (line 1009) | def copy(self):
    method __repr__ (line 1020) | def __repr__(self):
    method raw_info (line 1030) | def raw_info(self, indent):
    method __eq__ (line 1048) | def __eq__(self, track):
    method parse (line 1060) | def parse(cls, reader):
    method build (line 1073) | def build(self, writer):
    method size (line 1086) | def size(self):
    method __len__ (line 1090) | def __len__(self):
    method __getitem__ (line 1093) | def __getitem__(self, index):
    method number (line 1096) | def number(self):
    method get_metadata (line 1101) | def get_metadata(self):
    method filename (line 1112) | def filename(self):
    method is_audio (line 1121) | def is_audio(self):
    method pre_emphasis (line 1126) | def pre_emphasis(self):
    method copy_permitted (line 1131) | def copy_permitted(self):
    method set_track (line 1136) | def set_track(self, audiofile):
  class Flac_CUESHEET_index (line 1146) | class Flac_CUESHEET_index(SheetIndex):
    method __init__ (line 1147) | def __init__(self, track_offset, offset, number, sample_rate=44100):
    method converted (line 1161) | def converted(cls, sheet_index, track_offset, sample_rate):
    method copy (line 1171) | def copy(self):
    method __repr__ (line 1179) | def __repr__(self):
    method __eq__ (line 1184) | def __eq__(self, index):
    method parse (line 1192) | def parse(cls, reader, track_offset):
    method build (line 1201) | def build(self, writer):
    method size (line 1206) | def size(self):
    method raw_info (line 1209) | def raw_info(self, indent):
    method number (line 1215) | def number(self):
    method offset (line 1218) | def offset(self):
    method set_track (line 1224) | def set_track(self, audiofile):
  class Flac_PICTURE (line 1230) | class Flac_PICTURE(Image):
    method __init__ (line 1233) | def __init__(self, picture_type, mime_type, description,
    method copy (line 1267) | def copy(self):
    method __getattr__ (line 1279) | def __getattr__(self, attr):
    method __setattr__ (line 1305) | def __setattr__(self, attr, value):
    method __repr__ (line 1331) | def __repr__(self):
    method raw_info (line 1342) | def raw_info(self):
    method parse (line 1360) | def parse(cls, reader):
    method build (line 1381) | def build(self, writer):
    method size (line 1398) | def size(self):
    method converted (line 1412) | def converted(cls, image):
    method type_string (line 1425) | def type_string(self):
    method clean (line 1454) | def clean(self):
  class FlacAudio (line 1480) | class FlacAudio(WaveContainer, AiffContainer):
    method __init__ (line 1496) | def __init__(self, filename):
    method channel_mask (line 1547) | def channel_mask(self):
    method lossless (line 1606) | def lossless(self):
    method supports_metadata (line 1612) | def supports_metadata(cls):
    method get_metadata (line 1617) | def get_metadata(self):
    method update_metadata (line 1636) | def update_metadata(self, metadata):
    method set_metadata (line 1734) | def set_metadata(self, metadata):
    method delete_metadata (line 1834) | def delete_metadata(self):
    method supports_cuesheet (line 1843) | def supports_cuesheet(cls):
    method set_cuesheet (line 1846) | def set_cuesheet(self, cuesheet):
    method get_cuesheet (line 1877) | def get_cuesheet(self):
    method delete_cuesheet (line 1918) | def delete_cuesheet(self):
    method to_pcm (line 1936) | def to_pcm(self):
    method supports_to_pcm (line 1967) | def supports_to_pcm(cls):
    method from_pcm (line 1975) | def from_pcm(cls, filename, pcmreader,
    method supports_from_pcm (line 2091) | def supports_from_pcm(cls):
    method seekable (line 2098) | def seekable(self):
    method seektable (line 2103) | def seektable(self, offsets=None, seekpoint_interval=None):
    method has_foreign_wave_chunks (line 2138) | def has_foreign_wave_chunks(self):
    method wave_header_footer (line 2153) | def wave_header_footer(self):
    method from_wave (line 2195) | def from_wave(cls, filename, header, pcmreader, footer, compression=No...
    method has_foreign_aiff_chunks (line 2372) | def has_foreign_aiff_chunks(self):
    method aiff_header_footer (line 2382) | def aiff_header_footer(self):
    method from_aiff (line 2424) | def from_aiff(cls, filename, header, pcmreader, footer, compression=No...
    method convert (line 2611) | def convert(self, target_path, target_class, compression=None,
    method bits_per_sample (line 2651) | def bits_per_sample(self):
    method channels (line 2656) | def channels(self):
    method total_frames (line 2661) | def total_frames(self):
    method sample_rate (line 2666) | def sample_rate(self):
    method supports_replay_gain (line 2672) | def supports_replay_gain(cls):
    method get_replay_gain (line 2677) | def get_replay_gain(self):
    method set_replay_gain (line 2705) | def set_replay_gain(self, replaygain):
    method delete_replay_gain (line 2736) | def delete_replay_gain(self):
    method clean (line 2758) | def clean(self, output_filename=None):
  class OggFlacMetaData (line 2903) | class OggFlacMetaData(FlacMetaData):
    method converted (line 2905) | def converted(cls, metadata):
    method __repr__ (line 2917) | def __repr__(self):
    method parse (line 2921) | def parse(cls, packetreader):
    method build (line 2992) | def build(self, pagewriter, serial_number):
  function sizes_to_offsets (line 3056) | def sizes_to_offsets(sizes):

FILE: audiotools/freedb.py
  function digit_sum (line 22) | def digit_sum(i):
  class DiscID (line 28) | class DiscID(object):
    method __init__ (line 29) | def __init__(self, offsets, total_length, track_count, playable_length):
    method from_cddareader (line 48) | def from_cddareader(cls, cddareader):
    method from_tracks (line 69) | def from_tracks(cls, tracks):
    method from_sheet (line 101) | def from_sheet(cls, sheet, total_pcm_frames, sample_rate):
    method __repr__ (line 115) | def __repr__(self):
    method __str__ (line 124) | def __str__(self):
    method __str__ (line 127) | def __str__(self):
    method __unicode__ (line 130) | def __unicode__(self):
    method __int__ (line 133) | def __int__(self):
  function perform_lookup (line 140) | def perform_lookup(disc_id, freedb_server, freedb_port):
  function freedb_command (line 232) | def freedb_command(freedb_server, freedb_port, cmd, *args):
  function xmcd_metadata (line 288) | def xmcd_metadata(freedb_file):

FILE: audiotools/id3.py
  function is_latin_1 (line 25) | def is_latin_1(unicode_string):
  class UCS2Codec (line 38) | class UCS2Codec(codecs.Codec):
    method fix_char (line 45) | def fix_char(cls, c):
    method encode (line 53) | def encode(self, input, errors='strict'):
    method decode (line 59) | def decode(self, input, errors='strict'):
  class UCS2CodecStreamWriter (line 66) | class UCS2CodecStreamWriter(UCS2Codec, codecs.StreamWriter):
  class UCS2CodecStreamReader (line 70) | class UCS2CodecStreamReader(UCS2Codec, codecs.StreamReader):
  function __reg_ucs2__ (line 74) | def __reg_ucs2__(name):
  function decode_syncsafe32 (line 86) | def decode_syncsafe32(i):
  function encode_syncsafe32 (line 110) | def encode_syncsafe32(i):
  class C_string (line 131) | class C_string(object):
    method __init__ (line 143) | def __init__(self, encoding, unicode_string):
    method __repr__ (line 154) | def __repr__(self):
    method __str__ (line 159) | def __str__(self):
    method __str__ (line 162) | def __str__(self):
    method __unicode__ (line 165) | def __unicode__(self):
    method __getitem__ (line 168) | def __getitem__(self, char):
    method __len__ (line 171) | def __len__(self):
    method __eq__ (line 174) | def __eq__(self, s):
    method __ne__ (line 177) | def __ne__(self, s):
    method __lt__ (line 180) | def __lt__(self, s):
    method __le__ (line 183) | def __le__(self, s):
    method __gt__ (line 186) | def __gt__(self, s):
    method __ge__ (line 189) | def __ge__(self, s):
    method parse (line 193) | def parse(cls, encoding, reader):
    method build (line 214) | def build(self, writer):
    method size (line 222) | def size(self):
  function __attrib_equals__ (line 229) | def __attrib_equals__(attributes, o1, o2):
  function __padded__ (line 239) | def __padded__(value):
  function __number_pair__ (line 253) | def __number_pair__(current, total):
  function read_id3v2_comment (line 266) | def read_id3v2_comment(filename):
  function skip_id3v2_comment (line 293) | def skip_id3v2_comment(file):
  function total_id3v2_comments (line 342) | def total_id3v2_comments(file):
  class ID3v22_Frame (line 386) | class ID3v22_Frame(object):
    method __init__ (line 387) | def __init__(self, frame_id, data):
    method copy (line 391) | def copy(self):
    method __repr__ (line 394) | def __repr__(self):
    method raw_info (line 397) | def raw_info(self):
    method __eq__ (line 409) | def __eq__(self, frame):
    method parse (line 413) | def parse(cls, frame_id, frame_size, reader):
    method build (line 419) | def build(self, writer):
    method size (line 425) | def size(self):
    method converted (line 432) | def converted(cls, frame_id, o):
    method clean (line 437) | def clean(self):
  class ID3v22_T__Frame (line 444) | class ID3v22_T__Frame(object):
    method __init__ (line 448) | def __init__(self, frame_id, encoding, data):
    method copy (line 461) | def copy(self):
    method __repr__ (line 464) | def __repr__(self):
    method raw_info (line 468) | def raw_info(self):
    method __eq__ (line 476) | def __eq__(self, frame):
    method __str__ (line 480) | def __str__(self):
    method __str__ (line 483) | def __str__(self):
    method __unicode__ (line 486) | def __unicode__(self):
    method number (line 491) | def number(self):
    method total (line 520) | def total(self):
    method true (line 541) | def true(self):
    method parse (line 551) | def parse(cls, frame_id, frame_size, reader):
    method build (line 558) | def build(self, writer):
    method size (line 565) | def size(self):
    method converted (line 572) | def converted(cls, frame_id, unicode_string):
    method clean (line 580) | def clean(self):
  class ID3v22_TXX_Frame (line 629) | class ID3v22_TXX_Frame(object):
    method __init__ (line 630) | def __init__(self, encoding, description, data):
    method copy (line 637) | def copy(self):
    method __repr__ (line 642) | def __repr__(self):
    method raw_info (line 646) | def raw_info(self):
    method __eq__ (line 655) | def __eq__(self, frame):
    method __str__ (line 660) | def __str__(self):
    method __str__ (line 663) | def __str__(self):
    method __unicode__ (line 666) | def __unicode__(self):
    method parse (line 672) | def parse(cls, frame_id, frame_size, reader):
    method build (line 683) | def build(self, writer):
    method size (line 691) | def size(self):
    method clean (line 697) | def clean(self):
  class ID3v22_W__Frame (line 730) | class ID3v22_W__Frame(object):
    method __init__ (line 731) | def __init__(self, frame_id, data):
    method copy (line 735) | def copy(self):
    method __repr__ (line 738) | def __repr__(self):
    method raw_info (line 741) | def raw_info(self):
    method __eq__ (line 747) | def __eq__(self, frame):
    method parse (line 751) | def parse(cls, frame_id, frame_size, reader):
    method build (line 754) | def build(self, writer):
    method size (line 760) | def size(self):
    method clean (line 766) | def clean(self):
  class ID3v22_WXX_Frame (line 774) | class ID3v22_WXX_Frame(object):
    method __init__ (line 775) | def __init__(self, encoding, description, data):
    method copy (line 782) | def copy(self):
    method __repr__ (line 787) | def __repr__(self):
    method raw_info (line 791) | def raw_info(self):
    method __eq__ (line 800) | def __eq__(self, frame):
    method parse (line 804) | def parse(cls, frame_id, frame_size, reader):
    method build (line 815) | def build(self, writer):
    method size (line 823) | def size(self):
    method clean (line 829) | def clean(self):
  class ID3v22_COM_Frame (line 839) | class ID3v22_COM_Frame(object):
    method __init__ (line 840) | def __init__(self, encoding, language, short_description, data):
    method copy (line 854) | def copy(self):
    method __repr__ (line 860) | def __repr__(self):
    method raw_info (line 864) | def raw_info(self):
    method __eq__ (line 873) | def __eq__(self, frame):
    method __ne__ (line 879) | def __ne__(self, frame):
    method __str__ (line 883) | def __str__(self):
    method __str__ (line 886) | def __str__(self):
    method __unicode__ (line 889) | def __unicode__(self):
    method parse (line 894) | def parse(cls, frame_id, frame_size, reader):
    method build (line 905) | def build(self, writer):
    method size (line 913) | def size(self):
    method converted (line 920) | def converted(cls, frame_id, unicode_string):
    method clean (line 928) | def clean(self):
  class ID3v22_PIC_Frame (line 968) | class ID3v22_PIC_Frame(Image):
    method __init__ (line 969) | def __init__(self, image_format, picture_type, description, data):
    method copy (line 1000) | def copy(self):
    method __repr__ (line 1006) | def __repr__(self):
    method raw_info (line 1010) | def raw_info(self):
    method type_string (line 1021) | def type_string(self):
    method __getattr__ (line 1044) | def __getattr__(self, attr):
    method __setattr__ (line 1062) | def __setattr__(self, attr, value):
    method parse (line 1084) | def parse(cls, frame_id, frame_size, reader):
    method build (line 1094) | def build(self, writer):
    method size (line 1105) | def size(self):
    method converted (line 1112) | def converted(cls, frame_id, image):
    method clean (line 1133) | def clean(self):
  class ID3v22Comment (line 1150) | class ID3v22Comment(MetaData):
    method __init__ (line 1181) | def __init__(self, frames, total_size=None):
    method copy (line 1185) | def copy(self):
    method __repr__ (line 1188) | def __repr__(self):
    method __iter__ (line 1192) | def __iter__(self):
    method raw_info (line 1195) | def raw_info(self):
    method parse (line 1204) | def parse(cls, reader):
    method build (line 1259) | def build(self, writer):
    method size (line 1282) | def size(self):
    method __len__ (line 1289) | def __len__(self):
    method __getitem__ (line 1292) | def __getitem__(self, frame_id):
    method __setitem__ (line 1299) | def __setitem__(self, frame_id, frames):
    method __delitem__ (line 1321) | def __delitem__(self, frame_id):
    method keys (line 1328) | def keys(self):
    method values (line 1331) | def values(self):
    method items (line 1334) | def items(self):
    method __getattr__ (line 1337) | def __getattr__(self, attr):
    method __setattr__ (line 1356) | def __setattr__(self, attr, value):
    method __delattr__ (line 1421) | def __delattr__(self, attr):
    method images (line 1479) | def images(self):
    method add_image (line 1482) | def add_image(self, image):
    method delete_image (line 1486) | def delete_image(self, image):
    method converted (line 1494) | def converted(cls, metadata):
    method clean (line 1537) | def clean(self):
    method intersection (line 1551) | def intersection(self, metadata):
  class ID3v23_Frame (line 1576) | class ID3v23_Frame(ID3v22_Frame):
    method __repr__ (line 1577) | def __repr__(self):
  class ID3v23_T___Frame (line 1581) | class ID3v23_T___Frame(ID3v22_T__Frame):
    method __repr__ (line 1585) | def __repr__(self):
  class ID3v23_TXXX_Frame (line 1590) | class ID3v23_TXXX_Frame(ID3v22_TXX_Frame):
    method __init__ (line 1591) | def __init__(self, encoding, description, data):
    method __repr__ (line 1598) | def __repr__(self):
  class ID3v23_W___Frame (line 1603) | class ID3v23_W___Frame(ID3v22_W__Frame):
    method __repr__ (line 1604) | def __repr__(self):
  class ID3v23_WXXX_Frame (line 1608) | class ID3v23_WXXX_Frame(ID3v22_WXX_Frame):
    method __init__ (line 1609) | def __init__(self, encoding, description, data):
    method __repr__ (line 1616) | def __repr__(self):
  class ID3v23_APIC_Frame (line 1621) | class ID3v23_APIC_Frame(ID3v22_PIC_Frame):
    method __init__ (line 1622) | def __init__(self, mime_type, picture_type, description, data):
    method copy (line 1652) | def copy(self):
    method __repr__ (line 1658) | def __repr__(self):
    method raw_info (line 1662) | def raw_info(self):
    method __getattr__ (line 1673) | def __getattr__(self, attr):
    method __setattr__ (line 1693) | def __setattr__(self, attr, value):
    method parse (line 1719) | def parse(cls, frame_id, frame_size, reader):
    method build (line 1734) | def build(self, writer):
    method size (line 1745) | def size(self):
    method converted (line 1756) | def converted(cls, frame_id, image):
    method clean (line 1771) | def clean(self):
  class ID3v23_COMM_Frame (line 1792) | class ID3v23_COMM_Frame(ID3v22_COM_Frame):
    method __init__ (line 1793) | def __init__(self, encoding, language, short_description, data):
    method __repr__ (line 1807) | def __repr__(self):
    method raw_info (line 1811) | def raw_info(self):
  class ID3v23Comment (line 1821) | class ID3v23Comment(ID3v22Comment):
    method __repr__ (line 1853) | def __repr__(self):
    method parse (line 1857) | def parse(cls, reader):
    method build (line 1912) | def build(self, writer):
    method size (line 1935) | def size(self):
  class ID3v24_Frame (line 1948) | class ID3v24_Frame(ID3v23_Frame):
    method __repr__ (line 1949) | def __repr__(self):
  class ID3v24_T___Frame (line 1953) | class ID3v24_T___Frame(ID3v23_T___Frame):
    method __init__ (line 1954) | def __init__(self, frame_id, encoding, data):
    method __repr__ (line 1962) | def __repr__(self):
    method __unicode__ (line 1966) | def __unicode__(self):
    method raw_info (line 1973) | def raw_info(self):
    method converted (line 1984) | def converted(cls, frame_id, unicode_string):
  class ID3v24_TXXX_Frame (line 1993) | class ID3v24_TXXX_Frame(ID3v23_TXXX_Frame):
    method __repr__ (line 1994) | def __repr__(self):
    method raw_info (line 1998) | def raw_info(self):
    method __unicode__ (line 2010) | def __unicode__(self):
    method parse (line 2018) | def parse(cls, frame_id, frame_size, reader):
  class ID3v24_APIC_Frame (line 2033) | class ID3v24_APIC_Frame(ID3v23_APIC_Frame):
    method __repr__ (line 2034) | def __repr__(self):
    method __setattr__ (line 2040) | def __setattr__(self, attr, value):
    method parse (line 2066) | def parse(cls, frame_id, frame_size, reader):
    method build (line 2083) | def build(self, writer):
    method converted (line 2097) | def converted(cls, frame_id, image):
    method clean (line 2112) | def clean(self):
  class ID3v24_W___Frame (line 2133) | class ID3v24_W___Frame(ID3v23_W___Frame):
    method __repr__ (line 2134) | def __repr__(self):
  class ID3v24_WXXX_Frame (line 2138) | class ID3v24_WXXX_Frame(ID3v23_WXXX_Frame):
    method __repr__ (line 2139) | def __repr__(self):
    method raw_info (line 2143) | def raw_info(self):
    method parse (line 2156) | def parse(cls, frame_id, frame_size, reader):
  class ID3v24_COMM_Frame (line 2171) | class ID3v24_COMM_Frame(ID3v23_COMM_Frame):
    method __repr__ (line 2172) | def __repr__(self):
    method __unicode__ (line 2176) | def __unicode__(self):
    method raw_info (line 2182) | def raw_info(self):
    method parse (line 2198) | def parse(cls, frame_id, frame_size, reader):
    method converted (line 2213) | def converted(cls, frame_id, unicode_string):
    method clean (line 2221) | def clean(self):
  class ID3v24Comment (line 2264) | class ID3v24Comment(ID3v23Comment):
    method __repr__ (line 2277) | def __repr__(self):
    method parse (line 2281) | def parse(cls, reader):
    method build (line 2338) | def build(self, writer):
    method size (line 2363) | def size(self):
  class ID3CommentPair (line 2374) | class ID3CommentPair(MetaData):
    method __init__ (line 2379) | def __init__(self, id3v2_comment, id3v1_comment):
    method __repr__ (line 2394) | def __repr__(self):
    method __getattr__ (line 2397) | def __getattr__(self, attr):
    method __setattr__ (line 2414) | def __setattr__(self, attr, value):
    method __delattr__ (line 2424) | def __delattr__(self, attr):
    method converted (line 2435) | def converted(cls, metadata,
    method raw_info (line 2454) | def raw_info(self):
    method images (line 2475) | def images(self):
    method add_image (line 2483) | def add_image(self, image):
    method delete_image (line 2489) | def delete_image(self, image):
    method supports_images (line 2496) | def supports_images(cls):
    method clean (line 2501) | def clean(self):
    method intersection (line 2517) | def intersection(self, metadata):

FILE: audiotools/id3v1.py
  class ID3v1Comment (line 21) | class ID3v1Comment(MetaData):
    method __init__ (line 37) | def __init__(self, track_name=u"",
    method __repr__ (line 82) | def __repr__(self):
    method __getattr__ (line 92) | def __getattr__(self, attr):
    method __setattr__ (line 110) | def __setattr__(self, attr, value):
    method __delattr__ (line 131) | def __delattr__(self, attr):
    method raw_info (line 144) | def raw_info(self):
    method parse (line 163) | def parse(cls, mp3_file):
    method build (line 195) | def build(self, mp3_file):
    method supports_images (line 220) | def supports_images(cls):
    method converted (line 226) | def converted(cls, metadata):
    method images (line 252) | def images(self):
    method clean (line 257) | def clean(self):
    method intersection (line 294) | def intersection(self, metadata):

FILE: audiotools/image.py
  function image_metrics (line 22) | def image_metrics(file_data):
  class ImageMetrics (line 48) | class ImageMetrics:
    method __init__ (line 51) | def __init__(self, width, height, bits_per_pixel, color_count, mime_ty...
    method __repr__ (line 72) | def __repr__(self):
    method parse (line 81) | def parse(cls, file_data):
  class InvalidJPEG (line 85) | class InvalidJPEG(InvalidImage):
  class __JPEG__ (line 91) | class __JPEG__(ImageMetrics):
    method __init__ (line 92) | def __init__(self, width, height, bits_per_pixel):
    method parse (line 97) | def parse(cls, file_data):
  class InvalidPNG (line 138) | class InvalidPNG(InvalidImage):
  class __PNG__ (line 144) | class __PNG__(ImageMetrics):
    method __init__ (line 145) | def __init__(self, width, height, bits_per_pixel, color_count):
    method parse (line 150) | def parse(cls, file_data):
  class InvalidBMP (line 225) | class InvalidBMP(InvalidImage):
  class __BMP__ (line 231) | class __BMP__(ImageMetrics):
    method __init__ (line 232) | def __init__(self, width, height, bits_per_pixel, color_count):
    method parse (line 237) | def parse(cls, file_data):
  class InvalidGIF (line 274) | class InvalidGIF(InvalidImage):
  class __GIF__ (line 280) | class __GIF__(ImageMetrics):
    method __init__ (line 281) | def __init__(self, width, height, color_count):
    method parse (line 286) | def parse(cls, file_data):
  class InvalidTIFF (line 312) | class InvalidTIFF(InvalidImage):
  class __TIFF__ (line 318) | class __TIFF__(ImageMetrics):
    method __init__ (line 319) | def __init__(self, width, height, bits_per_pixel, color_count):
    method parse (line 325) | def parse(cls, file_data):

FILE: audiotools/m4a.py
  class InvalidM4A (line 23) | class InvalidM4A(InvalidFile):
  function get_m4a_atom (line 27) | def get_m4a_atom(reader, *atoms):
  function get_m4a_atom_offset (line 54) | def get_m4a_atom_offset(reader, *atoms):
  function has_m4a_atom (line 85) | def has_m4a_atom(reader, *atoms):
  class M4ATaggedAudio (line 110) | class M4ATaggedAudio(object):
    method supports_metadata (line 112) | def supports_metadata(cls):
    method get_metadata (line 117) | def get_metadata(self):
    method update_metadata (line 155) | def update_metadata(self, metadata, old_metadata=None):
    method set_metadata (line 261) | def set_metadata(self, metadata):
    method delete_metadata (line 291) | def delete_metadata(self):
  class M4AAudio_faac (line 302) | class M4AAudio_faac(M4ATaggedAudio, AudioFile):
    method __init__ (line 316) | def __init__(self, filename):
    method channel_mask (line 376) | def channel_mask(self):
    method lossless (line 408) | def lossless(self):
    method channels (line 413) | def channels(self):
    method bits_per_sample (line 418) | def bits_per_sample(self):
    method sample_rate (line 423) | def sample_rate(self):
    method cd_frames (line 428) | def cd_frames(self):
    method total_frames (line 435) | def total_frames(self):
    method supports_to_pcm (line 441) | def supports_to_pcm(cls):
    method to_pcm (line 447) | def to_pcm(self):
    method supports_from_pcm (line 467) | def supports_from_pcm(cls):
    method from_pcm (line 474) | def from_pcm(cls, filename, pcmreader,
  class M4AAudio_nero (line 581) | class M4AAudio_nero(M4AAudio_faac):
    method supports_from_pcm (line 598) | def supports_from_pcm(cls):
    method from_pcm (line 605) | def from_pcm(cls, filename, pcmreader,
    method supports_to_pcm (line 653) | def supports_to_pcm(cls):
    method to_pcm (line 659) | def to_pcm(self):
    method __from_wave__ (line 680) | def __from_wave__(cls, filename, wave_filename, compression):
  class InvalidALAC (line 706) | class InvalidALAC(InvalidFile):
  class ALACAudio (line 710) | class ALACAudio(M4ATaggedAudio, AudioFile):
    method __init__ (line 725) | def __init__(self, filename):
    method channels (line 799) | def channels(self):
    method bits_per_sample (line 804) | def bits_per_sample(self):
    method sample_rate (line 809) | def sample_rate(self):
    method total_frames (line 814) | def total_frames(self):
    method channel_mask (line 819) | def channel_mask(self):
    method cd_frames (line 827) | def cd_frames(self):
    method lossless (line 837) | def lossless(self):
    method seekable (line 842) | def seekable(self):
    method supports_to_pcm (line 875) | def supports_to_pcm(cls):
    method to_pcm (line 885) | def to_pcm(self):
    method supports_from_pcm (line 901) | def supports_from_pcm(cls):
    method from_pcm (line 912) | def from_pcm(cls, filename, pcmreader,

FILE: audiotools/m4a_atoms.py
  function parse_sub_atoms (line 52) | def parse_sub_atoms(data_size, reader, parsers):
  class M4A_Tree_Atom (line 79) | class M4A_Tree_Atom(object):
    method __init__ (line 80) | def __init__(self, name, leaf_atoms):
    method copy (line 90) | def copy(self):
    method __repr__ (line 96) | def __repr__(self):
    method __eq__ (line 99) | def __eq__(self, atom):
    method __iter__ (line 107) | def __iter__(self):
    method __getitem__ (line 111) | def __getitem__(self, atom_name):
    method get_child (line 114) | def get_child(self, atom_name):
    method get_children (line 126) | def get_children(self, atom_name):
    method has_child (line 131) | def has_child(self, atom_name):
    method add_child (line 143) | def add_child(self, atom_obj):
    method remove_child (line 148) | def remove_child(self, atom_name):
    method replace_child (line 163) | def replace_child(self, atom_obj):
    method child_offset (line 178) | def child_offset(self, *child_path):
    method parse (line 199) | def parse(cls, name, data_size, reader, parsers):
    method build (line 206) | def build(self, writer):
    method size (line 214) | def size(self):
  class M4A_Leaf_Atom (line 221) | class M4A_Leaf_Atom(object):
    method __init__ (line 222) | def __init__(self, name, data):
    method copy (line 233) | def copy(self):
    method __repr__ (line 239) | def __repr__(self):
    method __eq__ (line 242) | def __eq__(self, atom):
    method __str__ (line 251) | def __str__(self):
    method __str__ (line 254) | def __str__(self):
    method __unicode__ (line 257) | def __unicode__(self):
    method raw_info (line 264) | def raw_info(self):
    method parse (line 279) | def parse(cls, name, data_size, reader, parsers):
    method build (line 286) | def build(self, writer):
    method size (line 292) | def size(self):
  class M4A_FTYP_Atom (line 299) | class M4A_FTYP_Atom(M4A_Leaf_Atom):
    method __init__ (line 300) | def __init__(self, major_brand, major_brand_version, compatible_brands):
    method __repr__ (line 310) | def __repr__(self):
    method parse (line 315) | def parse(cls, name, data_size, reader, parsers):
    method build (line 326) | def build(self, writer):
    method size (line 335) | def size(self):
  class M4A_MVHD_Atom (line 342) | class M4A_MVHD_Atom(M4A_Leaf_Atom):
    method __init__ (line 343) | def __init__(self, version, flags, created_utc_date, modified_utc_date,
    method parse (line 364) | def parse(cls, name, data_size, reader, parsers):
    method __repr__ (line 406) | def __repr__(self):
    method build (line 424) | def build(self, writer):
    method size (line 447) | def size(self):
  class M4A_TKHD_Atom (line 457) | class M4A_TKHD_Atom(M4A_Leaf_Atom):
    method __init__ (line 458) | def __init__(self, version, track_in_poster, track_in_preview,
    method __repr__ (line 480) | def __repr__(self):
    method parse (line 500) | def parse(cls, name, data_size, reader, parsers):
    method build (line 542) | def build(self, writer):
    method size (line 561) | def size(self):
  class M4A_MDHD_Atom (line 571) | class M4A_MDHD_Atom(M4A_Leaf_Atom):
    method __init__ (line 572) | def __init__(self, version, flags, created_utc_date, modified_utc_date,
    method __repr__ (line 584) | def __repr__(self):
    method parse (line 597) | def parse(cls, name, data_size, reader, parsers):
    method build (line 624) | def build(self, writer):
    method size (line 639) | def size(self):
  class M4A_SMHD_Atom (line 649) | class M4A_SMHD_Atom(M4A_Leaf_Atom):
    method __init__ (line 650) | def __init__(self, version, flags, audio_balance):
    method __repr__ (line 656) | def __repr__(self):
    method parse (line 663) | def parse(cls, name, data_size, reader, parsers):
    method build (line 670) | def build(self, writer):
    method size (line 677) | def size(self):
  class M4A_DREF_Atom (line 684) | class M4A_DREF_Atom(M4A_Leaf_Atom):
    method __init__ (line 685) | def __init__(self, version, flags, references):
    method __repr__ (line 691) | def __repr__(self):
    method parse (line 698) | def parse(cls, name, data_size, reader, parsers):
    method build (line 713) | def build(self, writer):
    method size (line 726) | def size(self):
  class M4A_STSD_Atom (line 734) | class M4A_STSD_Atom(M4A_Leaf_Atom):
    method __init__ (line 735) | def __init__(self, version, flags, descriptions):
    method __repr__ (line 741) | def __repr__(self):
    method parse (line 746) | def parse(cls, name, data_size, reader, parsers):
    method build (line 765) | def build(self, writer):
    method size (line 778) | def size(self):
  class M4A_STTS_Atom (line 786) | class M4A_STTS_Atom(M4A_Leaf_Atom):
    method __init__ (line 787) | def __init__(self, version, flags, times):
    method __repr__ (line 793) | def __repr__(self):
    method parse (line 798) | def parse(cls, name, data_size, reader, parsers):
    method build (line 809) | def build(self, writer):
    method size (line 817) | def size(self):
  class M4A_STSC_Atom (line 824) | class M4A_STSC_Atom(M4A_Leaf_Atom):
    method __init__ (line 825) | def __init__(self, version, flags, blocks):
    method __repr__ (line 831) | def __repr__(self):
    method parse (line 836) | def parse(cls, name, data_size, reader, parsers):
    method build (line 847) | def build(self, writer):
    method size (line 856) | def size(self):
  class M4A_STSZ_Atom (line 863) | class M4A_STSZ_Atom(M4A_Leaf_Atom):
    method __init__ (line 864) | def __init__(self, version, flags, byte_size, block_sizes):
    method __repr__ (line 871) | def __repr__(self):
    method parse (line 876) | def parse(cls, name, data_size, reader, parsers):
    method build (line 888) | def build(self, writer):
    method size (line 899) | def size(self):
  class M4A_STCO_Atom (line 906) | class M4A_STCO_Atom(M4A_Leaf_Atom):
    method __init__ (line 907) | def __init__(self, version, flags, offsets):
    method __repr__ (line 913) | def __repr__(self):
    method parse (line 918) | def parse(cls, name, data_size, reader, parsers):
    method build (line 928) | def build(self, writer):
    method size (line 937) | def size(self):
  class M4A_ALAC_Atom (line 944) | class M4A_ALAC_Atom(M4A_Leaf_Atom):
    method __init__ (line 945) | def __init__(self, reference_index, qt_version, qt_revision_level,
    method __repr__ (line 962) | def __repr__(self):
    method parse (line 976) | def parse(cls, name, data_size, reader, parsers):
    method build (line 1007) | def build(self, writer):
    method size (line 1025) | def size(self):
  class M4A_SUB_ALAC_Atom (line 1032) | class M4A_SUB_ALAC_Atom(M4A_Leaf_Atom):
    method __init__ (line 1033) | def __init__(self, max_samples_per_frame, bits_per_sample,
    method __repr__ (line 1049) | def __repr__(self):
    method parse (line 1063) | def parse(cls, name, data_size, reader, parsers):
    method build (line 1072) | def build(self, writer):
    method size (line 1088) | def size(self):
  class M4A_META_Atom (line 1095) | class M4A_META_Atom(MetaData, M4A_Tree_Atom):
    method __init__ (line 1113) | def __init__(self, version, flags, leaf_atoms):
    method __repr__ (line 1118) | def __repr__(self):
    method has_ilst_atom (line 1122) | def has_ilst_atom(self):
    method ilst_atom (line 1131) | def ilst_atom(self):
    method add_ilst_atom (line 1140) | def add_ilst_atom(self):
    method raw_info (line 1150) | def raw_info(self):
    method parse (line 1178) | def parse(cls, name, data_size, reader, parsers):
    method build (line 1188) | def build(self, writer):
    method size (line 1197) | def size(self):
    method __getattr__ (line 1203) | def __getattr__(self, attr):
    method __setattr__ (line 1245) | def __setattr__(self, attr, value):
    method __delattr__ (line 1327) | def __delattr__(self, attr):
    method images (line 1378) | def images(self):
    method add_image (line 1387) | def add_image(self, image):
    method delete_image (line 1404) | def delete_image(self, image):
    method converted (line 1417) | def converted(cls, metadata):
    method supports_images (line 1481) | def supports_images(self):
    method clean (line 1486) | def clean(self):
    method intersection (line 1547) | def intersection(self, metadata):
  class M4A_ILST_Leaf_Atom (line 1582) | class M4A_ILST_Leaf_Atom(M4A_Tree_Atom):
    method copy (line 1583) | def copy(self):
    method __repr__ (line 1589) | def __repr__(self):
    method parse (line 1594) | def parse(cls, name, data_size, reader, parsers):
    method __str__ (line 1618) | def __str__(self):
    method __str__ (line 1621) | def __str__(self):
    method __unicode__ (line 1624) | def __unicode__(self):
    method raw_info_lines (line 1631) | def raw_info_lines(self):
  class M4A_ILST_Unicode_Data_Atom (line 1642) | class M4A_ILST_Unicode_Data_Atom(M4A_Leaf_Atom):
    method __init__ (line 1643) | def __init__(self, type, flags, data):
    method copy (line 1651) | def copy(self):
    method __repr__ (line 1657) | def __repr__(self):
    method __eq__ (line 1661) | def __eq__(self, atom):
    method raw_info (line 1669) | def raw_info(self):
    method parse (line 1675) | def parse(cls, name, data_size, reader, parsers):
    method build (line 1684) | def build(self, writer):
    method size (line 1691) | def size(self):
    method __str__ (line 1698) | def __str__(self):
    method __str__ (line 1701) | def __str__(self):
    method __unicode__ (line 1704) | def __unicode__(self):
  class M4A_ILST_TRKN_Data_Atom (line 1708) | class M4A_ILST_TRKN_Data_Atom(M4A_Leaf_Atom):
    method __init__ (line 1709) | def __init__(self, track_number, track_total):
    method copy (line 1714) | def copy(self):
    method __repr__ (line 1720) | def __repr__(self):
    method __eq__ (line 1724) | def __eq__(self, atom):
    method __str__ (line 1733) | def __str__(self):
    method __str__ (line 1736) | def __str__(self):
    method __unicode__ (line 1739) | def __unicode__(self):
    method raw_info (line 1745) | def raw_info(self):
    method parse (line 1751) | def parse(cls, name, data_size, reader, parsers):
    method build (line 1760) | def build(self, writer):
    method size (line 1767) | def size(self):
    method number (line 1773) | def number(self):
    method total (line 1782) | def total(self):
  class M4A_ILST_DISK_Data_Atom (line 1792) | class M4A_ILST_DISK_Data_Atom(M4A_Leaf_Atom):
    method __init__ (line 1793) | def __init__(self, disk_number, disk_total):
    method copy (line 1798) | def copy(self):
    method __repr__ (line 1804) | def __repr__(self):
    method __eq__ (line 1808) | def __eq__(self, atom):
    method __str__ (line 1817) | def __str__(self):
    method __str__ (line 1820) | def __str__(self):
    method __unicode__ (line 1823) | def __unicode__(self):
    method raw_info (line 1829) | def raw_info(self):
    method parse (line 1835) | def parse(cls, name, data_size, reader, parsers):
    method build (line 1844) | def build(self, writer):
    method size (line 1851) | def size(self):
    method number (line 1857) | def number(self):
    method total (line 1865) | def total(self):
  class M4A_ILST_COVR_Data_Atom (line 1874) | class M4A_ILST_COVR_Data_Atom(Image, M4A_Leaf_Atom):
    method __init__ (line 1875) | def __init__(self, version, flags, image_data):
    method copy (line 1893) | def copy(self):
    method __repr__ (line 1899) | def __repr__(self):
    method raw_info (line 1903) | def raw_info(self):
    method parse (line 1916) | def parse(cls, name, data_size, reader, parsers):
    method build (line 1925) | def build(self, writer):
    method size (line 1932) | def size(self):
    method converted (line 1939) | def converted(cls, image):
  class M4A_HDLR_Atom (line 1946) | class M4A_HDLR_Atom(M4A_Leaf_Atom):
    method __init__ (line 1947) | def __init__(self, version, flags, qt_type, qt_subtype,
    method copy (line 1965) | def copy(self):
    method __repr__ (line 1979) | def __repr__(self):
    method parse (line 1993) | def parse(cls, name, data_size, reader, parsers):
    method build (line 2013) | def build(self, writer):
    method size (line 2029) | def size(self):
  class M4A_FREE_Atom (line 2036) | class M4A_FREE_Atom(M4A_Leaf_Atom):
    method __init__ (line 2037) | def __init__(self, bytes):
    method copy (line 2041) | def copy(self):
    method __repr__ (line 2047) | def __repr__(self):
    method parse (line 2051) | def parse(cls, name, data_size, reader, parsers):
    method build (line 2060) | def build(self, writer):
    method size (line 2066) | def size(self):

FILE: audiotools/mp3.py
  class InvalidMP3 (line 22) | class InvalidMP3(InvalidFile):
  class MP3Audio (line 28) | class MP3Audio(AudioFile):
    method __init__ (line 104) | def __init__(self, filename):
    method lossless (line 196) | def lossless(self):
    method supports_to_pcm (line 202) | def supports_to_pcm(cls):
    method to_pcm (line 212) | def to_pcm(self):
    method supports_from_pcm (line 220) | def supports_from_pcm(cls):
    method from_pcm (line 231) | def from_pcm(cls, filename, pcmreader,
    method bits_per_sample (line 285) | def bits_per_sample(self):
    method channels (line 290) | def channels(self):
    method sample_rate (line 295) | def sample_rate(self):
    method supports_metadata (line 301) | def supports_metadata(cls):
    method get_metadata (line 306) | def get_metadata(self):
    method update_metadata (line 333) | def update_metadata(self, metadata):
    method set_metadata (line 386) | def set_metadata(self, metadata):
    method delete_metadata (line 436) | def delete_metadata(self):
    method clean (line 471) | def clean(self, output_filename=None):
    method __find_next_mp3_frame__ (line 526) | def __find_next_mp3_frame__(cls, mp3file):
    method __find_mp3_start__ (line 562) | def __find_mp3_start__(cls, mp3file):
    method __find_last_mp3_frame__ (line 586) | def __find_last_mp3_frame__(cls, mp3file):
    method frame_length (line 603) | def frame_length(self, mpeg_id, layer, bit_rate, sample_rate, pad):
    method total_frames (line 627) | def total_frames(self):
  class MP2Audio (line 633) | class MP2Audio(MP3Audio):
    method supports_from_pcm (line 649) | def supports_from_pcm(cls):
    method from_pcm (line 660) | def from_pcm(cls, filename, pcmreader,

FILE: audiotools/mpc.py
  class MPC_Size (line 24) | class MPC_Size:
    method __init__ (line 25) | def __init__(self, value, length):
    method __repr__ (line 29) | def __repr__(self):
    method __int__ (line 32) | def __int__(self):
    method __len__ (line 35) | def __len__(self):
    method parse (line 39) | def parse(cls, reader):
    method build (line 50) | def build(self, writer):
  class InvalidMPC (line 56) | class InvalidMPC(InvalidFile):
  class MPCAudio (line 62) | class MPCAudio(ApeTaggedAudio, AudioFile):
    method __init__ (line 85) | def __init__(self, filename):
    method blocks (line 106) | def blocks(self):
    method get_block (line 120) | def get_block(self, block_id):
    method bits_per_sample (line 127) | def bits_per_sample(self):
    method channels (line 132) | def channels(self):
    method lossless (line 137) | def lossless(self):
    method total_frames (line 142) | def total_frames(self):
    method sample_rate (line 147) | def sample_rate(self):
    method supports_to_pcm (line 153) | def supports_to_pcm(cls):
    method to_pcm (line 163) | def to_pcm(self):
    method supports_from_pcm (line 182) | def supports_from_pcm(cls):
    method from_pcm (line 193) | def from_pcm(cls, filename, pcmreader,
    method supports_replay_gain (line 258) | def supports_replay_gain(cls):
    method get_replay_gain (line 263) | def get_replay_gain(self):
    method set_replay_gain (line 296) | def set_replay_gain(self, replaygain):
    method delete_replay_gain (line 341) | def delete_replay_gain(self):

FILE: audiotools/musicbrainz.py
  class DiscID (line 22) | class DiscID(object):
    method __init__ (line 23) | def __init__(self, first_track_number, last_track_number,
    method from_cddareader (line 38) | def from_cddareader(cls, cddareader):
    method from_tracks (line 49) | def from_tracks(cls, tracks):
    method from_sheet (line 77) | def from_sheet(cls, sheet, total_pcm_frames, sample_rate):
    method __repr__ (line 89) | def __repr__(self):
    method __str__ (line 98) | def __str__(self):
    method __str__ (line 101) | def __str__(self):
    method __unicode__ (line 104) | def __unicode__(self):
  function perform_lookup (line 120) | def perform_lookup(disc_id, musicbrainz_server, musicbrainz_port):
  function get_node (line 170) | def get_node(parent, *nodes):
  function get_nodes (line 185) | def get_nodes(parent, node):
  function text (line 193) | def text(node):
  function artist (line 203) | def artist(artist_credit):
  function parse_release (line 222) | def parse_release(release, disc_id):

FILE: audiotools/ogg.py
  class PacketReader (line 21) | class PacketReader(object):
    method __init__ (line 22) | def __init__(self, pagereader):
    method __enter__ (line 35) | def __enter__(self):
    method __exit__ (line 38) | def __exit__(self, exc_type, exc_value, traceback):
    method read_segment (line 41) | def read_segment(self):
    method read_page (line 49) | def read_page(self):
    method read_packet (line 54) | def read_packet(self):
    method close (line 67) | def close(self):
  function packet_to_segments (line 73) | def packet_to_segments(packet):
  function packet_to_pages (line 87) | def packet_to_pages(packet, bitstream_serial_number,
  function packets_to_pages (line 127) | def packets_to_pages(packets, bitstream_serial_number,

FILE: audiotools/opus.py
  class InvalidOpus (line 23) | class InvalidOpus(InvalidFile):
  class OpusAudio (line 31) | class OpusAudio(VorbisAudio):
    method __init__ (line 42) | def __init__(self, filename):
    method supports_replay_gain (line 113) | def supports_replay_gain(cls):
    method get_replay_gain (line 118) | def get_replay_gain(self):
    method set_replay_gain (line 127) | def set_replay_gain(self, replaygain):
    method delete_replay_gain (line 134) | def delete_replay_gain(self):
    method total_frames (line 141) | def total_frames(self):
    method sample_rate (line 159) | def sample_rate(self):
    method supports_to_pcm (line 165) | def supports_to_pcm(cls):
    method to_pcm (line 175) | def to_pcm(self):
    method supports_from_pcm (line 194) | def supports_from_pcm(cls):
    method from_pcm (line 205) | def from_pcm(cls, filename, pcmreader,
    method update_metadata (line 280) | def update_metadata(self, metadata):
    method set_metadata (line 357) | def set_metadata(self, metadata):
    method supports_metadata (line 387) | def supports_metadata(cls):
    method get_metadata (line 392) | def get_metadata(self):
    method delete_metadata (line 416) | def delete_metadata(self):
    method verify (line 428) | def verify(self, progress=None):

FILE: audiotools/player.py
  class Player (line 25) | class Player(object):
    method __init__ (line 31) | def __init__(self, audio_output,
    method open (line 67) | def open(self, track):
    method play (line 74) | def play(self):
    method set_replay_gain (line 79) | def set_replay_gain(self, replay_gain):
    method set_output (line 88) | def set_output(self, output):
    method pause (line 97) | def pause(self):
    method toggle_play_pause (line 104) | def toggle_play_pause(self):
    method stop (line 109) | def stop(self):
    method state (line 116) | def state(self):
    method close (line 122) | def close(self):
    method progress (line 129) | def progress(self):
    method current_output_description (line 136) | def current_output_description(self):
    method current_output_name (line 142) | def current_output_name(self):
    method get_volume (line 148) | def get_volume(self):
    method set_volume (line 154) | def set_volume(self, volume):
    method change_volume (line 160) | def change_volume(self, delta):
  class AudioPlayer (line 170) | class AudioPlayer(object):
    method __init__ (line 171) | def __init__(self, audio_output,
    method set_audiofile (line 189) | def set_audiofile(self, audiofile):
    method state (line 194) | def state(self):
    method progress (line 200) | def progress(self):
    method stop (line 206) | def stop(self):
    method pause (line 221) | def pause(self):
    method play (line 229) | def play(self):
    method output_audio (line 288) | def output_audio(self):
    method run (line 313) | def run(self, commands, responses):
  class CDPlayer (line 374) | class CDPlayer(Player):
    method __init__ (line 375) | def __init__(self, cddareader, audio_output,
    method open (line 407) | def open(self, track_number):
    method set_replay_gain (line 414) | def set_replay_gain(self, replay_gain):
  class CDAudioPlayer (line 420) | class CDAudioPlayer(AudioPlayer):
    method __init__ (line 421) | def __init__(self, cddareader, audio_output,
    method set_audiofile (line 443) | def set_audiofile(self, track_number):
    method play (line 450) | def play(self):
  class AudioOutput (line 498) | class AudioOutput(object):
    method __init__ (line 501) | def __init__(self):
    method __getstate__ (line 507) | def __getstate__(self):
    method __setstate__ (line 512) | def __setstate__(self, name):
    method description (line 521) | def description(self):
    method compatible (line 526) | def compatible(self, sample_rate, channels, channel_mask, bits_per_sam...
    method set_format (line 535) | def set_format(self, sample_rate, channels, channel_mask, bits_per_sam...
    method play (line 551) | def play(self, framelist):
    method pause (line 556) | def pause(self):
    method resume (line 561) | def resume(self):
    method get_volume (line 566) | def get_volume(self):
    method set_volume (line 571) | def set_volume(self, volume):
    method close (line 577) | def close(self):
    method available (line 586) | def available(cls):
  class NULLAudioOutput (line 592) | class NULLAudioOutput(AudioOutput):
    method __init__ (line 600) | def __init__(self):
    method __getstate__ (line 604) | def __getstate__(self):
    method __setstate__ (line 607) | def __setstate__(self, name):
    method description (line 611) | def description(self):
    method play (line 616) | def play(self, framelist):
    method pause (line 623) | def pause(self):
    method resume (line 628) | def resume(self):
    method get_volume (line 633) | def get_volume(self):
    method set_volume (line 638) | def set_volume(self, volume):
    method close (line 647) | def close(self):
    method available (line 653) | def available(cls):
  class OSSAudioOutput (line 659) | class OSSAudioOutput(AudioOutput):
    method __init__ (line 664) | def __init__(self):
    method __getstate__ (line 672) | def __getstate__(self):
    method __setstate__ (line 677) | def __setstate__(self, name):
    method description (line 684) | def description(self):
    method set_format (line 689) | def set_format(self, sample_rate, channels, channel_mask, bits_per_sam...
    method play (line 741) | def play(self, framelist):
    method pause (line 746) | def pause(self):
    method resume (line 751) | def resume(self):
    method get_volume (line 756) | def get_volume(self):
    method set_volume (line 776) | def set_volume(self, volume):
    method close (line 796) | def close(self):
    method available (line 809) | def available(cls):
  class PulseAudioOutput (line 820) | class PulseAudioOutput(AudioOutput):
    method __init__ (line 825) | def __init__(self):
    method __getstate__ (line 829) | def __getstate__(self):
    method __setstate__ (line 834) | def __setstate__(self, name):
    method description (line 840) | def description(self):
    method set_format (line 846) | def set_format(self, sample_rate, channels, channel_mask, bits_per_sam...
    method play (line 885) | def play(self, framelist):
    method pause (line 890) | def pause(self):
    method resume (line 896) | def resume(self):
    method get_volume (line 902) | def get_volume(self):
    method set_volume (line 910) | def set_volume(self, volume):
    method close (line 922) | def close(self):
    method available (line 933) | def available(cls):
  class ALSAAudioOutput (line 944) | class ALSAAudioOutput(AudioOutput):
    method __init__ (line 949) | def __init__(self):
    method __getstate__ (line 953) | def __getstate__(self):
    method __setstate__ (line 958) | def __setstate__(self, name):
    method description (line 964) | def description(self):
    method set_format (line 970) | def set_format(self, sample_rate, channels, channel_mask, bits_per_sam...
    method play (line 1005) | def play(self, framelist):
    method pause (line 1010) | def pause(self):
    method resume (line 1016) | def resume(self):
    method get_volume (line 1022) | def get_volume(self):
    method set_volume (line 1029) | def set_volume(self, volume):
    method close (line 1040) | def close(self):
    method available (line 1051) | def available(cls):
  class CoreAudioOutput (line 1062) | class CoreAudioOutput(AudioOutput):
    method __init__ (line 1067) | def __init__(self):
    method __getstate__ (line 1071) | def __getstate__(self):
    method __setstate__ (line 1076) | def __setstate__(self, name):
    method description (line 1082) | def description(self):
    method set_format (line 1088) | def set_format(self, sample_rate, channels, channel_mask, bits_per_sam...
    method play (line 1123) | def play(self, framelist):
    method pause (line 1128) | def pause(self):
    method resume (line 1134) | def resume(self):
    method get_volume (line 1140) | def get_volume(self):
    method set_volume (line 1151) | def set_volume(self, volume):
    method close (line 1166) | def close(self):
    method available (line 1177) | def available(cls):
  function available_outputs (line 1188) | def available_outputs():
  function open_output (line 1207) | def open_output(output):

FILE: audiotools/ply/lex.py
  class LexError (line 57) | class LexError(Exception):
    method __init__ (line 58) | def __init__(self, message, s):
  class LexToken (line 64) | class LexToken(object):
    method __str__ (line 65) | def __str__(self):
    method __repr__ (line 68) | def __repr__(self):
  class PlyLogger (line 75) | class PlyLogger(object):
    method __init__ (line 76) | def __init__(self, f):
    method critical (line 79) | def critical(self, msg, *args, **kwargs):
    method warning (line 82) | def warning(self, msg, *args, **kwargs):
    method error (line 85) | def error(self, msg, *args, **kwargs):
  class NullLogger (line 93) | class NullLogger(object):
    method __getattribute__ (line 94) | def __getattribute__(self, name):
    method __call__ (line 97) | def __call__(self, *args, **kwargs):
  class Lexer (line 115) | class Lexer:
    method __init__ (line 116) | def __init__(self):
    method clone (line 144) | def clone(self, object=None):
    method writetab (line 174) | def writetab(self, lextab, outputdir=''):
    method readtab (line 211) | def readtab(self, tabfile, fdict):
    method input (line 251) | def input(self, s):
    method begin (line 263) | def begin(self, state):
    method push_state (line 276) | def push_state(self, state):
    method pop_state (line 283) | def pop_state(self):
    method current_state (line 289) | def current_state(self):
    method skip (line 295) | def skip(self, n):
    method token (line 305) | def token(self):
    method __iter__ (line 415) | def __iter__(self):
    method next (line 418) | def next(self):
  function _get_regex (line 439) | def _get_regex(func):
  function get_caller_module_dict (line 449) | def get_caller_module_dict(levels):
  function _funcs_to_names (line 462) | def _funcs_to_names(funclist, namelist):
  function _names_to_funcs (line 477) | def _names_to_funcs(namelist, fdict):
  function _form_master_re (line 493) | def _form_master_re(relist, reflags, ldict, toknames):
  function _statetoken (line 533) | def _statetoken(s, names):
  class LexerReflect (line 558) | class LexerReflect(object):
    method __init__ (line 559) | def __init__(self, ldict, log=None, reflags=0):
    method get_all (line 570) | def get_all(self):
    method validate_all (line 577) | def validate_all(self):
    method get_tokens (line 584) | def get_tokens(self):
    method validate_tokens (line 604) | def validate_tokens(self):
    method get_literals (line 615) | def get_literals(self):
    method validate_literals (line 621) | def validate_literals(self):
    method get_states (line 632) | def get_states(self):
    method get_rules (line 663) | def get_rules(self):
    method validate_rules (line 729) | def validate_rules(self):
    method validate_module (line 832) | def validate_module(self, module):
  function lex (line 860) | def lex(module=None, object=None, debug=False, optimize=False, lextab='l...
  function runmain (line 1052) | def runmain(lexer=None, data=None):
  function TOKEN (line 1086) | def TOKEN(r):

FILE: audiotools/ply/yacc.py
  class PlyLogger (line 109) | class PlyLogger(object):
    method __init__ (line 110) | def __init__(self, f):
    method debug (line 113) | def debug(self, msg, *args, **kwargs):
    method warning (line 118) | def warning(self, msg, *args, **kwargs):
    method error (line 121) | def error(self, msg, *args, **kwargs):
  class NullLogger (line 127) | class NullLogger(object):
    method __getattribute__ (line 128) | def __getattribute__(self, name):
    method __call__ (line 131) | def __call__(self, *args, **kwargs):
  class YaccError (line 135) | class YaccError(Exception):
  function format_result (line 139) | def format_result(r):
  function format_stack_entry (line 149) | def format_stack_entry(r):
  function errok (line 175) | def errok():
  function restart (line 179) | def restart():
  function token (line 183) | def token():
  function call_errorfunc (line 188) | def call_errorfunc(errorfunc, token, parser):
  class YaccSymbol (line 217) | class YaccSymbol:
    method __str__ (line 218) | def __str__(self):
    method __repr__ (line 221) | def __repr__(self):
  class YaccProduction (line 233) | class YaccProduction:
    method __init__ (line 234) | def __init__(self, s, stack=None):
    method __getitem__ (line 240) | def __getitem__(self, n):
    method __setitem__ (line 248) | def __setitem__(self, n, v):
    method __getslice__ (line 251) | def __getslice__(self, i, j):
    method __len__ (line 254) | def __len__(self):
    method lineno (line 257) | def lineno(self, n):
    method set_lineno (line 260) | def set_lineno(self, n, lineno):
    method linespan (line 263) | def linespan(self, n):
    method lexpos (line 268) | def lexpos(self, n):
    method lexspan (line 271) | def lexspan(self, n):
    method error (line 276) | def error(self):
  class LRParser (line 285) | class LRParser:
    method __init__ (line 286) | def __init__(self, lrtab, errorf):
    method errok (line 294) | def errok(self):
    method restart (line 297) | def restart(self):
    method set_defaulted_states (line 313) | def set_defaulted_states(self):
    method disable_defaulted_states (line 320) | def disable_defaulted_states(self):
    method parse (line 323) | def parse(self, input=None, lexer=None, debug=False, tracking=False, t...
    method parsedebug (line 348) | def parsedebug(self, input=None, lexer=None, debug=False, tracking=Fal...
    method parseopt (line 689) | def parseopt(self, input=None, lexer=None, debug=False, tracking=False...
    method parseopt_notrack (line 989) | def parseopt_notrack(self, input=None, lexer=None, debug=False, tracki...
  class Production (line 1291) | class Production(object):
    method __init__ (line 1293) | def __init__(self, number, name, prod, precedence=('right', 0), func=N...
    method __str__ (line 1323) | def __str__(self):
    method __repr__ (line 1326) | def __repr__(self):
    method __len__ (line 1329) | def __len__(self):
    method __nonzero__ (line 1332) | def __nonzero__(self):
    method __getitem__ (line 1335) | def __getitem__(self, index):
    method lr_item (line 1339) | def lr_item(self, n):
    method bind (line 1355) | def bind(self, pdict):
  class MiniProduction (line 1363) | class MiniProduction(object):
    method __init__ (line 1364) | def __init__(self, str, name, len, func, file, line):
    method __str__ (line 1373) | def __str__(self):
    method __repr__ (line 1376) | def __repr__(self):
    method bind (line 1380) | def bind(self, pdict):
  class LRItem (line 1409) | class LRItem(object):
    method __init__ (line 1410) | def __init__(self, p, n):
    method __str__ (line 1421) | def __str__(self):
    method __repr__ (line 1428) | def __repr__(self):
  function rightmost_terminal (line 1436) | def rightmost_terminal(symbols, terminals):
  class GrammarError (line 1452) | class GrammarError(YaccError):
  class Grammar (line 1455) | class Grammar(object):
    method __init__ (line 1456) | def __init__(self, terminals):
    method __len__ (line 1492) | def __len__(self):
    method __getitem__ (line 1495) | def __getitem__(self, index):
    method set_precedence (line 1506) | def set_precedence(self, term, assoc, level):
    method add_production (line 1531) | def add_production(self, prodname, syms, func=None, file='', line=0):
    method set_start (line 1615) | def set_start(self, start=None):
    method find_unreachable (line 1631) | def find_unreachable(self):
    method infinite_cycles (line 1654) | def infinite_cycles(self):
    method undefined_symbols (line 1718) | def undefined_symbols(self):
    method unused_terminals (line 1735) | def unused_terminals(self):
    method unused_rules (line 1750) | def unused_rules(self):
    method unused_precedence (line 1767) | def unused_precedence(self):
    method _first (line 1783) | def _first(self, beta):
    method compute_first (line 1818) | def compute_first(self):
    method compute_follow (line 1855) | def compute_follow(self, start=None):
    method build_lritems (line 1914) | def build_lritems(self):
  class VersionError (line 1950) | class VersionError(YaccError):
  class LRTable (line 1953) | class LRTable(object):
    method __init__ (line 1954) | def __init__(self):
    method read_table (line 1960) | def read_table(self, module):
    method read_pickle (line 1980) | def read_pickle(self, filename):
    method bind_callables (line 2008) | def bind_callables(self, pdict):
  function digraph (line 2037) | def digraph(X, R, FP):
  function traverse (line 2048) | def traverse(x, N, stack, F, X, R, FP):
  class LALRError (line 2071) | class LALRError(YaccError):
  class LRGeneratedTable (line 2081) | class LRGeneratedTable(LRTable):
    method __init__ (line 2082) | def __init__(self, grammar, method='LALR', log=None):
    method lr0_closure (line 2119) | def lr0_closure(self, I):
    method lr0_goto (line 2145) | def lr0_goto(self, I, x):
    method lr0_items (line 2180) | def lr0_items(self):
    method compute_nullable_nonterminals (line 2236) | def compute_nullable_nonterminals(self):
    method find_nonterminal_transitions (line 2265) | def find_nonterminal_transitions(self, C):
    method dr_relation (line 2285) | def dr_relation(self, C, trans, nullable):
    method reads_relation (line 2310) | def reads_relation(self, C, trans, empty):
    method compute_lookback_includes (line 2353) | def compute_lookback_includes(self, C, trans, nullable):
    method compute_read_sets (line 2433) | def compute_read_sets(self, C, ntrans, nullable):
    method compute_follow_sets (line 2455) | def compute_follow_sets(self, ntrans, readsets, inclsets):
    method add_lookaheads (line 2473) | def add_lookaheads(self, lookbacks, followset):
    method add_lalr_lookaheads (line 2491) | def add_lalr_lookaheads(self, C):
    method lr_parse_table (line 2515) | def lr_parse_table(self):
    method write_table (line 2698) | def write_table(self, tabmodule, outputdir='', signature=''):
    method pickle_table (line 2820) | def pickle_table(self, filename, signature=''):
  function get_caller_module_dict (line 2855) | def get_caller_module_dict(levels):
  function parse_grammar (line 2867) | def parse_grammar(doc, file, line):
  class ParserReflect (line 2908) | class ParserReflect(object):
    method __init__ (line 2909) | def __init__(self, pdict, log=None):
    method get_all (line 2924) | def get_all(self):
    method validate_all (line 2932) | def validate_all(self):
    method signature (line 2942) | def signature(self):
    method validate_modules (line 2977) | def validate_modules(self):
    method get_start (line 2999) | def get_start(self):
    method validate_start (line 3003) | def validate_start(self):
    method get_error_func (line 3009) | def get_error_func(self):
    method validate_error_func (line 3013) | def validate_error_func(self):
    method get_tokens (line 3035) | def get_tokens(self):
    method validate_tokens (line 3055) | def validate_tokens(self):
    method get_precedence (line 3069) | def get_precedence(self):
    method validate_precedence (line 3073) | def validate_precedence(self):
    method get_pfunctions (line 3104) | def get_pfunctions(self):
    method validate_pfunctions (line 3125) | def validate_pfunctions(self):
  function yacc (line 3191) | def yacc(method='LALR', debug=yaccdebug, module=None, tabmodule=tab_modu...

FILE: audiotools/speex.py
  class InvalidSpeex (line 21) | class InvalidSpeex(InvalidFile):
  class SpeexAudio (line 25) | class SpeexAudio(AudioFile):
    method __init__ (line 40) | def __init__(self, filename):
    method bits_per_sample (line 88) | def bits_per_sample(self):
    method channels (line 93) | def channels(self):
    method total_frames (line 98) | def total_frames(self):
    method lossless (line 116) | def lossless(self):
    method supports_metadata (line 122) | def supports_metadata(cls):
    method update_metadata (line 127) | def update_metadata(self, metadata):
    method set_metadata (line 206) | def set_metadata(self, metadata):
    method get_metadata (line 236) | def get_metadata(self):
    method delete_metadata (line 260) | def delete_metadata(self):
    method sample_rate (line 272) | def sample_rate(self):
    method supports_to_pcm (line 278) | def supports_to_pcm(cls):
    method to_pcm (line 284) | def to_pcm(self):
    method supports_from_pcm (line 309) | def supports_from_pcm(cls):
    method from_pcm (line 316) | def from_pcm(cls, filename, pcmreader,

FILE: audiotools/toc/__init__.py
  class TOCFile (line 23) | class TOCFile(Sheet):
    method __init__ (line 24) | def __init__(self, type, tracks, catalog=None, cd_text=None):
    method __repr__ (line 39) | def __repr__(self):
    method converted (line 49) | def converted(cls, sheet, filename=None):
    method __len__ (line 75) | def __len__(self):
    method __getitem__ (line 78) | def __getitem__(self, index):
    method build (line 81) | def build(self):
    method get_metadata (line 94) | def get_metadata(self):
  class TOCTrack (line 113) | class TOCTrack(SheetTrack):
    method __init__ (line 114) | def __init__(self, mode, flags, sub_channel_mode=None):
    method converted (line 159) | def converted(cls, sheettrack, next_sheettrack, filename=None):
    method first_flag (line 208) | def first_flag(self, flag_class):
    method all_flags (line 218) | def all_flags(self, flag_class):
    method __repr__ (line 223) | def __repr__(self):
    method __len__ (line 232) | def __len__(self):
    method __getitem__ (line 235) | def __getitem__(self, index):
    method number (line 238) | def number(self):
    method get_metadata (line 243) | def get_metadata(self):
    method filename (line 261) | def filename(self):
    method is_audio (line 270) | def is_audio(self):
    method pre_emphasis (line 275) | def pre_emphasis(self):
    method copy_permitted (line 284) | def copy_permitted(self):
    method build (line 293) | def build(self):
  class TOCFlag (line 305) | class TOCFlag(object):
    method __init__ (line 306) | def __init__(self, attrs):
    method __repr__ (line 309) | def __repr__(self):
    method build (line 316) | def build(self):
  class TOCFlag_COPY (line 323) | class TOCFlag_COPY(TOCFlag):
    method __init__ (line 324) | def __init__(self, copy):
    method copy (line 329) | def copy(self):
    method build (line 332) | def build(self):
  class TOCFlag_PRE_EMPHASIS (line 336) | class TOCFlag_PRE_EMPHASIS(TOCFlag):
    method __init__ (line 337) | def __init__(self, pre_emphasis):
    method pre_emphasis (line 342) | def pre_emphasis(self):
    method build (line 345) | def build(self):
  class TOCFlag_CHANNELS (line 349) | class TOCFlag_CHANNELS(TOCFlag):
    method __init__ (line 350) | def __init__(self, channels):
    method build (line 355) | def build(self):
  class TOCFlag_ISRC (line 361) | class TOCFlag_ISRC(TOCFlag):
    method __init__ (line 362) | def __init__(self, isrc):
    method isrc (line 369) | def isrc(self):
    method build (line 372) | def build(self):
  class TOCFlag_FILE (line 376) | class TOCFlag_FILE(TOCFlag):
    method __init__ (line 377) | def __init__(self, type, filename, start, length=None):
    method filename (line 391) | def filename(self):
    method start (line 394) | def start(self):
    method length (line 397) | def length(self):
    method build (line 400) | def build(self):
  class TOCFlag_START (line 412) | class TOCFlag_START(TOCFlag):
    method __init__ (line 413) | def __init__(self, start=None):
    method start (line 419) | def start(self):
    method build (line 422) | def build(self):
  class TOCFlag_INDEX (line 429) | class TOCFlag_INDEX(TOCFlag):
    method __init__ (line 430) | def __init__(self, index):
    method index (line 436) | def index(self):
    method build (line 439) | def build(self):
  class CDText (line 443) | class CDText(object):
    method __init__ (line 444) | def __init__(self, languages, language_map=None):
    method __repr__ (line 448) | def __repr__(self):
    method get (line 452) | def get(self, key, default):
    method build (line 461) | def build(self):
    method to_disc_metadata (line 470) | def to_disc_metadata(self):
    method from_disc_metadata (line 481) | def from_disc_metadata(cls, metadata):
    method to_track_metadata (line 502) | def to_track_metadata(self):
    method from_track_metadata (line 514) | def from_track_metadata(cls, metadata):
  class CDTextLanguage (line 536) | class CDTextLanguage(object):
    method __init__ (line 537) | def __init__(self, language_id, text_pairs):
    method __repr__ (line 541) | def __repr__(self):
    method __len__ (line 545) | def __len__(self):
    method __getitem__ (line 548) | def __getitem__(self, key):
    method build (line 555) | def build(self):
  class CDTextLanguageMap (line 566) | class CDTextLanguageMap(object):
    method __init__ (line 567) | def __init__(self, mapping):
    method __repr__ (line 570) | def __repr__(self):
    method build (line 573) | def build(self):
  function format_string (line 581) | def format_string(s):
  function format_timestamp (line 585) | def format_timestamp(t):
  function format_binary (line 592) | def format_binary(s):
  function read_tocfile (line 596) | def read_tocfile(filename):
  function read_tocfile_string (line 609) | def read_tocfile_string(tocfile):
  function write_tocfile (line 637) | def write_tocfile(sheet, filename, file):

FILE: audiotools/toc/tokrules.py
  function t_COMMENT (line 77) | def t_COMMENT(t):
  function t_ID (line 87) | def t_ID(t):
  function t_STRING (line 94) | def t_STRING(t):
  function t_TIMESTAMP (line 101) | def t_TIMESTAMP(t):
  function t_NUMBER (line 108) | def t_NUMBER(t):
  function t_newline (line 116) | def t_newline(t):
  function t_error (line 121) | def t_error(t):

FILE: audiotools/toc/yaccrules.py
  function p_tocfile (line 21) | def p_tocfile(t):
  function p_headers (line 32) | def p_headers(t):
  function p_header (line 42) | def p_header(t):
  function p_header_cd_text (line 57) | def p_header_cd_text(t):
  function p_language_map (line 63) | def p_language_map(t):
  function p_language_mappings (line 70) | def p_language_mappings(t):
  function p_language_mapping (line 80) | def p_language_mapping(t):
  function p_language (line 86) | def p_language(t):
  function p_language_blocks (line 94) | def p_language_blocks(t):
  function p_language_block (line 104) | def p_language_block(t):
  function p_cd_text_items (line 111) | def p_cd_text_items(t):
  function p_cd_text_item (line 121) | def p_cd_text_item(t):
  function p_binary (line 138) | def p_binary(t):
  function p_bytes (line 143) | def p_bytes(t):
  function p_tracks (line 152) | def p_tracks(t):
  function p_track (line 162) | def p_track(t):
  function p_track_mode (line 174) | def p_track_mode(t):
  function p_sub_channel_mode (line 186) | def p_sub_channel_mode(t):
  function p_track_flags (line 192) | def p_track_flags(t):
  function p_track_flag (line 202) | def p_track_flag(t):
  function p_track_cd_text (line 213) | def p_track_cd_text(t):
  function p_track_flag_copy (line 219) | def p_track_flag_copy(t):
  function p_track_flag_no_copy (line 225) | def p_track_flag_no_copy(t):
  function p_track_flag_pre_emphasis (line 231) | def p_track_flag_pre_emphasis(t):
  function p_track_flag_no_pre_emphasis (line 237) | def p_track_flag_no_pre_emphasis(t):
  function p_track_flag_two_channels (line 243) | def p_track_flag_two_channels(t):
  function p_track_flag_four_channels (line 249) | def p_track_flag_four_channels(t):
  function p_track_flag_isrc (line 255) | def p_track_flag_isrc(t):
  function p_track_file (line 261) | def p_track_file(t):
  function p_track_start (line 278) | def p_track_start(t):
  function p_track_index (line 289) | def p_track_index(t):
  function p_start_number (line 296) | def p_start_number(t):
  function p_start_timestamp (line 303) | def p_start_timestamp(t):
  function p_length_number (line 310) | def p_length_number(t):
  function p_length_timestamp (line 317) | def p_length_timestamp(t):
  function p_error (line 324) | def p_error(t):

FILE: audiotools/tta.py
  function div_ceil (line 23) | def div_ceil(n, d):
  class InvalidTTA (line 29) | class InvalidTTA(InvalidFile):
  class TrueAudio (line 33) | class TrueAudio(ApeTaggedAudio, ApeGainedAudio, AudioFile):
    method __init__ (line 40) | def __init__(self, filename):
    method bits_per_sample (line 76) | def bits_per_sample(self):
    method channels (line 81) | def channels(self):
    method channel_mask (line 86) | def channel_mask(self):
    method lossless (line 98) | def lossless(self):
    method total_frames (line 103) | def total_frames(self):
    method sample_rate (line 108) | def sample_rate(self):
    method seekable (line 113) | def seekable(self):
    method supports_to_pcm (line 119) | def supports_to_pcm(cls):
    method to_pcm (line 131) | def to_pcm(self):
    method supports_from_pcm (line 164) | def supports_from_pcm(cls):
    method from_pcm (line 175) | def from_pcm(cls, filename, pcmreader,
    method data_size (line 234) | def data_size(self):
    method supports_metadata (line 243) | def supports_metadata(cls):
    method supports_cuesheet (line 249) | def supports_cuesheet(cls):
    method get_cuesheet (line 252) | def get_cuesheet(self):
    method set_cuesheet (line 279) | def set_cuesheet(self, cuesheet):
    method delete_cuesheet (line 310) | def delete_cuesheet(self):
  function write_header (line 327) | def write_header(writer,
  function write_seektable (line 348) | def write_seektable(writer, frame_sizes):
  class CRC32 (line 359) | class CRC32(object):
    method __init__ (line 425) | def __init__(self):
    method update (line 428) | def update(self, byte):
    method __int__ (line 431) | def __int__(self):

FILE: audiotools/ui.py
  function choice_selection_unicode (line 27) | def choice_selection_unicode(metadata):
  function Screen (line 58) | def Screen():
  class DownEdit (line 64) | class DownEdit(urwid.Edit):
    method __init__ (line 69) | def __init__(self, *args, **kwargs):
    method keypress (line 73) | def keypress(self, size, key):
  class DownIntEdit (line 80) | class DownIntEdit(urwid.IntEdit):
    method __init__ (line 85) | def __init__(self, *args, **kwargs):
    method keypress (line 89) | def keypress(self, size, key):
  class DownCheckBox (line 96) | class DownCheckBox(urwid.CheckBox):
    method keypress (line 101) | def keypress(self, size, key):
  class FocusFrame (line 107) | class FocusFrame(urwid.Frame):
    method __init__ (line 110) | def __init__(self, *args, **kwargs):
    method set_focus_callback (line 115) | def set_focus_callback(self, callback, user_arg=None):
    method set_focus (line 122) | def set_focus(self, part):
  function get_focus (line 130) | def get_focus(widget):
  class OutputFiller (line 138) | class OutputFiller(urwid.Frame):
    method __init__ (line 142) | def __init__(self,
    method page_changed (line 225) | def page_changed(self, new_page):
    method exit (line 233) | def exit(self, button):
    method complete (line 237) | def complete(self, button):
    method cancelled (line 251) | def cancelled(self):
    method handle_text (line 257) | def handle_text(self, i):
    method output_tracks (line 264) | def output_tracks(self):
  class SingleOutputFiller (line 288) | class SingleOutputFiller(urwid.Frame):
    method __init__ (line 292) | def __init__(self,
    method exit (line 369) | def exit(self, button):
    method complete (line 373) | def complete(self, button):
    method cancelled (line 385) | def cancelled(self):
    method handle_text (line 388) | def handle_text(self, i):
    method output_track (line 396) | def output_track(self):
  class MetaDataFiller (line 413) | class MetaDataFiller(urwid.Pile):
    method __init__ (line 416) | def __init__(self, track_labels, metadata_choices, status):
    method select_match (line 489) | def select_match(self, radio, selected, match):
    method swiveled (line 494) | def swiveled(self, radio_button, selected, swivel):
    method select_previous_item (line 514) | def select_previous_item(self):
    method select_next_item (line 520) | def select_next_item(self):
    method populated_metadata (line 526) | def populated_metadata(self):
  class MetaDataEditor (line 533) | class MetaDataEditor(urwid.Frame):
    method __init__ (line 536) | def __init__(self, tracks,
    method activate_swivel (line 692) | def activate_swivel(self, radio_button, selected, swivel):
    method select_previous_item (line 720) | def select_previous_item(self):
    method select_next_item (line 725) | def select_next_item(self):
    method metadata (line 730) | def metadata(self):
  class OrderedRadioButton (line 740) | class OrderedRadioButton(urwid.RadioButton):
    method __init__ (line 741) | def __init__(self, ordered_group, group, label,
    method previous_radio_button (line 752) | def previous_radio_button(self):
    method next_radio_button (line 761) | def next_radio_button(self):
  class LinkedWidgetHeader (line 770) | class LinkedWidgetHeader(urwid.Columns):
    method __init__ (line 771) | def __init__(self, widget):
  class LinkedWidgetDivider (line 777) | class LinkedWidgetDivider(urwid.Columns):
    method __init__ (line 778) | def __init__(self):
  class LinkedWidgets (line 785) | class LinkedWidgets(urwid.Columns):
    method __init__ (line 786) | def __init__(self, checkbox_group, linked_widget, unlinked_widget,
    method swap_link (line 807) | def swap_link(self, checkbox, linked):
    method value (line 836) | def value(self):
  class BaseMetaData (line 860) | class BaseMetaData(object):
    method __init__ (line 861) | def __init__(self, metadata, on_change=None):
  class TrackMetaData (line 887) | class TrackMetaData(object):
    method __init__ (line 890) | def __init__(self, metadata, base_metadata, on_change=None):
    method edited_metadata (line 927) | def edited_metadata(self):
  class Swivel (line 938) | class Swivel(object):
    method __init__ (line 941) | def __init__(self, swivel_type,
    method rows (line 964) | def rows(self):
  function tab_complete (line 969) | def tab_complete(path):
  function tab_complete_file (line 1001) | def tab_complete_file(path):
  function pop_directory (line 1035) | def pop_directory(path):
  function split_at_cursor (line 1049) | def split_at_cursor(edit):
  class SelectButtons (line 1056) | class SelectButtons(urwid.Pile):
    method __init__ (line 1057) | def __init__(self, widget_list, focus_item=None, cancelled=None):
    method keypress (line 1065) | def keypress(self, size, key):
  class BottomLineBox (line 1073) | class BottomLineBox(urwid.LineBox):
    method __init__ (line 1076) | def __init__(self, original_widget, title="",
  class SelectOneDialog (line 1108) | class SelectOneDialog(urwid.WidgetWrap):
    method __init__ (line 1111) | def __init__(self, select_one, items, selected_value,
    method select_button (line 1134) | def select_button(self, button, label_value):
  class SelectOne (line 1139) | class SelectOne(urwid.PopUpLauncher):
    method __init__ (line 1140) | def __init__(self, items, selected_value=None, on_change=None,
    method create_pop_up (line 1180) | def create_pop_up(self):
    method get_pop_up_parameters (line 1191) | def get_pop_up_parameters(self):
    method make_selection (line 1198) | def make_selection(self, label, value):
    method selection (line 1207) | def selection(self):
    method set_items (line 1210) | def set_items(self, items, selected_value):
  class SelectDirectory (line 1216) | class SelectDirectory(urwid.Columns):
    method __init__ (line 1217) | def __init__(self, initial_directory, on_change=None, user_data=None):
    method set_directory (line 1228) | def set_directory(self, directory):
    method get_directory (line 1232) | def get_directory(self):
  class EditDirectory (line 1235) | class EditDirectory(urwid.Edit):
    method __init__ (line 1236) | def __init__(self, initial_directory):
    method keypress (line 1253) | def keypress(self, size, key):
    method set_directory (line 1287) | def set_directory(self, directory):
    method get_directory (line 1296) | def get_directory(self):
  class BrowseDirectory (line 1304) | class BrowseDirectory(urwid.PopUpLauncher):
    method __init__ (line 1305) | def __init__(self, edit_directory):
    method create_pop_up (line 1315) | def create_pop_up(self):
    method get_pop_up_parameters (line 1321) | def get_pop_up_parameters(self):
  class BrowseDirectoryDialog (line 1329) | class BrowseDirectoryDialog(urwid.WidgetWrap):
    method __init__ (line 1332) | def __init__(self, edit_directory):
    method select_directory (line 1360) | def select_directory(self, selected_directory):
  class DirectoryBrowser (line 1364) | class DirectoryBrowser(urwid.TreeListBox):
    method __init__ (line 1365) | def __init__(self, initial_directory,
    method selected_directory (line 1405) | def selected_directory(self):
    method unhandled_input (line 1419) | def unhandled_input(self, size, input):
  class DirectoryWidget (line 1434) | class DirectoryWidget(urwid.TreeWidget):
    method __init__ (line 1437) | def __init__(self, node):
    method keypress (line 1442) | def keypress(self, size, key):
    method get_display_text (line 1450) | def get_display_text(self):
  class ErrorWidget (line 1457) | class ErrorWidget(urwid.TreeWidget):
    method get_display_text (line 1460) | def get_display_text(self):
  class ErrorNode (line 1463) | class ErrorNode(urwid.TreeNode):
    method load_widget (line 1464) | def load_widget(self):
  class DirectoryNode (line 1467) | class DirectoryNode(urwid.ParentNode):
    method __init__ (line 1468) | def __init__(self, path, parent=None):
    method load_parent (line 1485) | def load_parent(self):
    method load_child_keys (line 1493) | def load_child_keys(self):
    method load_child_node (line 1512) | def load_child_node(self, key):
    method load_widget (line 1521) | def load_widget(self):
  class EditFilename (line 1524) | class EditFilename(urwid.Edit):
    method __init__ (line 1525) | def __init__(self, initial_filename):
    method keypress (line 1542) | def keypress(self, size, key):
    method set_filename (line 1576) | def set_filename(self, filename):
    method get_filename (line 1585) | def get_filename(self):
  class BrowseFields (line 1593) | class BrowseFields(urwid.PopUpLauncher):
    method __init__ (line 1594) | def __init__(self, output_format):
    method create_pop_up (line 1603) | def create_pop_up(self):
    method get_pop_up_parameters (line 1609) | def get_pop_up_parameters(self):
  class BrowseFieldsDialog (line 1619) | class BrowseFieldsDialog(urwid.WidgetWrap):
    method __init__ (line 1622) | def __init__(self, output_format):
    method close (line 1637) | def close(self):
  class FieldsList (line 1640) | class FieldsList(urwid.ListBox):
    method __init__ (line 1641) | def __init__(self, output_format, close):
    method select_field (line 1653) | def select_field(self, button, field_value):
    method cancel (line 1658) | def cancel(self):
    method keypress (line 1661) | def keypress(self, size, input):
  class OutputOptions (line 1670) | class OutputOptions(urwid.Pile):
    method __init__ (line 1674) | def __init__(self,
    method select_type (line 1808) | def select_type(self, audio_class, default_quality=None):
    method directory_changed (line 1839) | def directory_changed(self, widget, new_value):
    method format_changed (line 1847) | def format_changed(self, widget, new_value):
    method update_tracks (line 1855) | def update_tracks(self, output_directory=None, filename_format=None):
    method selected_options (line 1929) | def selected_options(self):
    method set_metadatas (line 1939) | def set_metadatas(self, metadatas):
  class SingleOutputOptions (line 1949) | class SingleOutputOptions(urwid.ListBox):
    method __init__ (line 1953) | def __init__(self,
    method set_metadata (line 2018) | def set_metadata(self, metadata):
    method select_type (line 2024) | def select_type(self, audio_class, default_quality=None):
    method selected_options (line 2052) | def selected_options(self):
  class Wizard (line 2060) | class Wizard(urwid.Frame):
    method __init__ (line 2061) | def __init__(self, pages, cancel_button, completion_button,
    method set_page (line 2110) | def set_page(self, button, user_data):
  class MappedButton (line 2116) | class MappedButton(urwid.Button):
    method __init__ (line 2117) | def __init__(self, label, on_press=None, user_data=None,
    method keypress (line 2124) | def keypress(self, size, key):
  class MappedRadioButton (line 2129) | class MappedRadioButton(urwid.RadioButton):
    method __init__ (line 2130) | def __init__(self, group, label, state='first True',
    method keypress (line 2140) | def keypress(self, size, key):
  class AudioProgressBar (line 2145) | class AudioProgressBar(urwid.ProgressBar):
    method __init__ (line 2146) | def __init__(self, normal, complete, sample_rate, current=0, done=100,
    method get_text (line 2156) | def get_text(self):
  class VolumeControl (line 2166) | class VolumeControl(urwid.ProgressBar):
    method __init__ (line 2167) | def __init__(self, get_volume, volume_delta, change_volume):
    method update (line 2183) | def update(self):
    method get_text (line 2186) | def get_text(self):
    method selectable (line 2192) | def selectable(self):
    method get_cursor_coords (line 2195) | def get_cursor_coords(self, size):
    method keypress (line 2198) | def keypress(self, size, key):
    method render (line 2206) | def render(self, size, focus=False):
    method decrease_volume (line 2214) | def decrease_volume(self):
    method increase_volume (line 2217) | def increase_volume(self):
    method update_volume (line 2220) | def update_volume(self, delta):
  class AdjustOutput (line 2223) | class AdjustOutput(urwid.PopUpLauncher):
    method __init__ (line 2224) | def __init__(self, player, volume_control):
    method create_pop_up (line 2237) | def create_pop_up(self):
    method get_pop_up_parameters (line 2249) | def get_pop_up_parameters(self):
  class AdjustOutputWidget (line 2255) | class AdjustOutputWidget(urwid.Pile):
    method __init__ (line 2256) | def __init__(self, player, volume_control, outputs,
    method keypress (line 2285) | def keypress(self, size, key):
    method change_output (line 2293) | def change_output(self, radio_button, new_state, new_output):
  class AdjustOutputDialog (line 2298) | class AdjustOutputDialog(urwid.WidgetWrap):
    method __init__ (line 2301) | def __init__(self, player, volume_control, outputs):
  class PlayerGUI (line 2313) | class PlayerGUI(urwid.Frame):
    method __init__ (line 2314) | def __init__(self, player, tracks, track_len):
    method select_track (line 2461) | def select_track(self, radio_button, new_state, user_data,
    method next_track (line 2467) | def next_track(self, user_data=None):
    method previous_track (line 2478) | def previous_track(self, user_data=None):
    method update_metadata (line 2489) | def update_metadata(self, track_name=None,
    method update_status (line 2547) | def update_status(self):
    method play_pause (line 2559) | def play_pause(self, user_data):
    method stop (line 2571) | def stop(self):
    method handle_text (line 2575) | def handle_text(self, i):
    method perform_exit (line 2585) | def perform_exit(self, *args):
  function timer (line 2589) | def timer(main_loop, playergui):
  function style (line 2597) | def style():
  function show_available_formats (line 2616) | def show_available_formats(msg):
  function show_available_qualities (line 2651) | def show_available_qualities(msg, audiotype):
  function select_metadata (line 2696) | def select_metadata(metadata_choices, msg, use_default=False):
  function process_output_options (line 2730) | def process_output_options(metadata_choices,
  class PlayerTTY (line 2810) | class PlayerTTY(object):
    method __init__ (line 2817) | def __init__(self, player):
    method previous_track (line 2826) | def previous_track(self):
    method next_track (line 2831) | def next_track(self):
    method set_metadata (line 2837) | def set_metadata(self, track_number,
    method toggle_play_pause (line 2848) | def toggle_play_pause(self):
    method stop (line 2851) | def stop(self):
    method run (line 2854) | def run(self, msg, stdin):
    method progress (line 2922) | def progress(self):
    method progress_line (line 2925) | def progress_line(self, frames_sent, frames_total):
  function not_available_message (line 2938) | def not_available_message(msg):
  function xargs_suggestion (line 2950) | def xargs_suggestion(args):

FILE: audiotools/vorbis.py
  class InvalidVorbis (line 21) | class InvalidVorbis(InvalidFile):
  class VorbisAudio (line 25) | class VorbisAudio(AudioFile):
    method __init__ (line 39) | def __init__(self, filename):
    method __read_identification__ (line 50) | def __read_identification__(self):
    method lossless (line 98) | def lossless(self):
    method bits_per_sample (line 103) | def bits_per_sample(self):
    method channels (line 108) | def channels(self):
    method channel_mask (line 113) | def channel_mask(self):
    method total_frames (line 156) | def total_frames(self):
    method sample_rate (line 174) | def sample_rate(self):
    method supports_to_pcm (line 180) | def supports_to_pcm(cls):
    method to_pcm (line 190) | def to_pcm(self):
    method supports_from_pcm (line 206) | def supports_from_pcm(cls):
    method from_pcm (line 217) | def from_pcm(cls, filename, pcmreader,
    method update_metadata (line 278) | def update_metadata(self, metadata):
    method set_metadata (line 362) | def set_metadata(self, metadata):
    method supports_metadata (line 393) | def supports_metadata(cls):
    method get_metadata (line 398) | def get_metadata(self):
    method delete_metadata (line 426) | def delete_metadata(self):
    method supports_replay_gain (line 439) | def supports_replay_gain(cls):
    method get_replay_gain (line 444) | def get_replay_gain(self):
    method set_replay_gain (line 470) | def set_replay_gain(self, replaygain):
    method delete_replay_gain (line 498) | def delete_replay_gain(self):
  class VorbisChannelMask (line 518) | class VorbisChannelMask(ChannelMask):
    method __repr__ (line 521) | def __repr__(self):
    method channels (line 527) | def channels(self):

FILE: audiotools/vorbiscomment.py
  class VorbisComment (line 23) | class VorbisComment(MetaData):
    method __init__ (line 53) | def __init__(self, comment_strings, vendor_string):
    method keys (line 68) | def keys(self):
    method values (line 73) | def values(self):
    method items (line 76) | def items(self):
    method __contains__ (line 79) | def __contains__(self, key):
    method __getitem__ (line 90) | def __getitem__(self, key):
    method __setitem__ (line 106) | def __setitem__(self, key, values):
    method __delitem__ (line 140) | def __delitem__(self, key):
    method __repr__ (line 159) | def __repr__(self):
    method __comment_name__ (line 163) | def __comment_name__(self):
    method raw_info (line 166) | def raw_info(self):
    method __getattr__ (line 200) | def __getattr__(self, attr):
    method __setattr__ (line 272) | def __setattr__(self, attr, value):
    method __delattr__ (line 375) | def __delattr__(self, attr):
    method __eq__ (line 444) | def __eq__(self, metadata):
    method converted (line 451) | def converted(cls, metadata):
    method supports_images (line 493) | def supports_images(cls):
    method images (line 505) | def images(self):
    method clean (line 510) | def clean(self):
    method intersection (line 587) | def intersection(self, metadata):

FILE: audiotools/wav.py
  class RIFF_Chunk (line 25) | class RIFF_Chunk(object):
    method __init__ (line 28) | def __init__(self, chunk_id, chunk_size, chunk_data):
    method __repr__ (line 38) | def __repr__(self):
    method size (line 41) | def size(self):
    method total_size (line 47) | def total_size(self):
    method data (line 56) | def data(self):
    method verify (line 63) | def verify(self):
    method write (line 68) | def write(self, f):
  class RIFF_File_Chunk (line 81) | class RIFF_File_Chunk(RIFF_Chunk):
    method __init__ (line 84) | def __init__(self, chunk_id, chunk_size, wav_file, chunk_data_offset):
    method __del__ (line 97) | def __del__(self):
    method __repr__ (line 100) | def __repr__(self):
    method data (line 103) | def data(self):
    method verify (line 112) | def verify(self):
    method write (line 125) | def write(self, f):
  function pad_data (line 144) | def pad_data(pcm_frames, channels, bits_per_sample):
  function validate_header (line 151) | def validate_header(header):
  function validate_footer (line 237) | def validate_footer(footer, data_bytes_written):
  function parse_fmt (line 286) | def parse_fmt(fmt):
  function wave_header (line 355) | def wave_header(sample_rate,
  class WaveReader (line 426) | class WaveReader(object):
    method __init__ (line 429) | def __init__(self, wave_filename):
    method __enter__ (line 517) | def __enter__(self):
    method __exit__ (line 520) | def __exit__(self, exc_type, exc_value, traceback):
    method read (line 523) | def read(self, pcm_frames):
    method read_closed (line 548) | def read_closed(self, pcm_frames):
    method seek (line 551) | def seek(self, pcm_frame_offset):
    method seek_closed (line 570) | def seek_closed(self, pcm_frame_offset):
    method close (line 573) | def close(self):
  class TempWaveReader (line 581) | class TempWaveReader(WaveReader):
    method __init__ (line 584) | def __init__(self, tempfile):
    method __del__ (line 592) | def __del__(self):
    method close (line 596) | def close(self):
  class InvalidWave (line 602) | class InvalidWave(InvalidFile):
  class WaveAudio (line 608) | class WaveAudio(WaveContainer):
    method __init__ (line 620) | def __init__(self, filename):
    method lossless (line 661) | def lossless(self):
    method has_foreign_wave_chunks (line 666) | def has_foreign_wave_chunks(self):
    method channel_mask (line 676) | def channel_mask(self):
    method supports_to_pcm (line 682) | def supports_to_pcm(cls):
    method to_pcm (line 689) | def to_pcm(self):
    method supports_from_pcm (line 704) | def supports_from_pcm(cls):
    method from_pcm (line 711) | def from_pcm(cls, filename, pcmreader,
    method total_frames (line 790) | def total_frames(self):
    method sample_rate (line 797) | def sample_rate(self):
    method channels (line 802) | def channels(self):
    method bits_per_sample (line 807) | def bits_per_sample(self):
    method seekable (line 812) | def seekable(self):
    method track_name (line 818) | def track_name(cls, file_path, track_metadata=None, format=None):
    method chunks (line 835) | def chunks(self):
    method wave_from_chunks (line 892) | def wave_from_chunks(cls, filename, chunk_iter):
    method wave_header_footer (line 915) | def wave_header_footer(self):
    method from_wave (line 998) | def from_wave(cls, filename, header, pcmreader, footer, compression=No...
    method verify (line 1070) | def verify(self, progress=None):
    method clean (line 1123) | def clean(self, output_filename=None):

FILE: audiotools/wavpack.py
  class InvalidWavPack (line 23) | class InvalidWavPack(InvalidFile):
  function __riff_chunk_ids__ (line 27) | def __riff_chunk_ids__(data_size, data):
  class WavPackAudio (line 47) | class WavPackAudio(ApeTaggedAudio, ApeGainedAudio, WaveContainer):
    method __init__ (line 67) | def __init__(self, filename):
    method lossless (line 81) | def lossless(self):
    method channel_mask (line 86) | def channel_mask(self):
    method supports_metadata (line 92) | def supports_metadata(cls):
    method get_metadata (line 97) | def get_metadata(self):
    method has_foreign_wave_chunks (line 107) | def has_foreign_wave_chunks(self):
    method wave_header_footer (line 125) | def wave_header_footer(self):
    method from_wave (line 150) | def from_wave(cls, filename, header, pcmreader, footer, compression=None,
    method blocks (line 226) | def blocks(self, reader=None):
    method sub_blocks (line 255) | def sub_blocks(self, reader=None):
    method __read_info__ (line 291) | def __read_info__(self):
    method bits_per_sample (line 393) | def bits_per_sample(self):
    method channels (line 398) | def channels(self):
    method total_frames (line 403) | def total_frames(self):
    method sample_rate (line 408) | def sample_rate(self):
    method seekable (line 413) | def seekable(self):
    method supports_from_pcm (line 419) | def supports_from_pcm(cls):
    method from_pcm (line 430) | def from_pcm(cls, filename, pcmreader,
    method supports_to_pcm (line 491) | def supports_to_pcm(cls):
    method to_pcm (line 501) | def to_pcm(self):
    method fmt_chunk (line 516) | def fmt_chunk(self, reader=None):
    method supports_cuesheet (line 543) | def supports_cuesheet(cls):
    method get_cuesheet (line 546) | def get_cuesheet(self):
    method set_cuesheet (line 573) | def set_cuesheet(self, cuesheet):
    method delete_cuesheet (line 603) | def delete_cuesheet(self):

FILE: docs/manpagexml.py
  function subtag (line 29) | def subtag(node, name):
  function subtags (line 35) | def subtags(node, name):
  function text (line 41) | def text(node):
  function man_escape (line 48) | def man_escape(s):
  function write_u (line 53) | def write_u(stream, unicode_string):
  function write_u (line 57) | def write_u(stream, unicode_string):
  class Manpage (line 62) | class Manpage:
    method __init__ (line 85) | def __init__(self,
    method __repr__ (line 125) | def __repr__(self):
    method flatten_options (line 139) | def flatten_options(self):
    method parse_file (line 145) | def parse_file(cls, filename):
    method parse (line 149) | def parse(cls, xml_dom):
    method to_man (line 182) | def to_man(self, stream, page_time=None):
    method format_fields_man (line 240) | def format_fields_man(self, stream):
    method to_html (line 258) | def to_html(self, stream):
  class Options (line 291) | class Options:
    method __init__ (line 292) | def __init__(self, options, category=None):
    method __repr__ (line 296) | def __repr__(self):
    method parse (line 302) | def parse(cls, xml_dom):
    method to_man (line 312) | def to_man(self, stream):
    method to_html (line 321) | def to_html(self, stream):
  class Option (line 337) | class Option:
    method __init__ (line 338) | def __init__(self,
    method __repr__ (line 348) | def __repr__(self):
    method parse (line 356) | def parse(cls, xml_dom):
    method to_man (line 385) | def to_man(self, stream):
    method to_html (line 431) | def to_html(self, stream):
  class Example (line 480) | class Example:
    method __init__ (line 481) | def __init__(self,
    method __repr__ (line 487) | def __repr__(self):
    method parse (line 493) | def parse(cls, xml_dom):
    method to_man (line 497) | def to_man(self, stream):
    method to_html (line 504) | def to_html(self, stream):
  class Command (line 514) | class Command:
    method __init__ (line 515) | def __init__(self, commandline, note=None):
    method __repr__ (line 519) | def __repr__(self):
    method parse (line 524) | def parse(cls, xml_dom):
    method to_man (line 533) | def to_man(self, stream):
    method to_html (line 542) | def to_html(self, stream):
  class Element_P (line 551) | class Element_P:
    method __init__ (line 552) | def __init__(self, contents):
    method __repr__ (line 555) | def __repr__(self):
    method parse (line 559) | def parse(cls, xml_dom):
    method to_man (line 562) | def to_man(self, stream):
    method to_html (line 566) | def to_html(self, stream):
  class Element_UL (line 570) | class Element_UL:
    method __init__ (line 571) | def __init__(self, list_items):
    method __repr__ (line 574) | def __repr__(self):
    method parse (line 578) | def parse(cls, xml_dom):
    method to_man (line 581) | def to_man(self, stream):
    method to_html (line 588) | def to_html(self, stream):
  class Element_TABLE (line 595) | class Element_TABLE:
    method __init__ (line 596) | def __init__(self, rows):
    method __repr__ (line 599) | def __repr__(self):
    method parse (line 603) | def parse(cls, xml_dom):
    method to_man (line 607) | def to_man(self, stream):
    method to_html (line 625) | def to_html(self, stream):
    method calculate_row_spans (line 638) | def calculate_row_spans(self):
    method calculate_span_column (line 655) | def calculate_span_column(self, row_spans):
  class Element_TR (line 676) | class Element_TR:
    method __init__ (line 677) | def __init__(self, columns, tr_class):
    method __repr__ (line 681) | def __repr__(self):
    method parse (line 688) | def parse(cls, xml_dom):
    method to_man (line 704) | def to_man(self, stream):
    method column_widths (line 718) | def column_widths(self):
    method to_html (line 724) | def to_html(self, stream, rowspans):
  class Element_TD (line 732) | class Element_TD:
    method __init__ (line 733) | def __init__(self, value):
    method __repr__ (line 736) | def __repr__(self):
    method parse (line 740) | def parse(cls, xml_dom):
    method empty (line 748) | def empty(self):
    method string (line 751) | def string(self):
    method to_man (line 757) | def to_man(self, stream):
    method width (line 760) | def width(self):
    method to_html (line 766) | def to_html(self, stream, header, rowspan):
  class Element (line 781) | class Element:
    method __init__ (line 786) | def __init__(self, name, elements):
    method __repr__ (line 790) | def __repr__(self):
    method parse (line 794) | def parse(cls, xml_dom):
    method to_man (line 813) | def to_man(self, stream):
    method to_html (line 818) | def to_html(self, stream):

FILE: setup.py
  class SystemLibraries (line 70) | class SystemLibraries(object):
    method __init__ (line 71) | def __init__(self, configfile):
    method guaranteed_present (line 74) | def guaranteed_present(self, library):
    method present (line 95) | def present(self, library):
    method extra_compile_args (line 114) | def extra_compile_args(self, library):
    method extra_link_args (line 139) | def extra_link_args(self, library):
    method executable_present (line 164) | def executable_present(self, executable, *args):
    method lib_version (line 176) | def lib_version(self, library):
  class output_table (line 205) | class output_table(object):
    method __init__ (line 206) | def __init__(self):
    method row (line 211) | def row(self):
    method blank_row (line 218) | def blank_row(self):
    method divider_row (line 223) | def divider_row(self, dividers):
    method total_width (line 230) | def total_width(self):
    method format (line 235) | def format(self):
  class output_table_row (line 254) | class output_table_row(object):
    method __init__ (line 255) | def __init__(self):
    method __len__ (line 260) | def __len__(self):
    method add_column (line 263) | def add_column(self, text, alignment="left"):
    method column_width (line 273) | def column_width(self, column):
    method format (line 276) | def format(self, column_widths):
  class output_table_divider (line 318) | class output_table_divider(object):
    method __init__ (line 321) | def __init__(self, dividers):
    method __len__ (line 324) | def __len__(self):
    method column_width (line 327) | def column_width(self, column):
    method format (line 330) | def format(self, column_widths):
  class output_table_blank (line 340) | class output_table_blank(object):
    method __init__ (line 343) | def __init__(self):
    method column_width (line 346) | def column_width(self, column):
    method format (line 349) | def format(self, column_widths):
  class build_ext (line 355) | class build_ext(_build_ext):
    method build_extensions (line 356) | def build_extensions(self):
  class audiotools_cdio (line 471) | class audiotools_cdio(Extension):
    method __init__ (line 472) | def __init__(self, system_libraries):
    method library_manifest (line 540) | def library_manifest(self):
    method libraries_present (line 544) | def libraries_present(self):
  class audiotools_dvdaudio (line 552) | class audiotools_dvdaudio(Extension):
    method __init__ (line 553) | def __init__(self, system_libraries):
    method library_manifest (line 589) | def library_manifest(self):
    method libraries_present (line 593) | def libraries_present(self):
  class audiotools_pcm (line 601) | class audiotools_pcm(Extension):
    method __init__ (line 602) | def __init__(self):
  class audiotools_pcmconverter (line 610) | class audiotools_pcmconverter(Extension):
    method __init__ (line 611) | def __init__(self):
  class audiotools_replaygain (line 629) | class audiotools_replaygain(Extension):
    method __init__ (line 630) | def __init__(self):
  class audiotools_decoders (line 643) | class audiotools_decoders(Extension):
    method __init__ (line 644) | def __init__(self, system_libraries):
    method library_manifest (line 760) | def library_manifest(self):
  class audiotools_encoders (line 765) | class audiotools_encoders(Extension):
    method __init__ (line 766) | def __init__(self, system_libraries):
    method library_manifest (line 905) | def library_manifest(self):
  class audiotools_bitstream (line 910) | class audiotools_bitstream(Extension):
    method __init__ (line 911) | def __init__(self):
  class audiotools_ogg (line 923) | class audiotools_ogg(Extension):
    method __init__ (line 924) | def __init__(self):
  class audiotools_accuraterip (line 937) | class audiotools_accuraterip(Extension):
    method __init__ (line 938) | def __init__(self):
  class audiotools_output (line 944) | class audiotools_output(Extension):
    method __init__ (line 945) | def __init__(self, system_libraries):
    method library_manifest (line 1014) | def library_manifest(self):

FILE: src/accuraterip.c
  function MOD_INIT (line 38) | MOD_INIT(_accuraterip)
  function PyObject (line 57) | static PyObject*
  function Checksum_init (line 67) | int
  function Checksum_dealloc (line 167) | void
  function unsigned_ (line 179) | static inline unsigned
  function value (line 185) | static inline unsigned
  function PyObject (line 191) | static PyObject*
  function update_frame_v1 (line 242) | static void
  function update_frame_v2 (line 290) | static void
  function PyObject (line 308) | static PyObject*
  function PyObject (line 342) | static PyObject*
  type queue (line 360) | struct queue
  type queue (line 363) | struct queue
  type queue (line 363) | struct queue
  function free_queue (line 371) | static void

FILE: src/accuraterip.h
  type queue (line 24) | struct queue {
  type accuraterip_v1 (line 31) | struct accuraterip_v1 {
  type accuraterip_v2 (line 43) | struct accuraterip_v2 {
  type accuraterip_Checksum (line 53) | typedef struct {
  type accuraterip_v1 (line 85) | struct accuraterip_v1
  type accuraterip_v2 (line 92) | struct accuraterip_v2
  type queue (line 98) | struct queue
  type queue (line 102) | struct queue
  function queue_full (line 104) | static inline int
  function queue_push (line 110) | static inline void
  function queue_pop (line 116) | static inline uint32_t

FILE: src/bitstream-table.c
  type state (line 39) | struct state {
  type state_t (line 46) | typedef uint16_t state_t;
  type state (line 50) | struct state
  type state (line 54) | struct state
  type state (line 57) | struct state
  type state (line 61) | struct state
  type state (line 65) | struct state
  type state (line 70) | struct state
  type state (line 73) | struct state
  type state (line 75) | struct state
  type state (line 77) | struct state
  type state (line 79) | struct state
  type state (line 81) | struct state
  type state (line 83) | struct state
  type state (line 86) | struct state
  type state (line 93) | struct state
  type state (line 100) | struct state
  type state (line 106) | struct state
  type state (line 112) | struct state
  type state (line 119) | struct state
  function main (line 125) | int main(int argc, char *argv[])
  function unpack_state (line 211) | void
  function state_t (line 231) | state_t
  function state_print (line 246) | void
  function last_state (line 260) | int
  function state_value (line 269) | unsigned
  function value_to_unsigned (line 275) | unsigned
  function read_bits_be_func (line 357) | void
  function read_bits_le_func (line 389) | void
  function unread_bit_be_func (line 420) | void
  function unread_bit_le_func (line 441) | void
  function read_unary_be_func (line 464) | void
  function read_unary_le_func (line 506) | void

FILE: src/bitstream.c
  type read_bits (line 36) | struct read_bits {
  type unread_bit (line 42) | struct unread_bit {
  type read_unary (line 47) | struct read_unary {
  type read_bits (line 53) | struct read_bits
  type read_bits (line 57) | struct read_bits
  type read_unary (line 61) | struct read_unary
  type read_unary (line 65) | struct read_unary
  function DEF_SET_ENDIANNESS (line 108) | DEF_READ_BIGINT(br_read_bits_bigint_f_be)
  function br_buf_free (line 700) | static inline void
  function br_buf_size (line 707) | static inline unsigned
  function br_buf_extend (line 714) | static void
  function br_buf_getc (line 724) | static inline int
  function br_buf_read (line 737) | static unsigned
  type br_buffer (line 749) | struct br_buffer
  type br_queue (line 757) | struct br_queue {
  type br_queue (line 765) | struct br_queue
  type br_queue (line 768) | struct br_queue
  type br_queue (line 768) | struct br_queue
  function br_queue_free (line 777) | static inline void
  function br_queue_getc (line 784) | static inline int
  function br_queue_read (line 794) | static unsigned
  type br_queue (line 806) | struct br_queue
  function br_queue_size (line 809) | static inline unsigned
  function br_queue_available_size (line 816) | static inline unsigned
  function br_queue_resize_for (line 823) | static void
  type br_queue (line 851) | struct br_queue
  type bw_buffer (line 861) | struct bw_buffer {
  type bw_buffer (line 869) | struct bw_buffer
  type bw_buffer (line 872) | struct bw_buffer
  type bw_buffer (line 872) | struct bw_buffer
  function bw_buf_free (line 887) | static inline void
  function bw_buf_putc (line 894) | static inline int
  function bw_buf_write (line 910) | static int
  function bw_buf_getpos (line 928) | static inline void
  function bw_buf_setpos (line 936) | static inline int
  function bw_buf_fseek (line 948) | static int
  function bw_buf_size (line 995) | static inline unsigned
  function bw_buf_reset (line 1000) | static inline void
  function BitstreamReader (line 1008) | static BitstreamReader*
  function BitstreamReader (line 1078) | BitstreamReader*
  function BitstreamReader (line 1121) | BitstreamReader*
  function BitstreamQueue (line 1166) | BitstreamQueue*
  function BitstreamReader (line 1239) | BitstreamReader*
  function br_read_bits_c (line 1409) | static unsigned int
  function br_read_bits64_c (line 1416) | static uint64_t
  function br_read_signed_bits_be (line 1423) | static int
  function br_read_signed_bits_le (line 1433) | static int
  function br_read_signed_bits64_be (line 1445) | static int64_t
  function br_read_signed_bits64_le (line 1455) | static int64_t
  function br_read_bits_bigint_c (line 1573) | static void
  function br_read_signed_bits_bigint_be (line 1581) | static void
  function br_read_signed_bits_bigint_le (line 1623) | static void
  function br_skip_bits_c (line 1759) | static void
  function br_unread_bit_be (line 1766) | static void
  function br_unread_bit_le (line 1780) | static void
  function br_unread_bit_c (line 1794) | static void
  function br_read_unary_c (line 1850) | static unsigned int
  function br_skip_unary_c (line 1900) | static void
  function __br_set_endianness__ (line 1907) | static void
  function br_set_endianness_f (line 1928) | static void
  function br_set_endianness_b (line 1952) | static void
  function br_set_endianness_q (line 1976) | static void
  function br_set_endianness_e (line 2000) | static void
  function br_set_endianness_c (line 2024) | static void
  function br_read_huffman_code_c (line 2064) | static int
  function br_read_bytes_file (line 2073) | static void
  type bs_callback (line 2119) | struct bs_callback
  function br_read_bytes_c (line 2146) | static void
  function br_skip_bytes (line 2155) | static void
  function br_parse (line 2168) | static void
  function br_byte_aligned (line 2255) | static int
  function br_byte_align (line 2262) | static void
  function br_pos_t (line 2272) | static br_pos_t*
  function br_pos_t (line 2283) | static br_pos_t*
  function br_pos_t (line 2294) | static br_pos_t*
  function br_pos_t (line 2311) | static br_pos_t*
  function br_pos_t (line 2337) | static br_pos_t*
  function br_setpos_file (line 2345) | static void
  function br_setpos_b (line 2353) | static void
  function br_setpos_q (line 2361) | static void
  function br_setpos_e (line 2369) | static void
  function br_setpos_c (line 2386) | static void
  function br_pos_del_f (line 2393) | static void
  function br_pos_del_b (line 2399) | static void
  function br_pos_del_q (line 2405) | static void
  function br_pos_del_e (line 2413) | static void
  function br_size_f_e_c (line 2435) | static unsigned
  function br_size_b (line 2441) | static unsigned
  function br_size_q (line 2447) | static unsigned
  function BitstreamReader (line 2454) | static BitstreamReader*
  function br_enqueue (line 2484) | static void
  function br_close_methods (line 2502) | static void
  function br_close_internal_stream_f (line 2526) | static void
  function br_close_internal_stream_b (line 2536) | static void
  function br_close_internal_stream_q (line 2543) | static void
  function br_close_internal_stream_e (line 2550) | static void
  function br_close_internal_stream_c (line 2561) | static void
  function br_free_f (line 2568) | static void
  function br_free_b (line 2600) | static void
  function br_free_q (line 2610) | static void
  function br_free_e (line 2645) | static void
  function br_close (line 2656) | static void
  function br_close_q (line 2663) | static void
  function br_push_q (line 2670) | static void
  function br_reset_q (line 2680) | static void
  function __br_abort__ (line 2694) | void
  function br_abort (line 2705) | void
  function jmp_buf (line 2717) | jmp_buf*
  function __br_etry (line 2733) | void
  function BitstreamWriter (line 2749) | BitstreamWriter*
  function BitstreamWriter (line 2808) | BitstreamWriter*
  function BitstreamRecorder (line 2885) | BitstreamRecorder*
  function BitstreamRecorder (line 2892) | BitstreamRecorder*
  function BitstreamRecorder (line 2947) | BitstreamRecorder*
  function BitstreamRecorder (line 2954) | BitstreamRecorder*
  function BitstreamAccumulator (line 3019) | BitstreamAccumulator*
  function BitstreamAccumulator (line 3067) | BitstreamAccumulator*
  type bs_callback (line 3146) | struct bs_callback
  type bs_callback (line 3193) | struct bs_callback
  function bw_write_bits_c (line 3231) | static void
  function bw_write_signed_bits_c (line 3239) | static void
  function bw_write_signed_bits_be (line 3247) | static void
  function bw_write_signed_bits_le (line 3261) | static void
  function bw_write_bits64_c (line 3288) | static void
  function bw_write_signed_bits64_c (line 3296) | static void
  function bw_write_signed_bits64_be (line 3305) | static void
  function bw_write_signed_bits64_le (line 3319) | static void
  type bs_callback (line 3367) | struct bs_callback
  type bs_callback (line 3447) | struct bs_callback
  function bw_write_bits_bigint_c (line 3486) | static void
  function bw_write_signed_bits_bigint_be (line 3494) | static void
  function bw_write_signed_bits_bigint_le (line 3534) | static void
  function bw_write_bits_a (line 3574) | static void
  function bw_write_signed_bits_a (line 3580) | static void
  function bw_write_bits64_a (line 3586) | static void
  function bw_write_signed_bits64_a (line 3592) | static void
  function bw_write_bits_bigint_a (line 3599) | static void
  function bw_write_signed_bits_bigint_a (line 3607) | static void
  function bw_write_bytes_a (line 3615) | static void
  function bw_write_bits_la (line 3623) | static void
  function bw_write_signed_bits_la (line 3632) | static void
  function bw_write_bits64_la (line 3642) | static void
  function bw_write_signed_bits64_la (line 3651) | static void
  function bw_write_bits_bigint_la (line 3661) | static void
  function bw_write_signed_bits_bigint_la (line 3672) | static void
  function bw_write_bytes_la (line 3683) | static void
  function bw_write_unary (line 3696) | static void
  function bw_write_unary_a (line 3714) | static void
  function bw_write_unary_la (line 3720) | static void
  function __bw_set_endianness__ (line 3731) | static void
  function bw_set_endianness_f (line 3751) | static void
  function bw_set_endianness_e (line 3769) | static void
  function bw_set_endianness_sr (line 3787) | static void
  function bw_set_endianness_a (line 3805) | static void
  function bw_set_endianness_c (line 3811) | static void
  function bw_write_huffman (line 3818) | static int
  function bw_write_bytes_file (line 3843) | static void
  function bw_write_bytes_e (line 3876) | static void
  function bw_write_bytes_sr (line 3910) | static void
  function bw_write_bytes_c (line 3944) | static void
  function bw_build (line 3953) | static void
  function bw_byte_aligned (line 4046) | static int
  function bw_byte_aligned_a (line 4052) | static int
  function bw_byte_aligned_la (line 4058) | static int
  function bw_byte_align (line 4064) | static void
  function bw_byte_align_a (line 4073) | static void
  function bw_flush_f (line 4081) | static void
  function bw_flush_noop (line 4087) | static void
  function bw_flush_e (line 4095) | static void
  function bw_pos_t (line 4103) | static bw_pos_t*
  function bw_pos_t (line 4117) | static bw_pos_t*
  function bw_pos_t (line 4139) | static bw_pos_t*
  function bw_pos_t (line 4153) | static bw_pos_t*
  function bw_setpos_file (line 4161) | static void
  function bw_setpos_e (line 4170) | static void
  function bw_setpos_sr (line 4183) | static void
  function bw_setpos_c (line 4197) | static void
  function bw_seek_file (line 4203) | static void
  function bw_seek_e (line 4213) | static void
  function bw_seek_sr (line 4225) | static void
  function bw_seek_c (line 4237) | static void
  function bw_pos_del_f (line 4244) | static void
  function bw_pos_del_e (line 4250) | static void
  function bw_pos_del_sr (line 4257) | static void
  function bw_close_methods (line 4264) | static void
  function bw_close_internal_stream_f (line 4283) | static void
  function bw_close_internal_stream_cf (line 4295) | static void
  function bw_close_internal_stream_e (line 4301) | static void
  function bw_free_f (line 4314) | static void
  function bw_free_e (line 4346) | static void
  function bw_free_sr (line 4357) | static void
  function bw_close_f_e (line 4392) | static void
  function bw_bits_written_sr (line 4399) | static unsigned int
  function bw_bytes_written_sr (line 4406) | static unsigned int
  function bw_reset_sr (line 4412) | static void
  function bw_write_bits_r (line 4420) | static void
  function playback_write_bits (line 4439) | static void
  function bw_write_signed_bits_r (line 4446) | static void
  function playback_write_signed_bits (line 4465) | static void
  function bw_write_bits64_r (line 4474) | static void
  function playback_write_64 (line 4493) | static void
  function bw_write_signed_bits64_r (line 4502) | static void
  function playback_write_signed_64 (line 4521) | static void
  function bw_write_bits_bigint_r (line 4530) | static void
  function playback_write_bigint (line 4549) | static void
  function reset_write_bigint (line 4558) | static void
  function bw_write_signed_bits_bigint_r (line 4564) | static void
  function playback_write_signed_bigint (line 4583) | static void
  function reset_write_signed_bigint (line 4592) | static void
  function bw_write_unary_r (line 4598) | static void
  function bw_write_unary_c (line 4617) | static void
  function playback_write_unary (line 4625) | static void
  function bw_write_bytes_r (line 4634) | static void
  function playback_write_bytes (line 4656) | static void
  function reset_write_bytes (line 4665) | static void
  function bw_set_endianness_r (line 4671) | static void
  function playback_set_endianness (line 4680) | static void
  function bw_bits_written_r (line 4687) | static unsigned
  function bw_bytes_written_r (line 4693) | static unsigned
  function bw_byte_align_r (line 4699) | static void
  function bw_byte_aligned_r (line 4707) | static int
  function bw_reset_r (line 4713) | static void
  function bw_copy_sr (line 4725) | static void
  function bw_copy_r (line 4741) | static void
  function bw_close_r (line 4753) | static void
  function bw_free_r (line 4760) | static void
  function bw_data_sr (line 4793) | static void
  function bw_data_r (line 4801) | static void
  function bw_bits_written_a (line 4810) | static unsigned int
  function bw_bytes_written_a (line 4816) | static unsigned int
  function bw_reset_a (line 4822) | static void
  function bw_bits_written_la (line 4830) | static unsigned int
  function bw_reset_la (line 4836) | static void
  function bw_free_a (line 4844) | static void
  function bw_close_internal_stream_r (line 4873) | static void
  function bw_close_internal_stream_a (line 4879) | static void
  function bw_close_a (line 4885) | static void
  function bw_abort (line 4892) | void
  function jmp_buf (line 4904) | jmp_buf*
  function __bw_etry (line 4920) | void
  function recorder_swap (line 4936) | void
  function bs_format_size (line 5033) | unsigned
  function bs_format_byte_size (line 5069) | unsigned
  function byte_counter (line 5075) | void
  type BitstreamRecorderEntry (line 5081) | struct BitstreamRecorderEntry
  type BitstreamRecorderEntry (line 5088) | struct BitstreamRecorderEntry
  type BitstreamRecorderEntry (line 5098) | struct BitstreamRecorderEntry
  function reset_noop (line 5107) | static void
  type bw_pos_stack (line 5235) | struct bw_pos_stack
  type bw_pos_stack (line 5235) | struct bw_pos_stack
  type bw_pos_stack (line 5244) | struct bw_pos_stack
  type align_check (line 5662) | typedef struct {
  function main (line 5683) | int main(int argc, char* argv[]) {
  function atexit_cleanup (line 5989) | void atexit_cleanup(void) {
  function sigabort_cleanup (line 5993) | void sigabort_cleanup(int signum) {
  function test_big_endian_reader (line 5997) | void test_big_endian_reader(BitstreamReader* reader,
  function test_big_endian_parse (line 6307) | void test_big_endian_parse(BitstreamReader* reader) {
  function test_little_endian_reader (line 6452) | void test_little_endian_reader(BitstreamReader* reader,
  function test_little_endian_parse (line 6759) | void test_little_endian_parse(BitstreamReader* reader) {
  function test_close_errors (line 6904) | void
  function test_try (line 7041) | void test_try(BitstreamReader* reader,
  function test_callbacks_reader (line 7158) | void test_callbacks_reader(BitstreamReader* reader,
  function test_writer (line 7276) | void
  function writer_perform_write_64 (line 7770) | void
  function writer_perform_write_signed_64 (line 7800) | void
  function writer_perform_write_bigint (line 7832) | void
  function writer_perform_write_signed_bigint (line 7876) | void
  function writer_perform_write_unary_0 (line 7923) | void
  function writer_perform_write_unary_1 (line 7968) | void
  function writer_perform_build_u (line 8019) | void
  function writer_perform_build_U (line 8035) | void
  function writer_perform_build_K (line 8050) | void
  function writer_perform_build_s (line 8084) | void
  function writer_perform_build_S (line 8100) | void
  function writer_perform_build_L (line 8115) | void
  function writer_perform_build_b (line 8149) | void
  function writer_perform_build_mult (line 8158) | void
  function writer_perform_huffman (line 8175) | void
  function writer_perform_write_bytes (line 8236) | void
  function check_output_file (line 8243) | void
  function check_alignment_f (line 8256) | void check_alignment_f(const align_check* check,
  function check_alignment_r (line 8277) | void check_alignment_r(const align_check* check,
  function check_alignment_e (line 8302) | void check_alignment_e(const align_check* check,
  function test_edge_cases (line 8334) | void test_edge_cases(void) {
  function test_edge_reader_be (line 8401) | void
  function test_edge_reader_le (line 8479) | void
  function validate_edge_writer_be (line 8656) | void
  function validate_edge_recorder_be (line 8676) | void
  function BitstreamWriter (line 8703) | BitstreamWriter*
  function BitstreamRecorder (line 8708) | BitstreamRecorder*
  function validate_edge_writer_le (line 8715) | void
  function validate_edge_recorder_le (line 8734) | void
  function test_rec_copy_dumps (line 8758) | void
  function ext_fread_test (line 8802) | unsigned ext_fread_test(void* user_data,
  function ext_fclose_test (line 8811) | int ext_fclose_test(void* user_data)
  function ext_ffree_test (line 8817) | void ext_ffree_test(void* user_data)
  function ext_fwrite_test (line 8822) | int ext_fwrite_test(void* user_data,
  function ext_fflush_test (line 8838) | int ext_fflush_test(void* user_data)
  function ext_fsetpos_test (line 8844) | int ext_fsetpos_test(void *user_data, void *pos)
  function ext_fseek_test (line 8867) | int ext_fseek_test(void *user_data, long location, int whence)
  function ext_free_pos_test (line 8873) | void ext_free_pos_test(void *pos)
  function func_add_one (line 8878) | void func_add_one(uint8_t byte, int* value)
  function func_add_two (line 8883) | void func_add_two(uint8_t byte, int* value)
  function func_mult_three (line 8888) | void func_mult_three(uint8_t byte, int* value)
  function test_writer_marks (line 8893) | void
  function test_writer_seeks (line 8909) | void

FILE: src/bitstream.h
  type state_t (line 56) | typedef uint16_t state_t;
  type bs_endianness (line 58) | typedef enum {BS_BIG_ENDIAN, BS_LITTLE_ENDIAN} bs_endianness;
  type br_type (line 59) | typedef enum {BR_FILE, BR_BUFFER, BR_QUEUE, BR_EXTERNAL} br_type;
  type bw_type (line 60) | typedef enum {BW_FILE,
  type bs_instruction_t (line 66) | typedef enum {BS_INST_UNSIGNED,
  type bs_whence (line 77) | typedef enum {BS_SEEK_SET=0,
  type bs_callback (line 85) | struct bs_callback {
  type bs_exception (line 93) | struct bs_exception {
  type BitstreamReader_s (line 98) | struct BitstreamReader_s
  type BitstreamQueue_s (line 99) | struct BitstreamQueue_s
  type br_buffer (line 100) | struct br_buffer
  type br_queue (line 101) | struct br_queue
  type br_pos_t (line 104) | typedef struct br_pos_s {
  type br_huffman_entry_t (line 139) | typedef struct {
  type br_huffman_entry_t (line 148) | typedef br_huffman_entry_t br_huffman_table_t[0x200];
  type BitstreamReader_s (line 161) | struct BitstreamReader_s
  type BitstreamReader_s (line 166) | struct BitstreamReader_s
  type BitstreamReader_s (line 171) | struct BitstreamReader_s
  type BitstreamReader_s (line 176) | struct BitstreamReader_s
  type BitstreamReader_s (line 182) | struct BitstreamReader_s
  type BitstreamReader_s (line 190) | struct BitstreamReader_s
  type BitstreamReader_s (line 197) | struct BitstreamReader_s
  type BitstreamReader_s (line 211) | struct BitstreamReader_s
  type BitstreamReader_s (line 216) | struct BitstreamReader_s
  type BitstreamReader_s (line 221) | struct BitstreamReader_s
  type BitstreamReader_s (line 226) | struct BitstreamReader_s
  type BitstreamReader_s (line 237) | struct BitstreamReader_s
  type BitstreamReader_s (line 244) | struct BitstreamReader_s
  type br_pos_t (line 250) | typedef br_pos_t*
  type BitstreamReader_s (line 257) | struct BitstreamReader_s
  type BitstreamReader_s (line 264) | struct BitstreamReader_s
  type BitstreamReader_s (line 303) | struct BitstreamReader_s
  type BitstreamReader_s (line 347) | struct BitstreamReader_s
  type BitstreamReader_s (line 351) | struct BitstreamReader_s
  type BitstreamReader_s (line 355) | struct BitstreamReader_s
  type BitstreamReader_s (line 360) | struct BitstreamReader_s
  type BitstreamReader_s (line 368) | struct BitstreamReader_s
  type bs_callback (line 369) | struct bs_callback
  type BitstreamReader_s (line 375) | struct BitstreamReader_s
  type bs_callback (line 376) | struct bs_callback
  type BitstreamReader_s (line 381) | struct BitstreamReader_s
  type BitstreamReader_s (line 396) | struct BitstreamReader_s
  type BitstreamReader_s (line 397) | struct BitstreamReader_s
  type BitstreamReader_s (line 405) | struct BitstreamReader_s
  type BitstreamQueue_s (line 407) | struct BitstreamQueue_s
  type BitstreamReader (line 409) | typedef struct BitstreamReader_s {
  type BitstreamQueue (line 453) | typedef struct BitstreamQueue_s {
  type bw_huffman_table_t (line 615) | typedef struct {
  type BitstreamWriter_s (line 625) | struct BitstreamWriter_s
  type recorder_buffer (line 626) | struct recorder_buffer
  type bw_pos_t (line 629) | typedef struct bw_pos_s {
  type bw_pos_stack (line 649) | struct bw_pos_stack {
  type BitstreamWriter_s (line 656) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 662) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 668) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 674) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 680) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 685) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 692) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 700) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 706) | struct BitstreamWriter_s
  type bw_pos_t (line 713) | typedef bw_pos_t*
  type BitstreamWriter_s (line 721) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 736) | struct BitstreamWriter_s
  type BitstreamRecorderEntry (line 740) | struct BitstreamRecorderEntry
  type BitstreamWriter_s (line 790) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 832) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 837) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 842) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 846) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 851) | struct BitstreamWriter_s
  type BitstreamWriter_s (line 859) | struct BitstreamWriter_s
  type bs_callback (line 860) | struct bs_callback
  type BitstreamWriter_s (line 866) | struct BitstreamWriter_s
  type bs_callback (line 867) | struct bs_callback
  type BitstreamWriter_s (line 872) | struct BitstreamWriter_s
  type BitstreamWriter (line 879) | typedef struct BitstreamWriter_s {
  type BitstreamRecorder (line 907) | typedef struct BitstreamRecorder_s {
  type BitstreamAccumulator (line 952) | typedef struct BitstreamAccumulator_s {
  type bw_pos_stack (line 1138) | struct bw_pos_stack
  type bw_pos_stack (line 1141) | struct bw_pos_stack

FILE: src/buffer.c
  type bs_buffer (line 32) | struct bs_buffer
  type bs_buffer (line 35) | struct bs_buffer
  type bs_buffer (line 35) | struct bs_buffer
  function buf_close (line 43) | void
  function buf_resize (line 50) | void
  function buf_read (line 74) | unsigned
  function buf_skip (line 83) | unsigned
  function buf_write (line 91) | void

FILE: src/buffer.h
  type bs_buffer (line 39) | struct bs_buffer {
  type buf_size_t (line 46) | typedef unsigned buf_size_t;
  type buf_pos_t (line 47) | typedef unsigned buf_pos_t;
  type bs_buffer (line 52) | struct bs_buffer
  type bs_buffer (line 57) | struct bs_buffer
  function buf_window_size (line 60) | static inline unsigned
  function buf_unused_size (line 68) | static inline unsigned
  type bs_buffer (line 77) | struct bs_buffer
  type bs_buffer (line 85) | struct bs_buffer
  type bs_buffer (line 94) | struct bs_buffer
  function buf_reset (line 98) | static inline void
  function buf_getc (line 110) | static inline int
  function buf_putc (line 121) | static inline int
  type bs_buffer (line 140) | struct bs_buffer
  type bs_buffer (line 146) | struct bs_buffer
  type bs_buffer (line 152) | struct bs_buffer
  function buf_extend (line 155) | static inline void

FILE: src/cdiomodule.c
  function MOD_INIT (line 44) | MOD_INIT(cdio)
  function PyObject (line 60) | static PyObject*
  function CDDAReader_init (line 70) | static int
  function CDDAReader_init_image (line 125) | static int
  function CDDAReader_init_device (line 160) | static int
  function CDDAReader_dealloc (line 202) | static void
  function CDDAReader_dealloc_image (line 212) | static void
  function CDDAReader_dealloc_device (line 220) | static void
  function PyObject (line 231) | static PyObject*
  function PyObject (line 238) | static PyObject*
  function PyObject (line 245) | static PyObject*
  function PyObject (line 252) | static PyObject*
  function PyObject (line 259) | static PyObject*
  function CDDAReader_first_track_num_image (line 265) | static int
  function CDDAReader_first_track_num_device (line 271) | static int
  function CDDAReader_last_track_num_image (line 278) | static int
  function CDDAReader_last_track_num_device (line 284) | static int
  function CDDAReader_track_lsn_image (line 291) | static int
  function CDDAReader_track_lsn_device (line 299) | static int
  function CDDAReader_track_last_lsn_image (line 307) | static int
  function CDDAReader_track_last_lsn_device (line 315) | static int
  function PyObject (line 323) | static PyObject*
  function PyObject (line 361) | static PyObject*
  function PyObject (line 400) | static PyObject*
  function CDDAReader_first_sector_image (line 407) | static int
  function CDDAReader_first_sector_device (line 414) | static int
  function PyObject (line 421) | static PyObject*
  function CDDAReader_last_sector_image (line 428) | static int
  function CDDAReader_last_sector_device (line 435) | static int
  function PyObject (line 442) | static PyObject*
  function CDDAReader_read_image (line 495) | static int
  function CDDAReader_read_device (line 524) | static int
  function PyObject (line 560) | static PyObject*
  function CDDAReader_seek_image (line 587) | static unsigned
  function CDDAReader_seek_device (line 595) | static unsigned
  function PyObject (line 607) | static PyObject*
  function PyObject (line 616) | static PyObject*
  function CDDAReader_set_speed_image (line 630) | static void
  function CDDAReader_set_speed_device (line 636) | static void
  function cddareader_callback (line 642) | static void
  function cddareader_reset_log (line 692) | static void
  function cddareader_set_log_item (line 710) | static int
  function PyObject (line 727) | static PyObject*
  function PyObject (line 770) | static PyObject*

FILE: src/cdiomodule.h
  type cdio_log (line 37) | struct cdio_log {
  type cdio_log (line 55) | struct cdio_log
  type cdio_CDDAReader (line 61) | typedef struct cdio_CDDAReader_s {
  type cdio_log (line 246) | struct cdio_log

FILE: src/common/flac_crc.c
  function flac_crc8 (line 22) | void
  function flac_crc16 (line 62) | void

FILE: src/common/m4a_atoms.c
  type qt_atom (line 28) | struct qt_atom
  function set_atom_name (line 90) | static inline void
  type qt_atom_list (line 102) | struct qt_atom_list
  type qt_atom_list (line 103) | struct qt_atom_list
  type qt_atom (line 103) | struct qt_atom
  type qt_atom_list (line 106) | struct qt_atom_list
  type qt_atom_list (line 109) | struct qt_atom_list
  type qt_atom (line 115) | struct qt_atom
  type field_type_t (line 117) | typedef enum {
  type qt_atom (line 149) | struct qt_atom
  type qt_atom (line 154) | struct qt_atom
  type qt_atom (line 154) | struct qt_atom
  type qt_atom (line 168) | struct qt_atom
  type qt_atom (line 173) | struct qt_atom
  type qt_atom (line 173) | struct qt_atom
  type qt_atom (line 182) | struct qt_atom
  type qt_atom (line 195) | struct qt_atom
  type qt_atom (line 201) | struct qt_atom
  type qt_atom (line 201) | struct qt_atom
  type qt_atom (line 224) | struct qt_atom
  type qt_atom (line 227) | struct qt_atom
  type qt_atom (line 227) | struct qt_atom
  type qt_atom (line 240) | struct qt_atom
  type qt_atom (line 256) | struct qt_atom
  type qt_atom (line 256) | struct qt_atom
  type qt_atom (line 281) | struct qt_atom
  type qt_atom (line 295) | struct qt_atom
  type qt_atom (line 295) | struct qt_atom
  type qt_atom (line 318) | struct qt_atom
  type qt_atom (line 328) | struct qt_atom
  type qt_atom (line 328) | struct qt_atom
  type qt_atom (line 347) | struct qt_atom
  type qt_atom (line 358) | struct qt_atom
  type qt_atom (line 358) | struct qt_atom
  type qt_atom (line 379) | struct qt_atom
  type qt_atom (line 384) | struct qt_atom
  type qt_atom (line 384) | struct qt_atom
  type qt_atom (line 398) | struct qt_atom
  type qt_atom (line 404) | struct qt_atom
  type qt_atom (line 404) | struct qt_atom
  type qt_atom (line 415) | struct qt_atom
  type qt_atom (line 430) | struct qt_atom
  type qt_atom (line 436) | struct qt_atom
  type qt_atom (line 436) | struct qt_atom
  type qt_atom (line 447) | struct qt_atom
  type qt_atom (line 462) | struct qt_atom
  type qt_atom (line 472) | struct qt_atom
  type qt_atom (line 474) | struct qt_atom
  type qt_atom (line 474) | struct qt_atom
  type qt_atom (line 495) | struct qt_atom
  type qt_atom (line 507) | struct qt_atom
  type qt_atom (line 507) | struct qt_atom
  type qt_atom (line 528) | struct qt_atom
  type qt_atom (line 531) | struct qt_atom
  type qt_atom (line 531) | struct qt_atom
  function qt_stts_add_time (line 546) | void
  type qt_atom (line 572) | struct qt_atom
  type qt_atom (line 575) | struct qt_atom
  type qt_atom (line 575) | struct qt_atom
  function qt_stsc_add_chunk_size (line 590) | void
  type qt_atom (line 607) | struct qt_atom
  type qt_atom (line 612) | struct qt_atom
  type qt_atom (line 612) | struct qt_atom
  function qt_stsz_add_size (line 628) | void
  type qt_atom (line 642) | struct qt_atom
  type qt_atom (line 646) | struct qt_atom
  type qt_atom (line 646) | struct qt_atom
  function qt_stco_add_offset (line 661) | void
  type qt_atom (line 673) | struct qt_atom
  type qt_atom (line 679) | struct qt_atom
  type qt_atom (line 679) | struct qt_atom
  type qt_atom (line 690) | struct qt_atom
  type qt_atom (line 704) | struct qt_atom
  type qt_atom (line 707) | struct qt_atom
  type qt_atom (line 707) | struct qt_atom
  type qt_atom (line 722) | struct qt_atom
  type qt_atom (line 735) | struct qt_atom
  type qt_atom (line 740) | struct qt_atom
  function qt_time_t (line 752) | qt_time_t
  function build_header (line 769) | static void
  function display_indent (line 776) | static void
  function display_name (line 784) | static void
  type qt_atom_list (line 797) | struct qt_atom_list
  type qt_atom_list (line 798) | struct qt_atom_list
  type qt_atom (line 798) | struct qt_atom
  type qt_atom_list (line 804) | struct qt_atom_list
  type qt_atom_list (line 804) | struct qt_atom_list
  function atom_list_len (line 811) | static unsigned
  function atom_list_free (line 821) | static void
  function display_leaf (line 833) | static void
  type qt_atom (line 843) | struct qt_atom
  type qt_atom (line 848) | struct qt_atom
  function build_leaf (line 866) | static void
  function size_leaf (line 874) | static unsigned
  type qt_atom (line 880) | struct qt_atom
  type qt_atom (line 881) | struct qt_atom
  function free_leaf (line 891) | static void
  function display_tree (line 900) | static void
  type qt_atom (line 914) | struct qt_atom
  type qt_atom (line 919) | struct qt_atom
  type qt_atom (line 923) | struct qt_atom
  function build_tree (line 938) | static void
  function size_tree (line 949) | static unsigned
  type qt_atom (line 960) | struct qt_atom
  type qt_atom (line 961) | struct qt_atom
  type qt_atom_list (line 964) | struct qt_atom_list
  function free_tree (line 981) | static void
  function display_ftyp (line 990) | static void
  type qt_atom (line 1015) | struct qt_atom
  type qt_atom (line 1020) | struct qt_atom
  function build_ftyp (line 1047) | static void
  function size_ftyp (line 1061) | static unsigned
  function free_ftyp (line 1067) | static void
  function display_mvhd (line 1080) | static void
  type qt_atom (line 1104) | struct qt_atom
  function build_mvhd (line 1172) | static void
  function size_mvhd (line 1210) | static unsigned
  function free_mvhd (line 1220) | static void
  function display_tkhd (line 1228) | static void
  type qt_atom (line 1249) | struct qt_atom
  function build_tkhd (line 1313) | static void
  function size_tkhd (line 1352) | static unsigned
  function free_tkhd (line 1362) | static void
  function display_mdhd (line 1370) | static void
  type qt_atom (line 1387) | struct qt_atom
  function build_mdhd (line 1431) | static void
  function size_mdhd (line 1461) | static unsigned
  function free_mdhd (line 1471) | static void
  function display_hdlr (line 1479) | static void
  type qt_atom (line 1497) | struct qt_atom
  type qt_atom (line 1511) | struct qt_atom
  function build_hdlr (line 1546) | static void
  function size_hdlr (line 1563) | static unsigned
  function free_hdlr (line 1569) | static void
  function display_smhd (line 1578) | static void
  type qt_atom (line 1590) | struct qt_atom
  function build_smhd (line 1602) | static void
  function size_smhd (line 1613) | static unsigned
  function free_smhd (line 1619) | static void
  function display_dref (line 1627) | static void
  type qt_atom (line 1645) | struct qt_atom
  type qt_atom (line 1653) | struct qt_atom
  type qt_atom (line 1656) | struct qt_atom
  function build_dref (line 1670) | static void
  function size_dref (line 1688) | static unsigned
  type qt_atom (line 1701) | struct qt_atom
  type qt_atom (line 1702) | struct qt_atom
  type qt_atom_list (line 1705) | struct qt_atom_list
  function free_dref (line 1724) | static void
  function display_stsd (line 1733) | static void
  type qt_atom (line 1752) | struct qt_atom
  type qt_atom (line 1760) | struct qt_atom
  type qt_atom (line 1763) | struct qt_atom
  function build_stsd (line 1777) | static void
  function size_stsd (line 1795) | static unsigned
  type qt_atom (line 1808) | struct qt_atom
  type qt_atom (line 1809) | struct qt_atom
  type qt_atom_list (line 1812) | struct qt_atom_list
  function free_stsd (line 1831) | static void
  function display_alac (line 1840) | static void
  type qt_atom (line 1859) | struct qt_atom
  type qt_atom (line 1873) | struct qt_atom
  function build_alac (line 1906) | static void
  function size_alac (line 1924) | static unsigned
  type qt_atom (line 1930) | struct qt_atom
  type qt_atom (line 1931) | struct qt_atom
  function free_alac (line 1944) | static void
  function display_sub_alac (line 1953) | static void
  type qt_atom (line 1975) | struct qt_atom
  function build_sub_alac (line 2015) | static void
  function size_sub_alac (line 2033) | static unsigned
  function free_sub_alac (line 2039) | static void
  function display_stts (line 2047) | static void
  type qt_atom (line 2067) | struct qt_atom
  type qt_atom (line 2076) | struct qt_atom
  type stts_time (line 2080) | struct stts_time
  function build_stts (line 2098) | static void
  function size_stts (line 2114) | static unsigned
  function free_stts (line 2120) | static void
  function display_stsc (line 2129) | static void
  type qt_atom (line 2149) | struct qt_atom
  type qt_atom (line 2158) | struct qt_atom
  function build_stsc (line 2181) | static void
  function size_stsc (line 2198) | static unsigned
  function free_stsc (line 2204) | static void
  function display_stsz (line 2213) | static void
  type qt_atom (line 2232) | struct qt_atom
  type qt_atom (line 2242) | struct qt_atom
  function build_stsz (line 2260) | static void
  function size_stsz (line 2276) | static unsigned
  function free_stsz (line 2282) | static void
  function display_stco (line 2291) | static void
  type qt_atom (line 2309) | struct qt_atom
  type qt_atom (line 2318) | struct qt_atom
  function build_stco (line 2333) | static void
  function size_stco (line 2348) | static unsigned
  function free_stco (line 2354) | static void
  function display_meta (line 2363) | static void
  type qt_atom (line 2378) | struct qt_atom
  type qt_atom (line 2385) | struct qt_atom
  type qt_atom (line 2389) | struct qt_atom
  function build_meta (line 2404) | static void
  function size_meta (line 2417) | static unsigned
  type qt_atom (line 2428) | struct qt_atom
  type qt_atom (line 2429) | struct qt_atom
  type qt_atom_list (line 2432) | struct qt_atom_list
  function free_meta (line 2449) | static void
  function display_data (line 2458) | static void
  type qt_atom (line 2486) | struct qt_atom
  type qt_atom (line 2494) | struct qt_atom
  function build_data (line 2515) | static void
  function size_data (line 2525) | static unsigned
  function free_data (line 2531) | static void
  function display_free (line 2540) | static void
  type qt_atom (line 2550) | struct qt_atom
  function build_free (line 2559) | static void
  function size_free (line 2570) | static unsigned
  function free_free (line 2576) | static void
  type parser_s (line 2582) | struct parser_s {
  function parser_cmp (line 2587) | static int
  function atom_parser_f (line 2597) | static atom_parser_f
  function add_ftyp_brand (line 2663) | static void
  function display_fields (line 2678) | static void
  function main (line 2791) | int

FILE: src/common/m4a_atoms.h
  type qt_atom_type_t (line 25) | typedef enum {
  type qt_time_t (line 47) | typedef uint64_t qt_time_t;
  type qt_atom_list (line 49) | struct qt_atom_list
  type stts_time (line 50) | struct stts_time
  type stsc_entry (line 51) | struct stsc_entry
  type qt_atom (line 53) | struct qt_atom {
  type qt_atom_list (line 242) | struct qt_atom_list {
  type stts_time (line 247) | struct stts_time {
  type stsc_entry (line 252) | struct stsc_entry {
  type qt_atom (line 258) | struct qt_atom
  type qt_atom (line 266) | struct qt_atom
  type qt_atom (line 271) | struct qt

[
  {
    "path": "COPYING",
    "chars": 18002,
    "preview": "\t\t    GNU GENERAL PUBLIC LICENSE\n\t\t       Version 2, June 1991\n\n Copyright (C) 1989, 1991 Free Software Foundation, Inc."
  },
  {
    "path": "INSTALL",
    "chars": 1893,
    "preview": "\t\t\tInstallation Procedure\n\nTo install Python Audio Tools, you simply need to run:\n\nmake install\n\nas root from this sourc"
  },
  {
    "path": "MANIFEST.in",
    "chars": 560,
    "preview": "recursive-include audiotools *\nrecursive-include docs *\nrecursive-include src *\nrecursive-include test *\ninclude audioto"
  },
  {
    "path": "Makefile",
    "chars": 555,
    "preview": "# which Python interpreter to use\nPYTHON = python\n\n# which Python test coverage utility to use\nCOVERAGE = coverage\n\nall:"
  },
  {
    "path": "TODO",
    "chars": 254699,
    "preview": "# -*- Mode: Org -*-\n* Previous Issues\n** DONE Fix WAVE/MP3 formats to support MP3 audio in a WAVE container\n   Instead o"
  },
  {
    "path": "audiotools/__init__.py",
    "chars": 204620,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2020  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/accuraterip.py",
    "chars": 11972,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/aiff.py",
    "chars": 41959,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/ape.py",
    "chars": 39279,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/au.py",
    "chars": 11486,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/cdtoc.py",
    "chars": 9455,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/coverartarchive.py",
    "chars": 2645,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/cue/__init__.py",
    "chars": 16111,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/cue/tokrules.py",
    "chars": 2695,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/cue/yaccrules.py",
    "chars": 4866,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/flac.py",
    "chars": 117364,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/freedb.py",
    "chars": 11911,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/id3.py",
    "chars": 88419,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/id3v1.py",
    "chars": 11355,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/image.py",
    "chars": 14009,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/m4a.py",
    "chars": 36305,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/m4a_atoms.py",
    "chars": 73290,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/mp3.py",
    "chars": 26997,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/mpc.py",
    "chars": 12755,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  James Buren and Brian La"
  },
  {
    "path": "audiotools/musicbrainz.py",
    "chars": 13306,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/ogg.py",
    "chars": 5240,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/opus.py",
    "chars": 17369,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/player.py",
    "chars": 40590,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/ply/README",
    "chars": 8579,
    "preview": "PLY (Python Lex-Yacc)                   Version 3.4\n\nCopyright (C) 2001-2011,\nDavid M. Beazley (Dabeaz LLC)\nAll rights r"
  },
  {
    "path": "audiotools/ply/__init__.py",
    "chars": 1664,
    "preview": "# Copyright (C) 2001-2011,\n# David M. Beazley (Dabeaz LLC)\n# All rights reserved.\n#\n# Redistribution and use in source a"
  },
  {
    "path": "audiotools/ply/lex.py",
    "chars": 42889,
    "preview": "# -----------------------------------------------------------------------------\n# ply: lex.py\n#\n# Copyright (C) 2001-201"
  },
  {
    "path": "audiotools/ply/yacc.py",
    "chars": 135805,
    "preview": "# -----------------------------------------------------------------------------\n# ply: yacc.py\n#\n# Copyright (C) 2001-20"
  },
  {
    "path": "audiotools/speex.py",
    "chars": 14447,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/text.py",
    "chars": 33671,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/toc/__init__.py",
    "chars": 21790,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/toc/tokrules.py",
    "chars": 3434,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/toc/yaccrules.py",
    "chars": 7986,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/tta.py",
    "chars": 16199,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/ui.py",
    "chars": 118054,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/vorbis.py",
    "chars": 20653,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/vorbiscomment.py",
    "chars": 25399,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/wav.py",
    "chars": 42891,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools/wavpack.py",
    "chars": 22994,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian Langenberger\n\n# Th"
  },
  {
    "path": "audiotools-config",
    "chars": 47142,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2020  Brian"
  },
  {
    "path": "cdda2track",
    "chars": 23428,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2020  Brian"
  },
  {
    "path": "cddainfo",
    "chars": 3914,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2020  Brian"
  },
  {
    "path": "cddaplay",
    "chars": 10719,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2020  Brian"
  },
  {
    "path": "coverbrowse",
    "chars": 16942,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian"
  },
  {
    "path": "coverdump",
    "chars": 4893,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian"
  },
  {
    "path": "covertag",
    "chars": 6209,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian"
  },
  {
    "path": "docs/COPYING",
    "chars": 23401,
    "preview": "\t\t\t        Creative Commons\n\n                          Creative Commons Legal Code\n\nAttribution-ShareAlike 3.0 Unported\n"
  },
  {
    "path": "docs/Makefile",
    "chars": 1169,
    "preview": "PYTHON = python\nMAN_PATH = /usr/share/man\nMAN_PAGES = \\\naudiotools-config.1 \\\naudiotools.cfg.5 \\\ncdda2track.1 \\\ncddainfo"
  },
  {
    "path": "docs/audiotools-config.xml",
    "chars": 5019,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/audiotools.cfg.xml",
    "chars": 3994,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/cdda2track.xml",
    "chars": 4748,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/cddainfo.xml",
    "chars": 1157,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/cddaplay.xml",
    "chars": 2623,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/coverbrowse.xml",
    "chars": 981,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/coverdump.xml",
    "chars": 1581,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/covertag.xml",
    "chars": 2477,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/dvda2track.xml",
    "chars": 4029,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/dvdainfo.xml",
    "chars": 1321,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/manpagexml.py",
    "chars": 29302,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian"
  },
  {
    "path": "docs/programming/Makefile",
    "chars": 3814,
    "preview": "# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2015  Brian Langenberger\n\n# Th"
  },
  {
    "path": "docs/programming/source/audiotools.rst",
    "chars": 84775,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_accuraterip.rst",
    "chars": 5454,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_bitstream.rst",
    "chars": 23277,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_cdio.rst",
    "chars": 3953,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_cue.rst",
    "chars": 3130,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_dvda.rst",
    "chars": 5331,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_freedb.rst",
    "chars": 3127,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_musicbrainz.rst",
    "chars": 3282,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_pcm.rst",
    "chars": 8636,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_pcmconverter.rst",
    "chars": 8088,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_player.rst",
    "chars": 8163,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_replaygain.rst",
    "chars": 3373,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_toc.rst",
    "chars": 2820,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/audiotools_ui.rst",
    "chars": 20848,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/conf.py",
    "chars": 7303,
    "preview": "# -*- coding: utf-8 -*-\n\n#Audio Tools, a module and set of tools for manipulating audio data\n#Copyright (C) 2007-2016  B"
  },
  {
    "path": "docs/programming/source/huffman.dot",
    "chars": 1436,
    "preview": "/********************************************************\n Audio Tools, a module and set of tools for manipulating audio"
  },
  {
    "path": "docs/programming/source/index.rst",
    "chars": 1645,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/programming/source/metadata.rst",
    "chars": 58459,
    "preview": "..\n  Audio Tools, a module and set of tools for manipulating audio data\n  Copyright (C) 2007-2016  Brian Langenberger\n\n "
  },
  {
    "path": "docs/track2cdda.xml",
    "chars": 2085,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/track2track.xml",
    "chars": 5127,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/trackcat.xml",
    "chars": 3404,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/trackcmp.xml",
    "chars": 1846,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/trackinfo.xml",
    "chars": 1749,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/tracklength.xml",
    "chars": 1057,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/tracklint.xml",
    "chars": 2906,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/trackplay.xml",
    "chars": 2116,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/trackrename.xml",
    "chars": 1990,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/tracksplit.xml",
    "chars": 4426,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/tracktag.xml",
    "chars": 6023,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "docs/trackverify.xml",
    "chars": 3771,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\nCopyright (C) 2007-2016  Brian Langenberger\nThis work is licensed under the\n"
  },
  {
    "path": "dvda2track",
    "chars": 15425,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian"
  },
  {
    "path": "dvdainfo",
    "chars": 4360,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian"
  },
  {
    "path": "setup.cfg",
    "chars": 3060,
    "preview": "# Python Audio Tools can make use of additional libraries\n# to support optional functionality.  Possible values are:\n\n# "
  },
  {
    "path": "setup.py",
    "chars": 41468,
    "preview": "#!/usr/bin/python\n\n# Audio Tools, a module and set of tools for manipulating audio data\n# Copyright (C) 2007-2016  Brian"
  },
  {
    "path": "src/COPYING.LESSERv3",
    "chars": 7639,
    "preview": "\t\t   GNU LESSER GENERAL PUBLIC LICENSE\n                       Version 3, 29 June 2007\n\n Copyright (C) 2007 Free Software"
  },
  {
    "path": "src/Makefile",
    "chars": 5593,
    "preview": "#This makefile is for generating debug standalone executables\n\nFLAGS = -Wall -g\nBINARIES = \\\nalacdec \\\nwvdec \\\nalacenc \\"
  },
  {
    "path": "src/accuraterip.c",
    "chars": 11607,
    "preview": "#include \"accuraterip.h\"\n#include \"pcm.h\"\n#include \"mod_defs.h\"\n\n/******************************************************"
  },
  {
    "path": "src/accuraterip.h",
    "chars": 5716,
    "preview": "#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#include <stdint.h>\n\n/*****************************************************"
  },
  {
    "path": "src/bitstream-table.c",
    "chars": 17047,
    "preview": "/********************************************************\n Bitstream Library, a module for reading bits of data\n\n Copyri"
  },
  {
    "path": "src/bitstream.c",
    "chars": 298557,
    "preview": "/********************************************************\n Bitstream Library, a module for reading bits of data\n\n Copyri"
  },
  {
    "path": "src/bitstream.h",
    "chars": 47528,
    "preview": "/********************************************************\n Bitstream Library, a module for reading bits of data\n\n Copyri"
  },
  {
    "path": "src/buffer.c",
    "chars": 2909,
    "preview": "#include \"buffer.h\"\n#include <string.h>\n#include <stdlib.h>\n#include <assert.h>\n\n/**************************************"
  },
  {
    "path": "src/buffer.h",
    "chars": 4691,
    "preview": "#ifndef BUFFER_H\n#define BUFFER_H\n\n#include <stdint.h>\n#include <stdio.h>\n\n/********************************************"
  },
  {
    "path": "src/cdiomodule.c",
    "chars": 22105,
    "preview": "#include \"cdiomodule.h\"\n#include <limits.h>\n#include <cdio/cd_types.h>\n#include <cdio/audio.h>\n#include <cdio/track.h>\n#"
  },
  {
    "path": "src/cdiomodule.h",
    "chars": 9545,
    "preview": "#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#ifdef PARANOIA_LT_0_90\n#include <cdio/cdda.h>\n#include <cdio/paranoia.h>\n#"
  },
  {
    "path": "src/common/flac_crc.c",
    "chars": 5429,
    "preview": "#include \"flac_crc.h\"\n\n/********************************************************\n Audio Tools, a module and set of tools"
  },
  {
    "path": "src/common/flac_crc.h",
    "chars": 1138,
    "preview": "#include <stdint.h>\n\n/********************************************************\n Audio Tools, a module and set of tools f"
  },
  {
    "path": "src/common/m4a_atoms.c",
    "chars": 84103,
    "preview": "#include \"m4a_atoms.h\"\n#include <string.h>\n#include <ctype.h>\n#include <assert.h>\n\n/************************************"
  },
  {
    "path": "src/common/m4a_atoms.h",
    "chars": 12386,
    "preview": "#include <inttypes.h>\n#include <stdarg.h>\n#include <time.h>\n#include \"../bitstream.h\"\n\n/********************************"
  },
  {
    "path": "src/common/md5.c",
    "chars": 10253,
    "preview": "#include <stdlib.h>     /* for malloc() */\n#include <string.h>     /* for memcpy() */\n\n#include \"md5.h\"\n\n/*\n * This code"
  },
  {
    "path": "src/common/md5.h",
    "chars": 1624,
    "preview": "#ifndef MD5_H\n#define MD5_H\n\n#include <stdint.h>\n\n/*\n * This is the header file for the MD5 message-digest algorithm.\n *"
  },
  {
    "path": "src/common/tta_crc.c",
    "chars": 4765,
    "preview": "#include \"tta_crc.h\"\n\n/********************************************************\n Audio Tools, a module and set of tools "
  },
  {
    "path": "src/common/tta_crc.h",
    "chars": 993,
    "preview": "#include <stdint.h>\n\n/********************************************************\n Audio Tools, a module and set of tools f"
  },
  {
    "path": "src/decoders/NOTES.rst",
    "chars": 9295,
    "preview": "Decoder Implementation\n----------------------\n\nDecoding binary file formats is a typically a nontrivial problem\nthat pur"
  },
  {
    "path": "src/decoders/alac.c",
    "chars": 44230,
    "preview": "#include \"alac.h\"\n#include \"../common/m4a_atoms.h\"\n#include \"../framelist.h\"\n#include <string.h>\n\n/*********************"
  },
  {
    "path": "src/decoders/alac.h",
    "chars": 5562,
    "preview": "#ifndef STANDALONE\n#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#endif\n#include <stdint.h>\n#include \"../bitstream.h\"\n\n/*"
  },
  {
    "path": "src/decoders/alac_residual.h",
    "chars": 97563,
    "preview": "/********************************************************\n Audio Tools, a module and set of tools for manipulating audio"
  },
  {
    "path": "src/decoders/alac_residual.json",
    "chars": 223,
    "preview": "[[0], 0,\n [1, 0], 1,\n [1, 1, 0], 2,\n [1, 1, 1, 0], 3,\n [1, 1, 1, 1, 0], 4,\n [1, 1, 1, 1, 1, 0], 5,\n [1, 1, 1, 1, 1, 1, 0"
  },
  {
    "path": "src/decoders/flac.c",
    "chars": 63293,
    "preview": "#include \"flac.h\"\n#include \"../framelist.h\"\n#include \"../common/flac_crc.h\"\n#include <string.h>\n#include <errno.h>\n\n/***"
  },
  {
    "path": "src/decoders/flac.h",
    "chars": 6065,
    "preview": "#ifndef STANDALONE\n#include <Python.h>\n#endif\n#include <stdint.h>\n#include \"../bitstream.h\"\n#include \"../common/md5.h\"\n\n"
  },
  {
    "path": "src/decoders/mp3.c",
    "chars": 4980,
    "preview": "#include \"mp3.h\"\n#include \"../framelist.h\"\n\n/********************************************************\n Audio Tools, a mo"
  },
  {
    "path": "src/decoders/mp3.h",
    "chars": 4815,
    "preview": "#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#include <stdint.h>\n#include <mpg123.h>\n\n/*********************************"
  },
  {
    "path": "src/decoders/mpc.c",
    "chars": 5051,
    "preview": "#include \"mpc.h\"\n#include \"../framelist.h\"\n\n/********************************************************\n Audio Tools, a mo"
  },
  {
    "path": "src/decoders/mpc.h",
    "chars": 4823,
    "preview": "#include <Python.h>\n#include \"../mpc/mpcdec.h\"\n\n/********************************************************\n Audio Tools, "
  },
  {
    "path": "src/decoders/oggflac.c",
    "chars": 21318,
    "preview": "#ifdef STANDALONE\n#include <string.h>\n#include <errno.h>\n#endif\n#include \"oggflac.h\"\n#include \"../common/flac_crc.h\"\n#in"
  },
  {
    "path": "src/decoders/oggflac.h",
    "chars": 5962,
    "preview": "#ifndef STANDALONE\n#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#endif\n#include <stdint.h>\n#include \"../bitstream.h\"\n#in"
  },
  {
    "path": "src/decoders/opus.c",
    "chars": 9053,
    "preview": "#include \"opus.h\"\n#include \"../framelist.h\"\n\n/********************************************************\n Audio Tools, a m"
  },
  {
    "path": "src/decoders/opus.h",
    "chars": 4813,
    "preview": "#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#include <opus/opusfile.h>\n\n/**********************************************"
  },
  {
    "path": "src/decoders/sine.c",
    "chars": 17834,
    "preview": "#include \"sine.h\"\n#include \"../framelist.h\"\n\n/********************************************************\n Audio Tools, a m"
  },
  {
    "path": "src/decoders/sine.h",
    "chars": 17102,
    "preview": "#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#include <stdint.h>\n\n/*****************************************************"
  },
  {
    "path": "src/decoders/tta.c",
    "chars": 24741,
    "preview": "#include \"tta.h\"\n#include \"../common/tta_crc.h\"\n#include \"../framelist.h\"\n#include <string.h>\n#include <stdio.h>\n#includ"
  },
  {
    "path": "src/decoders/tta.h",
    "chars": 5321,
    "preview": "#ifndef STANDALONE\n#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#endif\n\n#include <stdint.h>\n#include \"../bitstream.h\"\n\n/"
  },
  {
    "path": "src/decoders/vorbis.c",
    "chars": 10563,
    "preview": "#include \"vorbis.h\"\n#include \"../framelist.h\"\n\n/********************************************************\n Audio Tools, a"
  },
  {
    "path": "src/decoders/vorbis.h",
    "chars": 4926,
    "preview": "#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#include <stdint.h>\n#include <vorbis/vorbisfile.h>\n\n/**********************"
  },
  {
    "path": "src/decoders/wavpack.c",
    "chars": 8106,
    "preview": "#include \"wavpack.h\"\n#include \"../pcm_conv.h\"\n#include \"../framelist.h\"\n#include <string.h>\n\n/**************************"
  },
  {
    "path": "src/decoders/wavpack.h",
    "chars": 5179,
    "preview": "#ifndef STANDALONE\n#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#endif\n#include <stdint.h>\n#include <wavpack/wavpack.h>\n"
  },
  {
    "path": "src/decoders.c",
    "chars": 5815,
    "preview": "#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#include \"mod_defs.h\"\n#include \"decoders.h\"\n#ifdef HAS_MP3\n#include <mpg123"
  },
  {
    "path": "src/decoders.h",
    "chars": 1173,
    "preview": "#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)\ntypedef int Py_ssize_t;\n#define PY_SSIZE_T_MAX INT_MAX\n#defi"
  },
  {
    "path": "src/dither.c",
    "chars": 3565,
    "preview": "/********************************************************\n Audio Tools, a module and set of tools for manipulating audio"
  },
  {
    "path": "src/dvdamodule.c",
    "chars": 12826,
    "preview": "#include \"dvdamodule.h\"\n#include \"mod_defs.h\"\n#include \"framelist.h\"\n\n/*************************************************"
  },
  {
    "path": "src/dvdamodule.h",
    "chars": 16529,
    "preview": "#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#include <dvd-audio.h>\n\n/**************************************************"
  },
  {
    "path": "src/encoders/NOTES.rst",
    "chars": 4425,
    "preview": "Encoder Implementation\n^^^^^^^^^^^^^^^^^^^^^^\n\nEncoding binary file formats is typically a CPU-intensive problem\nthat's "
  },
  {
    "path": "src/encoders/alac.c",
    "chars": 60809,
    "preview": "#include \"alac.h\"\n#include <string.h>\n#include <assert.h>\n#include <math.h>\n#include \"../common/m4a_atoms.h\"\n\n/*********"
  },
  {
    "path": "src/encoders/alac.h",
    "chars": 8777,
    "preview": "#ifndef A_ALAC_ENCODE\n#define A_ALAC_ENCODE\n#ifndef STANDALONE\n#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#endif\n\n#inc"
  },
  {
    "path": "src/encoders/flac.c",
    "chars": 84885,
    "preview": "#include \"flac.h\"\n#include \"../common/md5.h\"\n#include \"../common/flac_crc.h\"\n#include \"../pcm_conv.h\"\n#include <string.h"
  },
  {
    "path": "src/encoders/flac.h",
    "chars": 3016,
    "preview": "#ifndef STANDALONE\n#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#endif\n#include \"../bitstream.h\"\n#include \"../pcmreader."
  },
  {
    "path": "src/encoders/mp2.c",
    "chars": 5166,
    "preview": "#include <twolame.h>\n#include \"../pcmreader.h\"\n\n/********************************************************\n Audio Tools, "
  },
  {
    "path": "src/encoders/mp3.c",
    "chars": 7180,
    "preview": "#include <lame/lame.h>\n#include \"../pcmreader.h\"\n\n/********************************************************\n Audio Tools"
  },
  {
    "path": "src/encoders/mpc.c",
    "chars": 34842,
    "preview": "#include \"../mpc/datatypes.h\"\n#include \"../mpc/mpcdec.h\"\n#include \"../mpc/mpcmath.h\"\n#include \"../mpc/minimax.h\"\n#includ"
  },
  {
    "path": "src/encoders/opus.c",
    "chars": 19504,
    "preview": "#include <opus/opus.h>\n#include <opus_multistream.h>\n#include <ogg/ogg.h>\n#include <time.h>\n#include <stdlib.h>\n#include"
  },
  {
    "path": "src/encoders/tta.c",
    "chars": 23959,
    "preview": "#include \"tta.h\"\n#include \"../common/tta_crc.h\"\n\n/********************************************************\n Audio Tools,"
  },
  {
    "path": "src/encoders/tta.h",
    "chars": 1763,
    "preview": "#ifndef STANDALONE\n#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#endif\n\n#include \"../bitstream.h\"\n#include \"../pcmreader"
  },
  {
    "path": "src/encoders/vorbis.c",
    "chars": 16342,
    "preview": "#include <stdlib.h>\n#include <time.h>\n#include <vorbis/vorbisenc.h>\n#include <ogg/ogg.h>\n#include \"../pcmreader.h\"\n\n#def"
  },
  {
    "path": "src/encoders/wavpack.c",
    "chars": 17319,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include \"../pcm_conv.h\"\n#include \"wavpack.h\"\n#include <wavpa"
  },
  {
    "path": "src/encoders/wavpack.h",
    "chars": 1841,
    "preview": "#include <stdint.h>\n#include \"../pcmreader.h\"\n#include \"../bitstream.h\"\n#include \"../common/md5.h\"\n\n/*******************"
  },
  {
    "path": "src/encoders.c",
    "chars": 1234,
    "preview": "#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#include \"mod_defs.h\"\n#include \"bitstream.h\"\n#include \"encoders.h\"\n\n/******"
  },
  {
    "path": "src/encoders.h",
    "chars": 3274,
    "preview": "#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)\ntypedef int Py_ssize_t;\n#define PY_SSIZE_T_MAX INT_MAX\n#defi"
  },
  {
    "path": "src/framelist.c",
    "chars": 2772,
    "preview": "#include \"framelist.h\"\n\n/********************************************************\n Audio Tools, a module and set of tool"
  },
  {
    "path": "src/framelist.h",
    "chars": 3132,
    "preview": "#ifndef STANDALONE\n#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n#endif\n#include \"pcm.h\"\n\n/******************************"
  },
  {
    "path": "src/func_io.c",
    "chars": 11483,
    "preview": "/********************************************************\n Bitstream Library, a module for reading bits of data\n\n Copyri"
  },
  {
    "path": "src/func_io.h",
    "chars": 6628,
    "preview": "/********************************************************\n Bitstream Library, a module for reading bits of data\n\n Copyri"
  },
  {
    "path": "src/huffman.c",
    "chars": 25439,
    "preview": "/********************************************************\n Bitstream Library, a module for reading bits of data\n\n Copyri"
  },
  {
    "path": "src/huffman.h",
    "chars": 5587,
    "preview": "/********************************************************\n Bitstream Library, a module for reading bits of data\n\n Copyri"
  },
  {
    "path": "src/libmpcdec/AUTHORS",
    "chars": 282,
    "preview": "libmpcdec is the result of the work of many people:\n\n* Andree Buschmann and Frank Klemm\n  Original implementation and co"
  },
  {
    "path": "src/libmpcdec/COPYING",
    "chars": 1563,
    "preview": "Copyright (c) 2005, The Musepack Development Team\nAll rights reserved.\n\nRedistribution and use in source and binary form"
  },
  {
    "path": "src/libmpcdec/ChangeLog",
    "chars": 1316,
    "preview": "1.3.0\n    * first sv8 release\n    * major changes in the API (decoder and demuxer are split)\n\n1.2.3\n    * Reduced memory"
  },
  {
    "path": "src/libmpcdec/README",
    "chars": 197,
    "preview": "Musepack Decoder Library:\n\nrun \"./configure [--prefix=/usr]; make\"\n\nTo create a sample app using the musepack decoder li"
  },
  {
    "path": "src/libmpcdec/decoder.h",
    "chars": 3770,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/huffman.c",
    "chars": 22986,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/huffman.h",
    "chars": 2560,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/internal.h",
    "chars": 3836,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/mpc_bits_reader.c",
    "chars": 11063,
    "preview": "/*\n  Copyright (c) 2007-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/mpc_bits_reader.h",
    "chars": 4955,
    "preview": "/*\n  Copyright (c) 2007-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/mpc_decoder.c",
    "chars": 26285,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/mpc_demux.c",
    "chars": 23152,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/mpc_reader.c",
    "chars": 4810,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/mpcdec_math.h",
    "chars": 5107,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/requant.c",
    "chars": 4008,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/requant.h",
    "chars": 2133,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/streaminfo.c",
    "chars": 8435,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcdec/synth_filter.c",
    "chars": 23689,
    "preview": "/*\n  Copyright (c) 2005-2009, The Musepack Development Team\n  All rights reserved.\n\n  Redistribution and use in source a"
  },
  {
    "path": "src/libmpcenc/analy_filter.c",
    "chars": 14499,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcenc/bitstream.c",
    "chars": 13037,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcenc/encode_sv7.c",
    "chars": 14855,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcenc/huffsv7.c",
    "chars": 13929,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcenc/libmpcenc.h",
    "chars": 5222,
    "preview": "/*\n * Musepack audio compression\n *\n * This library is free software; you can redistribute it and/or\n * modify it under "
  },
  {
    "path": "src/libmpcenc/quant.c",
    "chars": 15404,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcpsy/ans.c",
    "chars": 11181,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcpsy/cvd.c",
    "chars": 14222,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcpsy/fft4g.c",
    "chars": 13241,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcpsy/fft_routines.c",
    "chars": 7827,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcpsy/libmpcpsy.h",
    "chars": 4753,
    "preview": "/*\n * Musepack audio compression\n *\n * This library is free software; you can redistribute it and/or\n * modify it under "
  },
  {
    "path": "src/libmpcpsy/profile.c",
    "chars": 7165,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcpsy/psy.c",
    "chars": 47549,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/libmpcpsy/psy_tab.c",
    "chars": 14446,
    "preview": "/*\n * Musepack audio compression\n * Copyright (c) 2005-2009, The Musepack Development Team\n * Copyright (C) 1999-2004 Bu"
  },
  {
    "path": "src/mini-gmp.c",
    "chars": 83367,
    "preview": "/* mini-gmp, a minimalistic implementation of a GNU GMP subset.\n\n   Contributed to the GNU project by Niels Möller\n\nCopy"
  }
]

// ... and 139 more files (download for full content)