SYMBOL INDEX (275 symbols across 50 files)

FILE: fuzz_target.cc
  function LLVMFuzzerTestOneInput (line 6) | int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {

FILE: guetzli/butteraugli_comparator.cc
  type guetzli (line 25) | namespace guetzli {
    function LinearRgb (line 33) | std::vector<ImageF> LinearRgb(const size_t xsize, const size_t ysize,
    type Complex (line 136) | struct Complex {
    function abssq (line 141) | inline double abssq(const Complex& c) {
    function TransposeBlock (line 145) | static void TransposeBlock(Complex data[kBlockSize]) {
    function FFT4 (line 154) | inline void FFT4(Complex* a) {
    function FFT8 (line 186) | void FFT8(Complex* a) {
    function RealFFT8 (line 282) | void RealFFT8(const double* in, Complex* out) {
    function ButteraugliFFTSquared (line 357) | void ButteraugliFFTSquared(double block[kBlockSize]) {
    function ButteraugliBlockDiff (line 382) | void ButteraugliBlockDiff(double xyb0[3 * kBlockSize],

FILE: guetzli/butteraugli_comparator.h
  function namespace (line 28) | namespace guetzli {

FILE: guetzli/color_transform.h
  function namespace (line 20) | namespace guetzli {

FILE: guetzli/comparator.h
  function namespace (line 25) | namespace guetzli {

FILE: guetzli/dct_double.cc
  type guetzli (line 22) | namespace guetzli {
    function DCT1d (line 47) | void DCT1d(const double* in, int stride, double* out) {
    function IDCT1d (line 56) | void IDCT1d(const double* in, int stride, double* out) {
    function TransformBlock (line 67) | void TransformBlock(double block[64], Transform1d f) {
    function ComputeBlockDCTDouble (line 79) | void ComputeBlockDCTDouble(double block[64]) {
    function ComputeBlockIDCTDouble (line 83) | void ComputeBlockIDCTDouble(double block[64]) {

FILE: guetzli/dct_double.h
  function namespace (line 20) | namespace guetzli {

FILE: guetzli/debug_print.cc
  type guetzli (line 19) | namespace guetzli {
    function PrintDebug (line 21) | void PrintDebug(ProcessStats* stats, std::string s) {

FILE: guetzli/debug_print.h
  function namespace (line 22) | namespace guetzli {

FILE: guetzli/entropy_encode.cc
  type guetzli (line 24) | namespace guetzli {
    function SetDepth (line 26) | bool SetDepth(int p0, HuffmanTree *pool, uint8_t *depth, int max_depth) {
    function SortHuffmanTree (line 50) | static inline bool SortHuffmanTree(const HuffmanTree& v0,
    function CreateHuffmanTree (line 73) | void CreateHuffmanTree(const uint32_t *data,

FILE: guetzli/entropy_encode.h
  function namespace (line 25) | namespace guetzli {

FILE: guetzli/fast_log.h
  function namespace (line 22) | namespace guetzli {

FILE: guetzli/fdct.cc
  type guetzli (line 23) | namespace guetzli {
    function ColumnDct (line 160) | inline void ColumnDct(coeff_t* in) {
    function RowDct (line 173) | void RowDct(coeff_t* in, const coeff_t* table) {
  function ComputeBlockDCT (line 230) | void ComputeBlockDCT(coeff_t* coeffs) {

FILE: guetzli/fdct.h
  function namespace (line 22) | namespace guetzli {

FILE: guetzli/gamma_correct.cc
  type guetzli (line 21) | namespace guetzli {

FILE: guetzli/gamma_correct.h
  function namespace (line 20) | namespace guetzli {

FILE: guetzli/guetzli.cc
  function BlendOnBlack (line 43) | inline uint8_t BlendOnBlack(const uint8_t val, const uint8_t alpha) {
  function ReadPNG (line 47) | bool ReadPNG(const std::string& data, int* xsize, int* ysize,
  function ReadFileOrDie (line 154) | std::string ReadFileOrDie(const char* filename) {
  function WriteFileOrDie (line 191) | void WriteFileOrDie(const char* filename, const std::string& contents) {
  function TerminateHandler (line 209) | void TerminateHandler() {
  function Usage (line 215) | void Usage() {
  function main (line 232) | int main(int argc, char** argv) {

FILE: guetzli/idct.cc
  type guetzli (line 24) | namespace guetzli {
    function Compute1dIDCT (line 41) | inline void Compute1dIDCT(const coeff_t* in, const int stride, int out...
    function ComputeBlockIDCT (line 139) | void ComputeBlockIDCT(const coeff_t* block, uint8_t* out) {

FILE: guetzli/idct.h
  function namespace (line 22) | namespace guetzli {

FILE: guetzli/jpeg_bit_writer.h
  function namespace (line 23) | namespace guetzli {
  function EmitByte (line 76) | void EmitByte(int byte) {
  function JumpToByteBoundary (line 87) | void JumpToByteBoundary() {

FILE: guetzli/jpeg_data.cc
  type guetzli (line 22) | namespace guetzli {
    function InitJPEGDataForYUV444 (line 48) | void InitJPEGDataForYUV444(int w, int h, JPEGData* jpg) {
    function SaveQuantTables (line 70) | void SaveQuantTables(const int q[3][kDCTBlockSize], JPEGData* jpg) {

FILE: guetzli/jpeg_data.h
  function namespace (line 29) | namespace guetzli {

FILE: guetzli/jpeg_data_decoder.cc
  type guetzli (line 21) | namespace guetzli {
    function HasYCbCrColorSpace (line 25) | bool HasYCbCrColorSpace(const JPEGData& jpg) {
    function DecodeJpegToRGB (line 45) | std::vector<uint8_t> DecodeJpegToRGB(const JPEGData& jpg) {

FILE: guetzli/jpeg_data_decoder.h
  function namespace (line 26) | namespace guetzli {

FILE: guetzli/jpeg_data_encoder.cc
  type guetzli (line 24) | namespace guetzli {
    function Quantize (line 33) | void Quantize(coeff_t* v, int iquant) {
    function RGBToYUV16 (line 40) | inline static void RGBToYUV16(const uint8_t* const rgb,
    function AddApp0Data (line 53) | void AddApp0Data(JPEGData* jpg) {
    function EncodeRGBToJpeg (line 66) | bool EncodeRGBToJpeg(const std::vector<uint8_t>& rgb, int w, int h,
    function EncodeRGBToJpeg (line 119) | bool EncodeRGBToJpeg(const std::vector<uint8_t>& rgb, int w, int h,

FILE: guetzli/jpeg_data_encoder.h
  function namespace (line 24) | namespace guetzli {

FILE: guetzli/jpeg_data_reader.cc
  type guetzli (line 25) | namespace guetzli {
    function SignedLeftshift (line 66) | inline int SignedLeftshift(int v, int s) {
    function DivCeil (line 71) | inline int DivCeil(int a, int b) {
    function ReadUint8 (line 75) | inline int ReadUint8(const uint8_t* data, size_t* pos) {
    function ReadUint16 (line 79) | inline int ReadUint16(const uint8_t* data, size_t* pos) {
    function ProcessSOF (line 87) | bool ProcessSOF(const uint8_t* data, const size_t len,
    function ProcessSOS (line 169) | bool ProcessSOS(const uint8_t* data, const size_t len, size_t* pos,
    function ProcessDHT (line 251) | bool ProcessDHT(const uint8_t* data, const size_t len,
    function ProcessDQT (line 344) | bool ProcessDQT(const uint8_t* data, const size_t len, size_t* pos,
    function ProcessDRI (line 379) | bool ProcessDRI(const uint8_t* data, const size_t len, size_t* pos,
    function ProcessAPP (line 396) | bool ProcessAPP(const uint8_t* data, const size_t len, size_t* pos,
    function ProcessCOM (line 411) | bool ProcessCOM(const uint8_t* data, const size_t len, size_t* pos,
    type BitReaderState (line 425) | struct BitReaderState {
      method BitReaderState (line 426) | BitReaderState(const uint8_t* data, const size_t len, size_t pos)
      method Reset (line 431) | void Reset(size_t pos) {
      method GetNextByte (line 440) | uint8_t GetNextByte() {
      method FillBitWindow (line 459) | void FillBitWindow() {
      method ReadBits (line 469) | int ReadBits(int nbits) {
      method FinishStream (line 478) | bool FinishStream(size_t* pos) {
    function ReadSymbol (line 508) | int ReadSymbol(const HuffmanTableEntry* table, BitReaderState* br) {
    function HuffExtend (line 526) | int HuffExtend(int x, int s) {
    function DecodeDCTBlock (line 531) | bool DecodeDCTBlock(const HuffmanTableEntry* dc_huff,
    function RefineDCTBlock (line 617) | bool RefineDCTBlock(const HuffmanTableEntry* ac_huff,
    function ProcessRestart (line 732) | bool ProcessRestart(const uint8_t* data, const size_t len,
    function ProcessScan (line 755) | bool ProcessScan(const uint8_t* data, const size_t len,
    function FixupIndexes (line 890) | bool FixupIndexes(JPEGData* jpg) {
    function FindNextMarker (line 911) | size_t FindNextMarker(const uint8_t* data, const size_t len, size_t po...
    function ReadJpeg (line 931) | bool ReadJpeg(const uint8_t* data, const size_t len, JpegReadMode mode,
    function ReadJpeg (line 1074) | bool ReadJpeg(const std::string& data, JpegReadMode mode,

FILE: guetzli/jpeg_data_reader.h
  function namespace (line 29) | namespace guetzli {

FILE: guetzli/jpeg_data_writer.cc
  type guetzli (line 27) | namespace guetzli {
    function JPEGWrite (line 34) | inline bool JPEGWrite(JPEGOutput out, const uint8_t* buf, size_t len) {
    function JPEGWrite (line 47) | inline bool JPEGWrite(JPEGOutput out, const std::string& s) {
    function EncodeMetadata (line 52) | bool EncodeMetadata(const JPEGData& jpg, bool strip_metadata, JPEGOutp...
    function EncodeDQT (line 77) | bool EncodeDQT(const std::vector<JPEGQuantTable>& quant, JPEGOutput ou...
    function EncodeSOF (line 102) | bool EncodeSOF(const JPEGData& jpg, JPEGOutput out) {
    function BuildHuffmanCode (line 131) | void BuildHuffmanCode(uint8_t* depth, int* counts, int* values) {
    function BuildHuffmanCodeTable (line 148) | void BuildHuffmanCodeTable(const int* counts, const int* values,
    function UpdateACHistogramForDCTBlock (line 188) | void UpdateACHistogramForDCTBlock(const coeff_t* coeffs,
    function HistogramHeaderCost (line 211) | size_t HistogramHeaderCost(const JpegHistogram& histo) {
    function HistogramEntropyCost (line 221) | size_t HistogramEntropyCost(const JpegHistogram& histo,
    function BuildDCHistograms (line 234) | void BuildDCHistograms(const JPEGData& jpg, JpegHistogram* histo) {
    function BuildACHistograms (line 258) | void BuildACHistograms(const JPEGData& jpg, JpegHistogram* histo) {
    function JpegHeaderSize (line 269) | size_t JpegHeaderSize(const JPEGData& jpg, bool strip_metadata) {
    function ClusterHistograms (line 295) | size_t ClusterHistograms(JpegHistogram* histo, size_t* num,
    function EstimateJpegDataSize (line 344) | size_t EstimateJpegDataSize(const int num_components,
    function BuildAndEncodeHuffmanCodes (line 361) | bool BuildAndEncodeHuffmanCodes(const JPEGData& jpg, JPEGOutput out,
    function EncodeDCTBlockSequential (line 455) | void EncodeDCTBlockSequential(const coeff_t* coeffs,
    function EncodeScan (line 502) | bool EncodeScan(const JPEGData& jpg,
    function WriteJpeg (line 540) | bool WriteJpeg(const JPEGData& jpg, bool strip_metadata, JPEGOutput ou...
    function NullOut (line 555) | int NullOut(void* data, const uint8_t* buf, size_t count) {
    function BuildSequentialHuffmanCodes (line 559) | void BuildSequentialHuffmanCodes(

FILE: guetzli/jpeg_data_writer.h
  function namespace (line 28) | namespace guetzli {
  type HuffmanCodeTable (line 47) | struct HuffmanCodeTable {
  function Clear (line 56) | struct JpegHistogram {
  function Add (line 64) | void Add(int symbol) {
  function Add (line 67) | void Add(int symbol, int weight) {
  function AddHistogram (line 70) | void AddHistogram(const JpegHistogram& other) {
  function NumSymbols (line 76) | int NumSymbols() const {

FILE: guetzli/jpeg_error.h
  function namespace (line 22) | namespace guetzli {

FILE: guetzli/jpeg_huffman_decode.cc
  type guetzli (line 26) | namespace guetzli {
    function NextTableBitSize (line 31) | static inline int NextTableBitSize(const int* count, int len) {
    function BuildJpegHuffmanTable (line 42) | int BuildJpegHuffmanTable(const int* count_in, const int* symbols,

FILE: guetzli/jpeg_huffman_decode.h
  function namespace (line 24) | namespace guetzli {

FILE: guetzli/output_image.cc
  type guetzli (line 33) | namespace guetzli {
    function SetDownsampledCoefficients (line 265) | void SetDownsampledCoefficients(const std::vector<float>& pixels,

FILE: guetzli/output_image.h
  function class (line 27) | class OutputImageComponent {
  function class (line 94) | class OutputImage {

FILE: guetzli/preprocess_downsample.cc
  function Convolve2D (line 29) | std::vector<float> Convolve2D(const std::vector<float>& image, int w, in...
  function Convolve2X (line 53) | std::vector<float> Convolve2X(const std::vector<float>& image, int w, in...
  function Normal (line 85) | double Normal(double x, double sigma) {
  function Sharpen (line 90) | std::vector<float> Sharpen(const std::vector<float>& image, int w, int h,
  function Erode (line 110) | void Erode(int w, int h, std::vector<bool>* image) {
  function Dilate (line 123) | void Dilate(int w, int h, std::vector<bool>* image) {
  function Blur (line 136) | std::vector<float> Blur(const std::vector<float>& image, int w, int h) {
  type guetzli (line 153) | namespace guetzli {
    function PreProcessChannel (line 157) | std::vector<std::vector<float>> PreProcessChannel(
    function Clip (line 283) | inline float Clip(float val) {
    function RGBToY (line 287) | inline float RGBToY(float r, float g, float b) {
    function RGBToU (line 291) | inline float RGBToU(float r, float g, float b) {
    function RGBToV (line 295) | inline float RGBToV(float r, float g, float b) {
    function YUVToR (line 299) | inline float YUVToR(float y, float u, float v) {
    function YUVToG (line 303) | inline float YUVToG(float y, float u, float v) {
    function YUVToB (line 307) | inline float YUVToB(float y, float u, float v) {
    function GammaToLinear (line 312) | inline float GammaToLinear(float x) {
    function LinearToGamma (line 317) | inline float LinearToGamma(float x) {
    function LinearlyAveragedLuma (line 321) | std::vector<float> LinearlyAveragedLuma(const std::vector<float>& rgb) {
    function LinearlyDownsample2x2 (line 332) | std::vector<float> LinearlyDownsample2x2(const std::vector<float>& rgb...
    function RGBToYUV (line 356) | std::vector<std::vector<float> > RGBToYUV(const std::vector<float>& rg...
    function YUVToRGB (line 369) | std::vector<float> YUVToRGB(const std::vector<std::vector<float> >& yu...
    function Upsample2x2 (line 384) | std::vector<float> Upsample2x2(const std::vector<float>& img_in,
    function Blur (line 405) | std::vector<float> Blur(const std::vector<float>& img,
    function YUV420ToRGB (line 428) | std::vector<float> YUV420ToRGB(const std::vector<std::vector<float> >&...
    function UpdateGuess (line 439) | void UpdateGuess(const std::vector<float>& target,
    function RGBToYUV420 (line 452) | std::vector<std::vector<float> > RGBToYUV420(

FILE: guetzli/preprocess_downsample.h
  function namespace (line 25) | namespace guetzli {

FILE: guetzli/processor.cc
  type guetzli (line 35) | namespace guetzli {
    type CoeffData (line 41) | struct CoeffData {
    type QuantData (line 45) | struct QuantData {
    class Processor (line 50) | class Processor {
    function RemoveOriginalQuantization (line 82) | void RemoveOriginalQuantization(JPEGData* jpg, int q_in[3][kDCTBlockSi...
    function CheckJpegSanity (line 106) | bool CheckJpegSanity(const JPEGData& jpg) {
    function GuetzliStringOut (line 123) | int GuetzliStringOut(void* data, const uint8_t* buf, size_t count) {
    function CompareQuantData (line 150) | bool CompareQuantData(const QuantData& a, const QuantData& b) {
    function CompareQuantMatrices (line 161) | int CompareQuantMatrices(const int* a, const int* b) {
    function ContrastSensitivity (line 180) | double ContrastSensitivity(int k) {
    function QuantMatrixHeuristicScore (line 184) | double QuantMatrixHeuristicScore(const int q[3][kDCTBlockSize]) {
    class QuantMatrixGenerator (line 194) | class QuantMatrixGenerator {
      method QuantMatrixGenerator (line 196) | QuantMatrixGenerator(bool downsample, ProcessStats* stats)
      method GetNext (line 204) | bool GetNext(int q[3][kDCTBlockSize]) {
      method Add (line 261) | void Add(const QuantData& data) {
      method GetQuantMatrixWithHeuristicScore (line 272) | void GetQuantMatrixWithHeuristicScore(double score,
    function QuantData (line 298) | QuantData Processor::TryQuantMatrix(const JPEGData& jpg_in,
    function UpdateACHistogram (line 471) | void UpdateACHistogram(const int weight,
    function ComputeEntropyCodes (line 497) | size_t ComputeEntropyCodes(const std::vector<JpegHistogram>& histograms,
    function EntropyCodedDataSize (line 518) | size_t EntropyCodedDataSize(const std::vector<JpegHistogram>& histograms,
    function EstimateDCSize (line 528) | size_t EstimateDCSize(const JPEGData& jpg) {
    function IsGrayscale (line 782) | bool IsGrayscale(const JPEGData& jpg) {
    function ProcessJpegData (line 883) | bool ProcessJpegData(const Params& params, const JPEGData& jpg_in,
    function Process (line 890) | bool Process(const Params& params, ProcessStats* stats,
    function Process (line 926) | bool Process(const Params& params, ProcessStats* stats,

FILE: guetzli/processor.h
  function namespace (line 27) | namespace guetzli {

FILE: guetzli/quality.cc
  type guetzli (line 19) | namespace guetzli {
    function ButteraugliScoreForQuality (line 78) | double ButteraugliScoreForQuality(double quality) {

FILE: guetzli/quality.h
  function namespace (line 20) | namespace guetzli {

FILE: guetzli/quantize.cc
  type guetzli (line 19) | namespace guetzli {
    function QuantizeBlock (line 21) | bool QuantizeBlock(coeff_t block[kDCTBlockSize],

FILE: guetzli/quantize.h
  function namespace (line 22) | namespace guetzli {

FILE: guetzli/score.cc
  type guetzli (line 21) | namespace guetzli {
    function ScoreJPEG (line 23) | double ScoreJPEG(double butteraugli_distance, int size,

FILE: guetzli/score.h
  function namespace (line 22) | namespace guetzli {

FILE: guetzli/stats.h
  function namespace (line 27) | namespace guetzli {

FILE: third_party/butteraugli/butteraugli/butteraugli.cc
  type butteraugli (line 58) | namespace butteraugli {
    function IsNan (line 88) | static inline bool IsNan(const float x) {
    function IsNan (line 95) | static inline bool IsNan(const double x) {
    function CheckImage (line 102) | static inline void CheckImage(const ImageF &image, const char *name) {
    function DotProduct (line 141) | inline float DotProduct(const float u[3], const float v[3]) {
    function ComputeKernel (line 145) | std::vector<float> ComputeKernel(float sigma) {
    function ConvolveBorderColumn (line 156) | void ConvolveBorderColumn(
    function ImageF (line 184) | ImageF Convolution(const ImageF& in,
    function ImageF (line 229) | ImageF Blur(const ImageF& in, float sigma, float border_ratio) {
    function InterpolateClampNegative (line 236) | inline double InterpolateClampNegative(const double *array,
    function GammaMinArg (line 253) | double GammaMinArg() {
    function GammaMaxArg (line 259) | double GammaMaxArg() {
    function SimpleGamma (line 265) | double SimpleGamma(double v) {
    function Gamma (line 319) | static inline double Gamma(double v) {
    function OpsinDynamicsImage (line 324) | std::vector<ImageF> OpsinDynamicsImage(const std::vector<ImageF>& rgb) {
    function BUTTERAUGLI_INLINE (line 369) | static BUTTERAUGLI_INLINE float RemoveRangeAroundZero(float w, float x) {
    function BUTTERAUGLI_INLINE (line 374) | static BUTTERAUGLI_INLINE float AmplifyRangeAroundZero(float w, float ...
    function BUTTERAUGLI_INLINE (line 382) | BUTTERAUGLI_INLINE void XybLowFreqToVals(const V &x, const V &y, const...
    function ImageF (line 401) | static ImageF SuppressInBrightAreas(size_t xsize, size_t ysize,
    function SuppressHfInBrightAreas (line 420) | static float SuppressHfInBrightAreas(float hf, float brightness,
    function SuppressUhfInBrightAreas (line 426) | static float SuppressUhfInBrightAreas(float hf, float brightness,
    function MaximumClamp (line 432) | static float MaximumClamp(float v, float maxval) {
    function ImageF (line 446) | static ImageF MaximumClamping(size_t xsize, size_t ysize, const ImageF...
    function ImageF (line 470) | static ImageF SuppressXByY(size_t xsize, size_t ysize,
    function SeparateFrequencies (line 489) | static void SeparateFrequencies(
    function SameNoiseLevels (line 624) | static void SameNoiseLevels(const ImageF& i0, const ImageF& i1,
    function L2Diff (line 654) | static void L2Diff(const ImageF& i0, const ImageF& i1, const double w,
    function L2DiffAsymmetric (line 672) | static void L2DiffAsymmetric(const ImageF& i0, const ImageF& i1,
    function ImageF (line 718) | ImageF CalculateDiffmap(const ImageF& diffmap_in) {
    function MaskPsychoImage (line 753) | void MaskPsychoImage(const PsychoImage& pi0, const PsychoImage& pi1,
    function const (line 793) | void ButteraugliComparator::Mask(
    type MaltaTagLF (line 911) | struct MaltaTagLF {}
    type MaltaTag (line 912) | struct MaltaTag {}
    function MaltaUnit (line 914) | static float MaltaUnit(MaltaTagLF, const float* BUTTERAUGLI_RESTRICT d,
    function MaltaUnit (line 1146) | static float MaltaUnit(MaltaTag, const float* BUTTERAUGLI_RESTRICT d,
    function BUTTERAUGLI_INLINE (line 1429) | static BUTTERAUGLI_INLINE float PaddedMaltaUnit(
    function MaltaDiffMapImpl (line 1461) | static void MaltaDiffMapImpl(const ImageF& lum0, const ImageF& lum1,
    function ImageF (line 1597) | ImageF ButteraugliComparator::CombineChannels(
    function ButteraugliScoreFromDiffmap (line 1623) | double ButteraugliScoreFromDiffmap(const ImageF& diffmap) {
    function MakeMask (line 1638) | static std::array<double, 512> MakeMask(
    function MaskX (line 1655) | double MaskX(double delta) {
    function MaskY (line 1666) | double MaskY(double delta) {
    function MaskDcX (line 1677) | double MaskDcX(double delta) {
    function MaskDcY (line 1688) | double MaskDcY(double delta) {
    function ImageF (line 1699) | ImageF DiffPrecompute(const ImageF& xyb0, const ImageF& xyb1) {
    function Mask (line 1741) | void Mask(const std::vector<ImageF>& xyb0,
    function ButteraugliDiffmap (line 1819) | void ButteraugliDiffmap(const std::vector<ImageF> &rgb0_image,
    function ButteraugliInterface (line 1860) | bool ButteraugliInterface(const std::vector<ImageF> &rgb0,
    function ButteraugliAdaptiveQuantization (line 1880) | bool ButteraugliAdaptiveQuantization(size_t xsize, size_t ysize,
    function ButteraugliFuzzyClass (line 1903) | double ButteraugliFuzzyClass(double score) {
    function ButteraugliFuzzyInverse (line 1923) | double ButteraugliFuzzyInverse(double seek) {
    function ScoreToRgb (line 1938) | void ScoreToRgb(double score, double good_threshold, double bad_thresh...
    function CreateHeatMapImage (line 1979) | void CreateHeatMapImage(const std::vector<float>& distmap,

FILE: third_party/butteraugli/butteraugli/butteraugli.h
  function namespace (line 36) | namespace butteraugli {
  function Align (line 169) | inline size_t Align(const size_t amount) {
  function BytesPerRow (line 200) | static size_t BytesPerRow(const size_t xsize) {
  function Swap (line 264) | void Swap(Image &other) {
  function T (line 275) | T *const BUTTERAUGLI_RESTRICT Row(const size_t y) {
  function T (line 286) | const T *const BUTTERAUGLI_RESTRICT Row(const size_t y) const {
  function std (line 326) | inline std::vector<Image<T>> CreatePlanes(const size_t xsize,
  function std (line 349) | inline std::vector<Image<T>> CopyPlanes(
  function const (line 570) | struct RationalPolynomial {
  function GammaPolynomial (line 603) | static inline double GammaPolynomial(double value) {

FILE: third_party/butteraugli/butteraugli/butteraugli_main.cc
  type butteraugli (line 12) | namespace butteraugli {
    function ReadPNG (line 17) | bool ReadPNG(FILE* f, std::vector<Image8>* rgb) {
    function jpeg_catch_error (line 148) | void jpeg_catch_error(j_common_ptr cinfo) {
    function ReadJPEG (line 157) | bool ReadJPEG(FILE* f, std::vector<Image8>* rgb) {
    function FromSrgbToLinear (line 239) | void FromSrgbToLinear(const std::vector<Image8>& rgb,
    function ReadImageOrDie (line 283) | std::vector<Image8> ReadImageOrDie(const char* filename) {
    function ScoreToRgb (line 311) | static void ScoreToRgb(double score, double good_threshold,
    function CreateHeatMapImage (line 347) | void CreateHeatMapImage(const ImageF& distmap, double good_threshold,
    function Run (line 362) | int Run(int argc, char* argv[]) {
  function main (line 457) | int main(int argc, char** argv) { return butteraugli::Run(argc, argv); }

FILE: tools/guetzli-compare.py
  function run (line 13) | def run(cmdline):
  function size (line 17) | def size(filename):
  function ba_distance (line 20) | def ba_distance(orig, compressed):
  function handle_png (line 23) | def handle_png(png):