Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "(", "e", "*", "Encoding", ")", "pad", "(", "s", "string", ",", "minlen", "int", ")", "string", "{", "if", "len", "(", "s", ")", ">=", "minlen", "{", "return", "s", "\n", "}", "\n\n", "format", ":=", "fmt", ".", "Sprint", "(", "`%0`", ",", "strconv", ".", "Itoa", "(", "minlen", ")", ",", "\"", "\"", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "format", ",", "s", ")", "\n", "}" ]

[ "pad", "a", "string", "to", "a", "minimum", "length", "with", "zero", "characters" ]

[ "func", "GenerateV1PSK", "(", ")", "(", "io", ".", "Reader", ",", "error", ")", "{", "psk", ",", "err", ":=", "GenerateV1Bytes", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "hexPsk", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "psk", ")", "*", "2", ")", "\n", "hex", ".", "Encode", "(", "hexPsk", ",", "psk", "[", ":", "]", ")", "\n\n", "// just a shortcut to NewReader", "nr", ":=", "func", "(", "b", "[", "]", "byte", ")", "io", ".", "Reader", "{", "return", "bytes", ".", "NewReader", "(", "b", ")", "\n", "}", "\n", "return", "io", ".", "MultiReader", "(", "nr", "(", "pathPSKv1", ")", ",", "newLine", "(", ")", ",", "nr", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", ",", "newLine", "(", ")", ",", "nr", "(", "hexPsk", ")", ")", ",", "nil", "\n", "}" ]

[ "GenerateV1PSK", "generates", "new", "PSK", "key", "that", "can", "be", "used", "with", "NewProtector" ]

[ "func", "NewProtector", "(", "input", "io", ".", "Reader", ")", "(", "ipnet", ".", "Protector", ",", "error", ")", "{", "psk", ",", "err", ":=", "decodeV1PSK", "(", "input", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "NewV1ProtectorFromBytes", "(", "psk", ")", "\n", "}" ]

[ "NewProtector", "creates", "ipnet", ".", "Protector", "instance", "from", "a", "io", ".", "Reader", "stream", "that", "should", "include", "Multicodec", "encoded", "V1", "PSK", "." ]

[ "func", "NewV1ProtectorFromBytes", "(", "psk", "*", "[", "32", "]", "byte", ")", "(", "ipnet", ".", "Protector", ",", "error", ")", "{", "return", "&", "protector", "{", "psk", ":", "psk", ",", "fingerprint", ":", "fingerprint", "(", "psk", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "NewV1ProtectorFromBytes", "creates", "ipnet", ".", "Protector", "of", "the", "V1", "version", "." ]

[ "func", "RegisterCertificateCheck", "(", "name", "string", ",", "filter", "*", "Filter", ",", "f", "func", "(", "*", "certdata", ".", "Data", ")", "*", "errors", ".", "Errors", ")", "{", "certMutex", ".", "Lock", "(", ")", "\n", "Certificate", "=", "append", "(", "Certificate", ",", "certificateCheck", "{", "name", ",", "filter", ",", "f", "}", ")", "\n", "certMutex", ".", "Unlock", "(", ")", "\n", "}" ]

[ "RegisterCertificateCheck", "adds", "a", "new", "check", "to", "Cerificates" ]

[ "func", "(", "c", "certificate", ")", "Check", "(", "d", "*", "certdata", ".", "Data", ")", "*", "errors", ".", "Errors", "{", "var", "e", "=", "errors", ".", "New", "(", "nil", ")", "\n\n", "for", "_", ",", "cc", ":=", "range", "c", "{", "if", "cc", ".", "filter", "!=", "nil", "&&", "!", "cc", ".", "filter", ".", "Check", "(", "d", ")", "{", "continue", "\n", "}", "\n", "e", ".", "Append", "(", "cc", ".", "f", "(", "d", ")", ")", "\n", "}", "\n\n", "return", "e", "\n", "}" ]

[ "Check", "runs", "all", "the", "registered", "certificate", "checks" ]

[ "func", "(", "l", "*", "Linter", ")", "CheckStruct", "(", "der", "[", "]", "byte", ")", "*", "errors", ".", "Errors", "{", "l", ".", "walk", "(", "der", ")", "\n", "if", "l", ".", "e", ".", "IsError", "(", ")", "{", "return", "&", "l", ".", "e", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckStruct", "returns", "a", "list", "of", "errors", "based", "on", "strict", "checks", "on", "the", "raw", "ASN1", "encoding", "of", "the", "input", "der", "." ]

[ "func", "(", "l", "*", "Linter", ")", "walk", "(", "der", "[", "]", "byte", ")", "{", "var", "err", "error", "\n", "var", "d", "asn1", ".", "RawValue", "\n\n", "for", "len", "(", "der", ")", ">", "0", "{", "der", ",", "err", "=", "asn1", ".", "Unmarshal", "(", "der", ",", "&", "d", ")", "\n", "if", "err", "!=", "nil", "{", "// Errors should be included in the report, but allow format checking when", "// data has been decoded.", "l", ".", "e", ".", "Err", "(", "err", ".", "Error", "(", ")", ")", "\n", "if", "len", "(", "d", ".", "Bytes", ")", "==", "0", "{", "return", "\n", "}", "\n", "}", "\n\n", "// A compound is an ASN.1 container that contains other structs.", "if", "d", ".", "IsCompound", "{", "l", ".", "walk", "(", "d", ".", "Bytes", ")", "\n", "}", "else", "{", "l", ".", "CheckFormat", "(", "d", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "walk", "is", "a", "recursive", "call", "that", "walks", "over", "the", "ASN1", "structured", "data", "until", "no", "remaining", "bytes", "are", "left", ".", "For", "each", "non", "compound", "it", "will", "call", "the", "ASN1", "format", "checker", "." ]

[ "func", "checkInternalName", "(", "fqdn", "string", ")", "bool", "{", "if", "ip", ":=", "net", ".", "ParseIP", "(", "fqdn", ")", ";", "ip", "!=", "nil", "{", "return", "checkInternalIP", "(", "ip", ")", "\n", "}", "\n\n", "suffix", ":=", "strings", ".", "Split", "(", "strings", ".", "ToLower", "(", "fqdn", ")", ",", "\"", "\"", ")", "\n", "_", ",", "icann", ":=", "psl", ".", "PublicSuffix", "(", "suffix", "[", "len", "(", "suffix", ")", "-", "1", "]", ")", "\n", "if", "icann", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "All", "official", "domain", "suffixes", "are", "registered", "by", "icann", "but", "because", "some", "subdomains", "are", "not", "only", "check", "against", "the", "last", "part", "of", "the", "fqdn", "." ]

[ "func", "Load", "(", "der", "[", "]", "byte", ")", "(", "*", "Data", ",", "error", ")", "{", "var", "err", "error", "\n\n", "d", ":=", "new", "(", "Data", ")", "\n", "d", ".", "Cert", ",", "err", "=", "x509", ".", "ParseCertificate", "(", "der", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "err", "=", "d", ".", "setCertificateType", "(", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "err", ")", "\n", "}", "\n\n", "return", "d", ",", "nil", "\n", "}" ]

[ "Load", "raw", "certificate", "bytes", "into", "a", "Data", "struct" ]

[ "func", "(", "e", "*", "Errors", ")", "List", "(", "p", "...", "Priority", ")", "[", "]", "Err", "{", "if", "len", "(", "p", ")", "==", "0", "{", "return", "e", ".", "err", "\n", "}", "\n\n", "// filter errors to given priorities", "var", "l", "[", "]", "Err", "\n", "for", "_", ",", "e", ":=", "range", "e", ".", "err", "{", "for", "_", ",", "priority", ":=", "range", "p", "{", "if", "e", ".", "p", "==", "priority", "{", "l", "=", "append", "(", "l", ",", "e", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "l", "\n", "}" ]

[ "List", "returns", "all", "errors", "of", "a", "given", "priority", "if", "no", "priority", "is", "given", "all", "errors", "are", "returned", "." ]

[ "func", "(", "e", "*", "Errors", ")", "Append", "(", "err", "*", "Errors", ")", "error", "{", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "e", ".", "m", ".", "Lock", "(", ")", "\n\n", "// append Errors at the end of the current list", "e", ".", "err", "=", "append", "(", "e", ".", "err", ",", "err", ".", "err", "...", ")", "\n\n", "// set highest priority", "if", "err", ".", "p", ">", "e", ".", "p", "{", "e", ".", "p", "=", "err", ".", "p", "\n", "}", "\n\n", "e", ".", "m", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Append", "add", "all", "Errors", "to", "existing", "Errors" ]

[ "func", "(", "e", "*", "Errors", ")", "Emerg", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "error", "{", "return", "e", ".", "add", "(", "Emergency", ",", "format", ",", "a", "...", ")", "\n", "}" ]

[ "Emerg", "log", "an", "error", "with", "severity", "Emergency" ]

[ "func", "(", "e", "*", "Errors", ")", "Alert", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "error", "{", "return", "e", ".", "add", "(", "Alert", ",", "format", ",", "a", "...", ")", "\n", "}" ]

[ "Alert", "log", "an", "error", "with", "severity", "Alert" ]

[ "func", "(", "e", "*", "Errors", ")", "Crit", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "error", "{", "return", "e", ".", "add", "(", "Critical", ",", "format", ",", "a", "...", ")", "\n", "}" ]

[ "Crit", "log", "an", "error", "with", "severity", "Critical" ]

[ "func", "(", "e", "*", "Errors", ")", "Err", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "error", "{", "return", "e", ".", "add", "(", "Error", ",", "format", ",", "a", "...", ")", "\n", "}" ]

[ "Err", "log", "an", "error", "with", "severity", "Error" ]

[ "func", "(", "e", "*", "Errors", ")", "Warning", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "error", "{", "return", "e", ".", "add", "(", "Warning", ",", "format", ",", "a", "...", ")", "\n", "}" ]

[ "Warning", "log", "an", "error", "with", "severity", "Warning" ]

[ "func", "(", "e", "*", "Errors", ")", "Notice", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "error", "{", "return", "e", ".", "add", "(", "Notice", ",", "format", ",", "a", "...", ")", "\n", "}" ]

[ "Notice", "log", "an", "error", "with", "severity", "Notice" ]

[ "func", "(", "e", "*", "Errors", ")", "Info", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "error", "{", "return", "e", ".", "add", "(", "Info", ",", "format", ",", "a", "...", ")", "\n", "}" ]

[ "Info", "log", "an", "error", "with", "severity", "Info" ]

[ "func", "(", "e", "*", "Errors", ")", "Debug", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "error", "{", "return", "e", ".", "add", "(", "Debug", ",", "format", ",", "a", "...", ")", "\n", "}" ]

[ "Debug", "log", "an", "error", "with", "severity", "Debug" ]

[ "func", "isNumericString", "(", "b", "[", "]", "byte", ")", "bool", "{", "for", "len", "(", "b", ")", ">", "0", "{", "r", ",", "size", ":=", "utf8", ".", "DecodeRune", "(", "b", ")", "\n", "if", "!", "unicode", ".", "IsNumber", "(", "r", ")", "&&", "!", "unicode", ".", "IsSpace", "(", "r", ")", "{", "return", "false", "\n", "}", "\n", "b", "=", "b", "[", "size", ":", "]", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "and", "SPACE" ]

[ "func", "isForbiddenString", "(", "b", "[", "]", "byte", ")", "bool", "{", "for", "len", "(", "b", ")", "==", "0", "{", "return", "false", "\n", "}", "\n\n", "switch", "strings", ".", "ToLower", "(", "string", "(", "b", ")", ")", "{", "case", "\"", "\"", ":", "return", "true", "\n", "}", "\n\n", "for", "len", "(", "b", ")", ">", "0", "{", "r", ",", "size", ":=", "utf8", ".", "DecodeRune", "(", "b", ")", "\n", "if", "!", "(", "(", "r", ">=", "32", "&&", "r", "<=", "47", ")", "||", "(", "r", ">=", "58", "&&", "r", "<=", "64", ")", "||", "(", "r", ">=", "91", "&&", "r", "<=", "96", ")", "||", "(", "r", ">=", "123", "&&", "r", "<=", "126", ")", ")", "{", "// non metadata character included in value", "return", "false", "\n", "}", "\n", "b", "=", "b", "[", "size", ":", "]", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "The", "BR", "state", "that", "attributes", "MUST", "NOT", "contain", "metadata", "such", "as", ".", "-", "this", "check", "implements", "a", "structure", "wide", "validation", "for", "values", "that", "indication", "that", "the", "field", "is", "absent", "incomplete", "or", "not", "applicable", ".", "ASCII", "range", "of", "forbidden", "metadata", "characters", "are", "32", "-", "47", "58", "-", "64", "91", "-", "96", "123", "-", "126", "if", "the", "value", "does", "only", "contain", "metadata", "this", "value", "is", "forbidden", ".", "This", "check", "does", "also", "detect", "double", "characters", "or", "any", "combination", "of", "metadata", "characters", "." ]

[ "func", "isControlCharacter", "(", "b", "[", "]", "byte", ")", "bool", "{", "for", "len", "(", "b", ")", ">", "0", "{", "r", ",", "size", ":=", "utf8", ".", "DecodeRune", "(", "b", ")", "\n", "if", "unicode", ".", "IsControl", "(", "r", ")", "||", "unicode", ".", "Is", "(", "unicode", ".", "C", ",", "r", ")", "{", "return", "true", "\n", "}", "\n", "b", "=", "b", "[", "size", ":", "]", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isControlCharacter", "checks", "if", "Control", "characters", "are", "included", "in", "the", "given", "bytes" ]

[ "func", "keyUsageString", "(", "ku", "x509", ".", "KeyUsage", ")", "string", "{", "switch", "ku", "{", "case", "x509", ".", "KeyUsageDigitalSignature", ":", "return", "\"", "\"", "\n", "case", "x509", ".", "KeyUsageContentCommitment", ":", "return", "\"", "\"", "\n", "case", "x509", ".", "KeyUsageKeyEncipherment", ":", "return", "\"", "\"", "\n", "case", "x509", ".", "KeyUsageDataEncipherment", ":", "return", "\"", "\"", "\n", "case", "x509", ".", "KeyUsageKeyAgreement", ":", "return", "\"", "\"", "\n", "case", "x509", ".", "KeyUsageCertSign", ":", "return", "\"", "\"", "\n", "case", "x509", ".", "KeyUsageCRLSign", ":", "return", "\"", "\"", "\n", "case", "x509", ".", "KeyUsageEncipherOnly", ":", "return", "\"", "\"", "\n", "case", "x509", ".", "KeyUsageDecipherOnly", ":", "return", "\"", "\"", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "keyUsageString", "returns", "the", "name", "of", "the", "keyusage", "as", "string" ]

[ "func", "(", "d", "*", "Data", ")", "setCertificateType", "(", ")", "error", "{", "// We want to be able to detect 'false' CA certificates, classify as CA", "// certificate is basic contains and key usage certsign are set.", "if", "d", ".", "Cert", ".", "IsCA", "&&", "d", ".", "Cert", ".", "KeyUsage", "&", "x509", ".", "KeyUsageCertSign", "!=", "0", "{", "d", ".", "Type", "=", "\"", "\"", "\n", "return", "nil", "\n", "}", "\n\n", "// The fallback type is used when a certificate could be any of a range", "// but further checks need to define the exact type. When these checks fail", "// the fallback type is used.", "var", "fallbackType", "string", "\n\n", "// Based on ExtKeyUsage", "for", "_", ",", "ku", ":=", "range", "d", ".", "Cert", ".", "ExtKeyUsage", "{", "switch", "ku", "{", "case", "x509", ".", "ExtKeyUsageServerAuth", ":", "// Try to determine certificate type via policy oid", "d", ".", "Type", "=", "getType", "(", "d", ".", "Cert", ".", "PolicyIdentifiers", ")", "\n", "fallbackType", "=", "\"", "\"", "\n", "case", "x509", ".", "ExtKeyUsageClientAuth", ":", "fallbackType", "=", "\"", "\"", "\n", "case", "x509", ".", "ExtKeyUsageEmailProtection", ":", "d", ".", "Type", "=", "\"", "\"", "\n", "case", "x509", ".", "ExtKeyUsageCodeSigning", ":", "d", ".", "Type", "=", "\"", "\"", "\n", "case", "x509", ".", "ExtKeyUsageTimeStamping", ":", "d", ".", "Type", "=", "\"", "\"", "\n", "case", "x509", ".", "ExtKeyUsageOCSPSigning", ":", "d", ".", "Type", "=", "\"", "\"", "\n", "}", "\n", "}", "\n\n", "// If we have no known key usage, try the policy list again", "if", "d", ".", "Type", "==", "\"", "\"", "{", "d", ".", "Type", "=", "getType", "(", "d", ".", "Cert", ".", "PolicyIdentifiers", ")", "\n", "}", "\n\n", "// When determined by Policy Identifier we can stop", "if", "d", ".", "Type", "!=", "\"", "\"", "{", "return", "nil", "\n", "}", "\n\n", "// Based on UnknownExtKeyUsage", "for", "_", ",", "ku", ":=", "range", "d", ".", "Cert", ".", "UnknownExtKeyUsage", "{", "switch", "{", "case", "ku", ".", "Equal", "(", "asn1", ".", "ObjectIdentifier", "{", "1", ",", "3", ",", "6", ",", "1", ",", "4", ",", "1", ",", "311", ",", "21", ",", "19", "}", ")", ":", "// dsEmailReplication", "d", ".", "Type", "=", "\"", "\"", "\n", "return", "nil", "\n", "case", "ku", ".", "Equal", "(", "asn1", ".", "ObjectIdentifier", "{", "1", ",", "3", ",", "6", ",", "1", ",", "5", ",", "5", ",", "8", ",", "2", ",", "2", "}", ")", ":", "// IPSEC Protection", "d", ".", "Type", "=", "\"", "\"", "\n", "return", "nil", "\n", "}", "\n", "}", "\n\n", "// Check if the e-mailAddress is set in the DN", "for", "_", ",", "n", ":=", "range", "d", ".", "Cert", ".", "Subject", ".", "Names", "{", "switch", "{", "case", "n", ".", "Type", ".", "Equal", "(", "asn1", ".", "ObjectIdentifier", "{", "1", ",", "2", ",", "840", ",", "113549", ",", "1", ",", "9", ",", "1", "}", ")", ":", "// e-mailAddress", "d", ".", "Type", "=", "\"", "\"", "\n", "return", "nil", "\n", "}", "\n", "}", "\n\n", "// An @ sing in the common name is often used in PS.", "if", "strings", ".", "Contains", "(", "d", ".", "Cert", ".", "Subject", ".", "CommonName", ",", "\"", "\"", ")", "{", "d", ".", "Type", "=", "\"", "\"", "\n", "return", "nil", "\n", "}", "else", "if", "strings", ".", "Contains", "(", "d", ".", "Cert", ".", "Subject", ".", "CommonName", ",", "\"", "\"", ")", "{", "d", ".", "Type", "=", "\"", "\"", "\n", "return", "nil", "\n", "}", "\n\n", "// If it's a fqdn, it's a EV, OV or DV", "if", "suffix", ",", "_", ":=", "psl", ".", "PublicSuffix", "(", "strings", ".", "ToLower", "(", "d", ".", "Cert", ".", "Subject", ".", "CommonName", ")", ")", ";", "len", "(", "suffix", ")", ">", "0", "{", "if", "len", "(", "d", ".", "Cert", ".", "Subject", ".", "Organization", ")", ">", "0", "{", "if", "len", "(", "d", ".", "Cert", ".", "Subject", ".", "SerialNumber", ")", ">", "0", "{", "d", ".", "Type", "=", "\"", "\"", "\n", "return", "nil", "\n", "}", "\n\n", "d", ".", "Type", "=", "\"", "\"", "\n", "return", "nil", "\n", "}", "\n\n", "d", ".", "Type", "=", "\"", "\"", "\n", "return", "nil", "\n", "}", "\n\n", "if", "len", "(", "fallbackType", ")", ">", "0", "{", "d", ".", "Type", "=", "fallbackType", "\n", "return", "nil", "\n", "}", "\n\n", "if", "d", ".", "Type", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "setCertificateType", "set", "the", "base", "on", "how", "we", "check", "for", "other", "requirements", "of", "the", "certificate", ".", "It", "s", "important", "that", "we", "reliably", "identify", "the", "purpose", "to", "apply", "the", "right", "checks", "for", "that", "certificate", "type", "." ]

[ "func", "(", "f", "*", "Filter", ")", "Check", "(", "d", "*", "certdata", ".", "Data", ")", "bool", "{", "// Is certificate recognised as one of the given types", "if", "len", "(", "f", ".", "Type", ")", ">", "0", "{", "var", "inFilter", "bool", "\n", "for", "_", ",", "t", ":=", "range", "f", ".", "Type", "{", "if", "d", ".", "Type", "==", "t", "{", "inFilter", "=", "true", "\n", "}", "\n", "}", "\n", "if", "!", "inFilter", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "// Issued before given date", "if", "f", ".", "IssuedBefore", "!=", "nil", "&&", "!", "d", ".", "Cert", ".", "NotBefore", ".", "Before", "(", "*", "f", ".", "IssuedBefore", ")", "{", "return", "false", "\n", "}", "\n", "// Issued after given date", "if", "f", ".", "IssuedAfter", "!=", "nil", "&&", "!", "d", ".", "Cert", ".", "NotBefore", ".", "After", "(", "*", "f", ".", "IssuedAfter", ")", "{", "return", "false", "\n", "}", "\n", "// Expires before given date", "if", "f", ".", "ExpiresBefore", "!=", "nil", "&&", "!", "d", ".", "Cert", ".", "NotBefore", ".", "Before", "(", "*", "f", ".", "ExpiresBefore", ")", "{", "return", "false", "\n", "}", "\n", "// Expires after given date", "if", "f", ".", "ExpiresAfter", "!=", "nil", "&&", "!", "d", ".", "Cert", ".", "NotAfter", ".", "After", "(", "*", "f", ".", "ExpiresAfter", ")", "{", "return", "false", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "Check", "returns", "true", "if", "a", "certificate", "complies", "with", "the", "given", "filter" ]

[ "func", "RegisterExtensionCheck", "(", "name", "string", ",", "oid", "asn1", ".", "ObjectIdentifier", ",", "filter", "*", "Filter", ",", "f", "func", "(", "pkix", ".", "Extension", ",", "*", "certdata", ".", "Data", ")", "*", "errors", ".", "Errors", ")", "{", "extMutex", ".", "Lock", "(", ")", "\n", "Extensions", "=", "append", "(", "Extensions", ",", "extensionCheck", "{", "name", ",", "oid", ",", "filter", ",", "f", "}", ")", "\n", "extMutex", ".", "Unlock", "(", ")", "\n", "}" ]

[ "RegisterExtensionCheck", "adds", "a", "new", "check", "to", "Extensions" ]

[ "func", "(", "ex", "extensions", ")", "Check", "(", "ext", "pkix", ".", "Extension", ",", "d", "*", "certdata", ".", "Data", ")", "*", "errors", ".", "Errors", "{", "var", "e", "=", "errors", ".", "New", "(", "nil", ")", "\n", "var", "found", "bool", "\n\n", "for", "_", ",", "ec", ":=", "range", "ex", "{", "if", "ec", ".", "oid", ".", "Equal", "(", "ext", ".", "Id", ")", "{", "found", "=", "true", "\n", "if", "ec", ".", "filter", "!=", "nil", "&&", "ec", ".", "filter", ".", "Check", "(", "d", ")", "{", "continue", "\n", "}", "\n", "e", ".", "Append", "(", "ec", ".", "f", "(", "ext", ",", "d", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "!", "found", "{", "// Don't report private enterprise extensions as unknown, registered private", "// extensions have still been checked above.", "if", "!", "strings", ".", "HasPrefix", "(", "ext", ".", "Id", ".", "String", "(", ")", ",", "\"", "\"", ")", "{", "e", ".", "Warning", "(", "\"", "\"", ",", "ext", ".", "Id", ".", "String", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "e", "\n", "}" ]

[ "Check", "lookups", "the", "registered", "extension", "checks", "and", "runs", "all", "checks", "with", "the", "same", "Object", "Identifier", "." ]

[ "func", "(", "policy", "*", "KeyPolicy", ")", "goodKeyECDSA", "(", "key", "ecdsa", ".", "PublicKey", ")", "(", "err", "error", ")", "{", "// Check the curve.", "//", "// The validity of the curve is an assumption for all following tests.", "err", "=", "policy", ".", "goodCurve", "(", "key", ".", "Curve", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Key validation routine adapted from NIST SP800-56A § 5.6.2.3.2.", "// <http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar2.pdf>", "//", "// Assuming a prime field since a) we are only allowing such curves and b)", "// crypto/elliptic only supports prime curves. Where this assumption", "// simplifies the code below, it is explicitly stated and explained. If ever", "// adapting this code to support non-prime curves, refer to NIST SP800-56A §", "// 5.6.2.3.2 and adapt this code appropriately.", "params", ":=", "key", ".", "Params", "(", ")", "\n\n", "// SP800-56A § 5.6.2.3.2 Step 1.", "// Partial check of the public key for an invalid range in the EC group:", "// Verify that key is not the point at infinity O.", "// This code assumes that the point at infinity is (0,0), which is the", "// case for all supported curves.", "if", "isPointAtInfinityNISTP", "(", "key", ".", "X", ",", "key", ".", "Y", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// SP800-56A § 5.6.2.3.2 Step 2.", "// \"Verify that x_Q and y_Q are integers in the interval [0,p-1] in the", "// case that q is an odd prime p, or that x_Q and y_Q are bit strings", "// of length m bits in the case that q = 2**m.\"", "//", "// Prove prime field: ASSUMED.", "// Prove q != 2: ASSUMED. (Curve parameter. No supported curve has q == 2.)", "// Prime field && q != 2 => q is an odd prime p", "// Therefore \"verify that x, y are in [0, p-1]\" satisfies step 2.", "//", "// Therefore verify that both x and y of the public key point have the unique", "// correct representation of an element in the underlying field by verifying", "// that x and y are integers in [0, p-1].", "if", "key", ".", "X", ".", "Sign", "(", ")", "<", "0", "||", "key", ".", "Y", ".", "Sign", "(", ")", "<", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "key", ".", "X", ".", "Cmp", "(", "params", ".", "P", ")", ">=", "0", "||", "key", ".", "Y", ".", "Cmp", "(", "params", ".", "P", ")", ">=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// SP800-56A § 5.6.2.3.2 Step 3.", "// \"If q is an odd prime p, verify that (y_Q)**2 === (x_Q)***3 + a*x_Q + b (mod p).", "// If q = 2**m, verify that (y_Q)**2 + (x_Q)*(y_Q) == (x_Q)**3 + a*(x_Q)*2 + b in", "// the finite field of size 2**m.", "// (Ensures that the public key is on the correct elliptic curve.)\"", "//", "// q is an odd prime p: proven/assumed above.", "// a = -3 for all supported curves.", "//", "// Therefore step 3 is satisfied simply by showing that", "// y**2 === x**3 - 3*x + B (mod P).", "//", "// This proves that the public key is on the correct elliptic curve.", "// But in practice, this test is provided by crypto/elliptic, so use that.", "if", "!", "key", ".", "Curve", ".", "IsOnCurve", "(", "key", ".", "X", ",", "key", ".", "Y", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// SP800-56A § 5.6.2.3.2 Step 4.", "// \"Verify that n*Q == O.", "// (Ensures that the public key has the correct order. Along with check 1,", "// ensures that the public key is in the correct range in the correct EC", "// subgroup, that is, it is in the correct EC subgroup and is not the", "// identity element.)\"", "//", "// Ensure that public key has the correct order:", "// verify that n*Q = O.", "//", "// n*Q = O iff n*Q is the point at infinity (see step 1).", "ox", ",", "oy", ":=", "key", ".", "Curve", ".", "ScalarMult", "(", "key", ".", "X", ",", "key", ".", "Y", ",", "params", ".", "N", ".", "Bytes", "(", ")", ")", "\n", "if", "!", "isPointAtInfinityNISTP", "(", "ox", ",", "oy", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// End of SP800-56A § 5.6.2.3.2 Public Key Validation Routine.", "// Key is valid.", "return", "nil", "\n", "}" ]

[ "GoodKeyECDSA", "determines", "if", "an", "ECDSA", "pubkey", "meets", "our", "requirements" ]

[ "func", "getCertificate", "(", "file", "string", ")", "[", "]", "byte", "{", "derBytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "file", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "// decode pem", "block", ",", "_", ":=", "pem", ".", "Decode", "(", "derBytes", ")", "\n", "if", "block", "!=", "nil", "{", "derBytes", "=", "block", ".", "Bytes", "\n", "}", "\n", "return", "derBytes", "\n", "}" ]

[ "getCertificate", "reads", "a", "single", "certificate", "from", "disk" ]

[ "func", "(", "ch", "*", "Chunk", ")", "Read", "(", "p", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "if", "ch", "==", "nil", "||", "ch", ".", "R", "==", "nil", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "n", ",", "err", "=", "ch", ".", "R", ".", "Read", "(", "p", ")", "\n", "ch", ".", "Pos", "+=", "n", "\n", "return", "n", ",", "err", "\n", "}" ]

[ "Read", "implements", "the", "reader", "interface" ]

[ "func", "(", "ch", "*", "Chunk", ")", "ReadLE", "(", "dst", "interface", "{", "}", ")", "error", "{", "if", "ch", "==", "nil", "||", "ch", ".", "R", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "ch", ".", "IsFullyRead", "(", ")", "{", "return", "io", ".", "EOF", "\n", "}", "\n", "ch", ".", "Pos", "+=", "binary", ".", "Size", "(", "dst", ")", "\n", "return", "binary", ".", "Read", "(", "ch", ".", "R", ",", "binary", ".", "LittleEndian", ",", "dst", ")", "\n", "}" ]

[ "ReadLE", "reads", "the", "Little", "Endian", "chunk", "data", "into", "the", "passed", "struct" ]

[ "func", "(", "ch", "*", "Chunk", ")", "ReadByte", "(", ")", "(", "byte", ",", "error", ")", "{", "if", "ch", ".", "IsFullyRead", "(", ")", "{", "return", "0", ",", "io", ".", "EOF", "\n", "}", "\n", "var", "r", "byte", "\n", "err", ":=", "ch", ".", "ReadLE", "(", "&", "r", ")", "\n", "return", "r", ",", "err", "\n", "}" ]

[ "ReadByte", "reads", "and", "returns", "a", "single", "byte" ]

[ "func", "(", "ch", "*", "Chunk", ")", "IsFullyRead", "(", ")", "bool", "{", "if", "ch", "==", "nil", "||", "ch", ".", "R", "==", "nil", "{", "return", "true", "\n", "}", "\n", "return", "ch", ".", "Size", "<=", "ch", ".", "Pos", "\n", "}" ]

[ "IsFullyRead", "checks", "if", "we", "re", "finished", "reading", "the", "chunk" ]

[ "func", "(", "ch", "*", "Chunk", ")", "Jump", "(", "bytesAhead", "int", ")", "error", "{", "var", "err", "error", "\n", "var", "n", "int64", "\n", "if", "bytesAhead", ">", "0", "{", "n", ",", "err", "=", "io", ".", "CopyN", "(", "ioutil", ".", "Discard", ",", "ch", ".", "R", ",", "int64", "(", "bytesAhead", ")", ")", "\n", "ch", ".", "Pos", "+=", "int", "(", "n", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Jump", "jumps", "ahead", "in", "the", "chunk" ]

[ "func", "(", "f", "*", "Frame", ")", "Duration", "(", ")", "time", ".", "Duration", "{", "if", "!", "f", ".", "Header", ".", "IsValid", "(", ")", "{", "return", "0", "\n", "}", "\n", "ms", ":=", "(", "1000", "/", "float64", "(", "f", ".", "Header", ".", "SampleRate", "(", ")", ")", ")", "*", "float64", "(", "f", ".", "Header", ".", "Samples", "(", ")", ")", "\n", "dur", ":=", "time", ".", "Duration", "(", "int", "(", "float64", "(", "time", ".", "Millisecond", ")", "*", "ms", ")", ")", "\n", "if", "dur", "<", "0", "{", "// we have bad data, let's ignore it", "dur", "=", "0", "\n", "}", "\n", "return", "dur", "\n", "}" ]

[ "Duration", "calculates", "the", "time", "duration", "of", "this", "frame", "based", "on", "the", "samplerate", "and", "number", "of", "samples" ]

[ "func", "(", "f", "*", "Frame", ")", "CRC", "(", ")", "uint16", "{", "var", "crc", "uint16", "\n", "if", "!", "f", ".", "Header", ".", "Protection", "(", ")", "{", "return", "0", "\n", "}", "\n", "crcdata", ":=", "bytes", ".", "NewReader", "(", "f", ".", "buf", "[", "4", ":", "6", "]", ")", "\n", "binary", ".", "Read", "(", "crcdata", ",", "binary", ".", "BigEndian", ",", "&", "crc", ")", "\n", "return", "crc", "\n", "}" ]

[ "CRC", "returns", "the", "CRC", "word", "stored", "in", "this", "frame" ]

[ "func", "(", "f", "*", "Frame", ")", "SideInfo", "(", ")", "FrameSideInfo", "{", "if", "f", ".", "Header", ".", "Protection", "(", ")", "{", "return", "FrameSideInfo", "(", "f", ".", "buf", "[", "6", ":", "]", ")", "\n", "}", "else", "{", "return", "FrameSideInfo", "(", "f", ".", "buf", "[", "4", ":", "]", ")", "\n", "}", "\n", "}" ]

[ "SideInfo", "returns", "the", "side", "info", "for", "this", "frame" ]

[ "func", "(", "f", "*", "Frame", ")", "String", "(", ")", "string", "{", "str", ":=", "\"", "\"", "\n", "str", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "f", ".", "Header", ")", "\n", "str", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "f", ".", "CRC", "(", ")", ")", "\n", "str", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "f", ".", "Header", ".", "Samples", "(", ")", ")", "\n", "str", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "f", ".", "Header", ".", "Size", "(", ")", ")", "\n", "str", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "f", ".", "Duration", "(", ")", ")", "\n", "return", "str", "\n", "}" ]

[ "Frame", "returns", "a", "string", "describing", "this", "frame", "header", "and", "side", "info" ]

[ "func", "EncodeVarint", "(", "x", "uint32", ")", "[", "]", "byte", "{", "if", "x", ">>", "7", "==", "0", "{", "return", "[", "]", "byte", "{", "byte", "(", "x", ")", ",", "}", "\n", "}", "\n\n", "if", "x", ">>", "14", "==", "0", "{", "return", "[", "]", "byte", "{", "byte", "(", "0x80", "|", "x", ">>", "7", ")", ",", "byte", "(", "127", "&", "x", ")", ",", "}", "\n", "}", "\n\n", "if", "x", ">>", "21", "==", "0", "{", "return", "[", "]", "byte", "{", "byte", "(", "0x80", "|", "x", ">>", "14", ")", ",", "byte", "(", "0x80", "|", "x", ">>", "7", ")", ",", "byte", "(", "127", "&", "x", ")", ",", "}", "\n", "}", "\n\n", "return", "[", "]", "byte", "{", "byte", "(", "0x80", "|", "x", ">>", "21", ")", ",", "byte", "(", "0x80", "|", "x", ">>", "14", ")", ",", "byte", "(", "0x80", "|", "x", ">>", "7", ")", ",", "byte", "(", "127", "&", "x", ")", ",", "}", "\n", "}" ]

[ "EncodeVarint", "returns", "the", "varint", "encoding", "of", "x", "." ]

[ "func", "DecodeVarint", "(", "buf", "[", "]", "byte", ")", "(", "x", "uint32", ",", "n", "int", ")", "{", "if", "len", "(", "buf", ")", "<", "1", "{", "return", "0", ",", "0", "\n", "}", "\n\n", "if", "buf", "[", "0", "]", "<=", "0x80", "{", "return", "uint32", "(", "buf", "[", "0", "]", ")", ",", "1", "\n", "}", "\n\n", "var", "b", "byte", "\n", "for", "n", ",", "b", "=", "range", "buf", "{", "x", "=", "x", "<<", "7", "\n", "x", "|=", "uint32", "(", "b", ")", "&", "0x7F", "\n", "if", "(", "b", "&", "0x80", ")", "==", "0", "{", "return", "x", ",", "n", "\n", "}", "\n", "}", "\n\n", "return", "x", ",", "n", "\n", "}" ]

[ "DecodeVarint", "reads", "a", "varint", "-", "encoded", "integer", "from", "the", "slice", ".", "It", "returns", "the", "integer", "and", "the", "number", "of", "bytes", "consumed", "or", "zero", "if", "there", "is", "not", "enough", "." ]

[ "func", "Quantize", "(", "buf", "*", "audio", ".", "PCMBuffer", ",", "bitDepth", "int", ")", "{", "if", "buf", "==", "nil", "{", "return", "\n", "}", "\n", "max", ":=", "math", ".", "Pow", "(", "2", ",", "float64", "(", "bitDepth", ")", ")", "-", "1", "\n\n", "buf", ".", "SwitchPrimaryType", "(", "audio", ".", "Float", ")", "\n", "bufLen", ":=", "buf", ".", "Len", "(", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "bufLen", ";", "i", "++", "{", "buf", ".", "Floats", "[", "i", "]", "=", "round", "(", "(", "buf", ".", "Floats", "[", "i", "]", "+", "1", ")", "*", "max", ")", "/", "max", "-", "1.0", "\n", "}", "\n", "}" ]

[ "Quantize", "quantizes", "the", "audio", "signal", "to", "match", "the", "target", "bitDepth" ]

[ "func", "Decimate", "(", "buf", "*", "audio", ".", "PCMBuffer", ",", "factor", "int", ")", "(", "err", "error", ")", "{", "if", "buf", "==", "nil", "||", "buf", ".", "Format", "==", "nil", "{", "return", "audio", ".", "ErrInvalidBuffer", "\n", "}", "\n\n", "if", "factor", "<", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// apply a low pass filter at the nyquist frequency to avoid", "// aliasing.", "if", "err", ":=", "filters", ".", "LowPass", "(", "buf", ",", "float64", "(", "buf", ".", "Format", ".", "SampleRate", ")", "/", "2", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// drop samples to match the decimation factor", "newLength", ":=", "len", "(", "buf", ".", "Floats", ")", "/", "factor", "\n", "for", "i", ":=", "0", ";", "i", "<", "newLength", ";", "i", "++", "{", "buf", ".", "Floats", "[", "i", "]", "=", "buf", ".", "Floats", "[", "i", "*", "factor", "]", "\n", "}", "\n", "buf", ".", "Floats", "=", "buf", ".", "Floats", "[", ":", "newLength", "]", "\n", "buf", ".", "Format", ".", "SampleRate", "/=", "factor", "\n\n", "return", "nil", "\n", "}" ]

[ "Decimate", "drops", "samples", "to", "switch", "to", "a", "lower", "sample", "rate", ".", "Factor", "is", "the", "decimation", "factor", "for", "instance", "a", "factor", "of", "2", "of", "a", "44100Hz", "buffer", "will", "convert", "the", "buffer", "in", "a", "22500", "buffer", "." ]

[ "func", "AvgInt", "(", "xs", "...", "int", ")", "int", "{", "var", "output", "int", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "xs", ")", ";", "i", "++", "{", "output", "+=", "xs", "[", "i", "]", "\n", "}", "\n", "return", "output", "/", "len", "(", "xs", ")", "\n", "}" ]

[ "AvgInt", "averages", "the", "int", "values", "passed" ]

[ "func", "IeeeFloatToInt", "(", "b", "[", "10", "]", "byte", ")", "int", "{", "var", "i", "uint32", "\n", "// Negative number", "if", "(", "b", "[", "0", "]", "&", "0x80", ")", "==", "1", "{", "return", "0", "\n", "}", "\n\n", "// Less than 1", "if", "b", "[", "0", "]", "<=", "0x3F", "{", "return", "1", "\n", "}", "\n\n", "// Too big", "if", "b", "[", "0", "]", ">", "0x40", "{", "return", "67108864", "\n", "}", "\n\n", "// Still too big", "if", "b", "[", "0", "]", "==", "0x40", "&&", "b", "[", "1", "]", ">", "0x1C", "{", "return", "800000000", "\n", "}", "\n\n", "i", "=", "(", "uint32", "(", "b", "[", "2", "]", ")", "<<", "23", ")", "|", "(", "uint32", "(", "b", "[", "3", "]", ")", "<<", "15", ")", "|", "(", "uint32", "(", "b", "[", "4", "]", ")", "<<", "7", ")", "|", "(", "uint32", "(", "b", "[", "5", "]", ")", ">>", "1", ")", "\n", "i", ">>=", "(", "29", "-", "uint32", "(", "b", "[", "1", "]", ")", ")", "\n\n", "return", "int", "(", "i", ")", "\n", "}" ]

[ "IeeeFloatToInt", "converts", "a", "10", "byte", "IEEE", "float", "into", "an", "int", "." ]

[ "func", "(", "d", "*", "Decoder", ")", "Duration", "(", ")", "(", "time", ".", "Duration", ",", "error", ")", "{", "if", "d", "==", "nil", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "d", ".", "ReadInfo", "(", ")", "\n", "if", "err", ":=", "d", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "duration", ":=", "time", ".", "Duration", "(", "float64", "(", "d", ".", "NumSampleFrames", ")", "/", "float64", "(", "d", ".", "SampleRate", ")", "*", "float64", "(", "time", ".", "Second", ")", ")", "\n", "return", "duration", ",", "nil", "\n", "}" ]

[ "Duration", "returns", "the", "time", "duration", "for", "the", "current", "AIFF", "container" ]

[ "func", "(", "d", "*", "Decoder", ")", "iDnSize", "(", ")", "(", "[", "4", "]", "byte", ",", "uint32", ",", "error", ")", "{", "var", "ID", "[", "4", "]", "byte", "\n", "var", "blockSize", "uint32", "\n", "if", "d", ".", "err", "=", "binary", ".", "Read", "(", "d", ".", "r", ",", "binary", ".", "BigEndian", ",", "&", "ID", ")", ";", "d", ".", "err", "!=", "nil", "{", "return", "ID", ",", "blockSize", ",", "d", ".", "err", "\n", "}", "\n", "if", "d", ".", "err", "=", "binary", ".", "Read", "(", "d", ".", "r", ",", "binary", ".", "BigEndian", ",", "&", "blockSize", ")", ";", "d", ".", "err", "!=", "nil", "{", "return", "ID", ",", "blockSize", ",", "d", ".", "err", "\n", "}", "\n", "return", "ID", ",", "blockSize", ",", "nil", "\n", "}" ]

[ "iDnSize", "returns", "the", "next", "ID", "+", "block", "size" ]

[ "func", "(", "d", "*", "Decoder", ")", "ReadInfo", "(", ")", "{", "if", "d", "==", "nil", "||", "d", ".", "SampleRate", ">", "0", "{", "return", "\n", "}", "\n", "if", "d", ".", "err", "=", "d", ".", "readHeaders", "(", ")", ";", "d", ".", "err", "!=", "nil", "{", "d", ".", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "d", ".", "err", ")", "\n", "return", "\n", "}", "\n\n", "var", "(", "id", "[", "4", "]", "byte", "\n", "size", "uint32", "\n", "rewindBytes", "int64", "\n", ")", "\n", "for", "d", ".", "err", "!=", "io", ".", "EOF", "{", "id", ",", "size", ",", "d", ".", "err", "=", "d", ".", "iDnSize", "(", ")", "\n", "if", "d", ".", "err", "!=", "nil", "{", "d", ".", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "d", ".", "err", ")", "\n", "break", "\n", "}", "\n", "switch", "id", "{", "case", "COMMID", ":", "d", ".", "parseCommChunk", "(", "size", ")", "\n", "// if we found other chunks before the COMM,", "// we need to rewind the reader so we can properly", "// read the rest later.", "if", "rewindBytes", ">", "0", "{", "d", ".", "r", ".", "Seek", "(", "-", "(", "rewindBytes", "+", "int64", "(", "size", ")", ")", ",", "1", ")", "\n", "break", "\n", "}", "\n", "return", "\n", "default", ":", "// we haven't read the COMM chunk yet, we need to track location to rewind", "if", "d", ".", "SampleRate", "==", "0", "{", "rewindBytes", "+=", "int64", "(", "size", ")", "\n", "}", "\n", "if", "d", ".", "err", "=", "d", ".", "jumpTo", "(", "int", "(", "size", ")", ")", ";", "d", ".", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "ReadInfo", "reads", "the", "underlying", "reader", "until", "the", "comm", "header", "is", "parsed", ".", "This", "method", "is", "safe", "to", "call", "multiple", "times", "." ]

[ "func", "(", "d", "*", "Decoder", ")", "VarLen", "(", ")", "(", "val", "uint32", ",", "readBytes", "uint32", ",", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "}", "\n", "var", "lastByte", "bool", "\n", "var", "n", "uint32", "\n\n", "for", "!", "lastByte", "{", "b", ",", "err", ":=", "d", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "n", ",", "err", "\n", "}", "\n", "buf", "=", "append", "(", "buf", ",", "b", ")", "\n", "lastByte", "=", "(", "b", ">>", "7", "==", "0x0", ")", "\n", "n", "++", "\n", "}", "\n\n", "val", ",", "nUsed", ":=", "DecodeVarint", "(", "buf", ")", "\n", "return", "val", ",", "uint32", "(", "nUsed", ")", ",", "nil", "\n", "}" ]

[ "VarLen", "returns", "the", "variable", "length", "value", "at", "the", "exact", "parser", "location", "." ]

[ "func", "(", "d", "*", "Decoder", ")", "VarLenTxt", "(", ")", "(", "string", ",", "uint32", ",", "error", ")", "{", "var", "l", "uint32", "\n", "var", "err", "error", "\n", "var", "n", "uint32", "\n\n", "if", "l", ",", "n", ",", "err", "=", "d", ".", "VarLen", "(", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "n", ",", "err", "\n", "}", "\n", "buf", ":=", "make", "(", "[", "]", "byte", ",", "l", ")", "\n", "err", "=", "d", ".", "Read", "(", "buf", ")", "\n", "return", "string", "(", "buf", ")", ",", "n", ",", "err", "\n", "}" ]

[ "VarLengthTxt", "Returns", "a", "variable", "length", "text", "string", "as", "well", "as", "the", "amount", "of", "bytes", "read" ]

[ "func", "(", "d", "*", "Decoder", ")", "Read", "(", "dst", "interface", "{", "}", ")", "error", "{", "return", "binary", ".", "Read", "(", "d", ".", "r", ",", "binary", ".", "BigEndian", ",", "dst", ")", "\n", "}" ]

[ "read", "reads", "n", "bytes", "from", "the", "parser", "s", "reader", "and", "stores", "them", "into", "the", "provided", "dst", "which", "must", "be", "a", "pointer", "to", "a", "fixed", "-", "size", "value", "." ]

[ "func", "(", "d", "*", "Decoder", ")", "Uint7", "(", ")", "(", "uint8", ",", "error", ")", "{", "b", ",", "err", ":=", "d", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "(", "b", "&", "0x7f", ")", ",", "nil", "\n", "}" ]

[ "Uint7", "reads", "a", "byte", "and", "converts", "the", "first", "7", "bits", "into", "an", "uint8" ]

[ "func", "(", "d", "*", "Decoder", ")", "Uint24", "(", ")", "(", "uint32", ",", "error", ")", "{", "bytes", ":=", "make", "(", "[", "]", "byte", ",", "3", ")", "\n", "if", "err", ":=", "d", ".", "Read", "(", "bytes", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "var", "output", "uint32", "\n", "output", "|=", "uint32", "(", "bytes", "[", "2", "]", ")", "<<", "0", "\n", "output", "|=", "uint32", "(", "bytes", "[", "1", "]", ")", "<<", "8", "\n", "output", "|=", "uint32", "(", "bytes", "[", "0", "]", ")", "<<", "16", "\n\n", "return", "output", ",", "nil", "\n", "}" ]

[ "Uint24", "reads", "3", "bytes", "and", "convert", "them", "into", "a", "uint32" ]

[ "func", "(", "c", "*", "Parser", ")", "ParseHeaders", "(", ")", "error", "{", "id", ",", "size", ",", "err", ":=", "c", ".", "IDnSize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "c", ".", "ID", "=", "id", "\n", "if", "c", ".", "ID", "!=", "RiffID", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "ID", ",", "ErrFmtNotSupported", ")", "\n", "}", "\n", "c", ".", "Size", "=", "size", "\n", "if", "err", ":=", "binary", ".", "Read", "(", "c", ".", "r", ",", "binary", ".", "BigEndian", ",", "&", "c", ".", "Format", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ParseHeaders", "reads", "the", "header", "of", "the", "passed", "container", "and", "populat", "the", "container", "with", "parsed", "info", ".", "Note", "that", "this", "code", "advances", "the", "container", "reader", "." ]

[ "func", "(", "c", "*", "Parser", ")", "NextChunk", "(", ")", "(", "*", "Chunk", ",", "error", ")", "{", "if", "c", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "id", ",", "size", ",", "err", ":=", "c", ".", "IDnSize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// all RIFF chunks (including WAVE \"data\" chunks) must be word aligned.", "// If the data uses an odd number of bytes, a padding byte with a value of zero must be placed at the end of the sample data.", "// The \"data\" chunk header's size should not include this byte.", "if", "size", "%", "2", "==", "1", "{", "size", "++", "\n", "}", "\n\n", "ch", ":=", "&", "Chunk", "{", "ID", ":", "id", ",", "Size", ":", "int", "(", "size", ")", ",", "R", ":", "c", ".", "r", ",", "}", "\n", "return", "ch", ",", "nil", "\n", "}" ]

[ "NextChunk", "returns", "a", "convenient", "structure", "to", "parse", "the", "next", "chunk", ".", "If", "the", "container", "is", "fully", "read", "io", ".", "EOF", "is", "returned", "as", "an", "error", "." ]

[ "func", "(", "c", "*", "Parser", ")", "IDnSize", "(", ")", "(", "[", "4", "]", "byte", ",", "uint32", ",", "error", ")", "{", "var", "ID", "[", "4", "]", "byte", "\n", "var", "blockSize", "uint32", "\n", "if", "err", ":=", "binary", ".", "Read", "(", "c", ".", "r", ",", "binary", ".", "BigEndian", ",", "&", "ID", ")", ";", "err", "!=", "nil", "{", "return", "ID", ",", "blockSize", ",", "err", "\n", "}", "\n", "if", "err", ":=", "binary", ".", "Read", "(", "c", ".", "r", ",", "binary", ".", "LittleEndian", ",", "&", "blockSize", ")", ";", "err", "!=", "err", "{", "return", "ID", ",", "blockSize", ",", "err", "\n", "}", "\n", "return", "ID", ",", "blockSize", ",", "nil", "\n", "}" ]

[ "IDnSize", "returns", "the", "next", "ID", "+", "block", "size" ]

[ "func", "(", "p", "*", "Parser", ")", "Parse", "(", ")", "error", "{", "if", "p", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "p", ".", "Size", "==", "0", "{", "id", ",", "size", ",", "err", ":=", "p", ".", "IDnSize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "p", ".", "ID", "=", "id", "\n", "if", "p", ".", "ID", "!=", "RiffID", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ".", "ID", ",", "ErrFmtNotSupported", ")", "\n", "}", "\n", "p", ".", "Size", "=", "size", "\n", "if", "err", ":=", "binary", ".", "Read", "(", "p", ".", "r", ",", "binary", ".", "BigEndian", ",", "&", "p", ".", "Format", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "var", "chunk", "*", "Chunk", "\n", "var", "err", "error", "\n", "for", "err", "==", "nil", "{", "chunk", ",", "err", "=", "p", ".", "NextChunk", "(", ")", "\n", "if", "err", "!=", "nil", "{", "break", "\n", "}", "\n\n", "if", "chunk", ".", "ID", "==", "FmtID", "{", "chunk", ".", "DecodeWavHeader", "(", "p", ")", "\n", "}", "else", "{", "if", "p", ".", "Chan", "!=", "nil", "{", "if", "chunk", ".", "Wg", "==", "nil", "{", "chunk", ".", "Wg", "=", "p", ".", "Wg", "\n", "}", "\n", "chunk", ".", "Wg", ".", "Add", "(", "1", ")", "\n", "p", ".", "Chan", "<-", "chunk", "\n", "// the channel has to release otherwise the goroutine is locked", "chunk", ".", "Wg", ".", "Wait", "(", ")", "\n", "}", "\n", "}", "\n\n", "// BFW: bext chunk described here", "// https://tech.ebu.ch/docs/tech/tech3285.pdf", "if", "!", "chunk", ".", "IsFullyRead", "(", ")", "{", "chunk", ".", "Drain", "(", ")", "\n", "}", "\n\n", "}", "\n", "if", "p", ".", "Wg", "!=", "nil", "{", "p", ".", "Wg", ".", "Wait", "(", ")", "\n", "}", "\n\n", "if", "p", ".", "Chan", "!=", "nil", "{", "close", "(", "p", ".", "Chan", ")", "\n", "}", "\n\n", "if", "err", "==", "io", ".", "EOF", "{", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Parse", "parses", "the", "content", "of", "the", "file", "and", "populate", "the", "useful", "fields", ".", "If", "the", "parser", "has", "a", "chan", "set", "chunks", "are", "sent", "to", "the", "channel", "." ]

[ "func", "(", "p", "*", "Parser", ")", "wavDuration", "(", ")", "(", "time", ".", "Duration", ",", "error", ")", "{", "if", "p", ".", "Size", "==", "0", "||", "p", ".", "AvgBytesPerSec", "==", "0", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "duration", ":=", "time", ".", "Duration", "(", "(", "float64", "(", "p", ".", "Size", ")", "/", "float64", "(", "p", ".", "AvgBytesPerSec", ")", ")", "*", "float64", "(", "time", ".", "Second", ")", ")", "\n", "return", "duration", ",", "nil", "\n", "}" ]

[ "WavDuration", "returns", "the", "time", "duration", "of", "a", "wav", "container", "." ]

[ "func", "(", "d", "*", "Decoder", ")", "Duration", "(", ")", "(", "time", ".", "Duration", ",", "error", ")", "{", "if", "d", "==", "nil", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "fr", ":=", "&", "Frame", "{", "}", "\n", "var", "frameDuration", "time", ".", "Duration", "\n", "var", "duration", "time", ".", "Duration", "\n", "var", "err", "error", "\n", "for", "{", "err", "=", "d", ".", "Next", "(", "fr", ")", "\n", "if", "err", "!=", "nil", "{", "// bad headers can be ignored and hopefully skipped", "if", "err", "==", "ErrInvalidHeader", "{", "continue", "\n", "}", "\n", "break", "\n", "}", "\n", "frameDuration", "=", "fr", ".", "Duration", "(", ")", "\n", "if", "frameDuration", ">", "0", "{", "duration", "+=", "frameDuration", "\n", "}", "\n", "d", ".", "NbrFrames", "++", "\n", "}", "\n", "if", "err", "==", "io", ".", "EOF", "||", "err", "==", "io", ".", "ErrUnexpectedEOF", "||", "err", "==", "io", ".", "ErrShortBuffer", "{", "err", "=", "nil", "\n", "}", "\n\n", "return", "duration", ",", "err", "\n", "}" ]

[ "Duration", "returns", "the", "time", "duration", "for", "the", "current", "mp3", "file", "The", "entire", "reader", "will", "be", "consumed", "the", "consumer", "might", "want", "to", "rewind", "the", "reader", "if", "they", "want", "to", "read", "more", "from", "the", "feed", ".", "Note", "that", "this", "is", "an", "estimated", "duration", "based", "on", "how", "the", "frames", "look", ".", "An", "invalid", "file", "might", "have", "a", "duration", "." ]

[ "func", "(", "d", "*", "Decoder", ")", "Next", "(", "f", "*", "Frame", ")", "error", "{", "if", "f", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "n", "int", "\n", "f", ".", "SkippedBytes", "=", "0", "\n", "f", ".", "Counter", "++", "\n\n", "hLen", ":=", "4", "\n", "if", "f", ".", "buf", "==", "nil", "{", "f", ".", "buf", "=", "make", "(", "[", "]", "byte", ",", "hLen", ")", "\n", "}", "else", "{", "f", ".", "buf", "=", "f", ".", "buf", "[", ":", "hLen", "]", "\n", "}", "\n\n", "_", ",", "err", ":=", "io", ".", "ReadAtLeast", "(", "d", ".", "r", ",", "f", ".", "buf", ",", "hLen", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// ID3v1 tag at the beggining", "if", "bytes", ".", "Compare", "(", "f", ".", "buf", "[", ":", "3", "]", ",", "id3v1", ".", "HeaderTagID", ")", "==", "0", "{", "// the ID3v1 tag is always 128 bytes long, we already read 4 bytes", "// so we need to read the rest.", "buf", ":=", "make", "(", "[", "]", "byte", ",", "124", ")", "\n", "// TODO: parse the actual header", "if", "_", ",", "err", ":=", "io", ".", "ReadAtLeast", "(", "d", ".", "r", ",", "buf", ",", "124", ")", ";", "err", "!=", "nil", "{", "return", "ErrInvalidHeader", "\n", "}", "\n", "buf", "=", "append", "(", "f", ".", "buf", ",", "buf", "...", ")", "\n", "// that wasn't a frame", "f", "=", "&", "Frame", "{", "}", "\n", "return", "nil", "\n", "}", "\n\n", "// ID3v2 tag", "if", "bytes", ".", "Compare", "(", "f", ".", "buf", "[", ":", "3", "]", ",", "id3v2", ".", "HeaderTagID", ")", "==", "0", "{", "d", ".", "ID3v2tag", "=", "&", "id3v2", ".", "Tag", "{", "}", "\n", "// we already read 4 bytes, an id3v2 tag header is of size 10, read the rest", "// and append it to what we already have.", "buf", ":=", "make", "(", "[", "]", "byte", ",", "6", ")", "\n", "n", ",", "err", ":=", "d", ".", "r", ".", "Read", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "||", "n", "!=", "6", "{", "return", "ErrInvalidHeader", "\n", "}", "\n", "buf", "=", "append", "(", "f", ".", "buf", ",", "buf", "...", ")", "\n\n", "th", ":=", "id3v2", ".", "TagHeader", "{", "}", "\n", "copy", "(", "th", "[", ":", "]", ",", "buf", ")", "\n", "if", "err", "=", "d", ".", "ID3v2tag", ".", "ReadHeader", "(", "th", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// TODO: parse the actual tag", "// Skip the tag for now", "bytesToSkip", ":=", "int64", "(", "d", ".", "ID3v2tag", ".", "Header", ".", "Size", ")", "\n", "var", "cn", "int64", "\n", "if", "cn", ",", "err", "=", "io", ".", "CopyN", "(", "ioutil", ".", "Discard", ",", "d", ".", "r", ",", "bytesToSkip", ")", ";", "cn", "!=", "bytesToSkip", "{", "return", "ErrInvalidHeader", "\n", "}", "\n", "f", "=", "&", "Frame", "{", "}", "\n", "return", "err", "\n", "}", "\n\n", "f", ".", "Header", "=", "FrameHeader", "(", "f", ".", "buf", ")", "\n", "if", "!", "f", ".", "Header", ".", "IsValid", "(", ")", "{", "f", ".", "Header", ",", "n", ",", "err", "=", "d", ".", "skipToNextFrame", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "f", ".", "SkippedBytes", "=", "n", "\n", "}", "\n\n", "dataSize", ":=", "f", ".", "Header", ".", "Size", "(", ")", "\n", "if", "dataSize", ">", "4", "{", "// substract the 4 bytes we already read", "dataSize", "-=", "4", "\n", "f", ".", "buf", "=", "append", "(", "f", ".", "buf", ",", "make", "(", "[", "]", "byte", ",", "dataSize", ")", "...", ")", "\n", "_", ",", "err", "=", "io", ".", "ReadAtLeast", "(", "d", ".", "r", ",", "f", ".", "buf", "[", "4", ":", "]", ",", "int", "(", "dataSize", ")", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Next", "decodes", "the", "next", "frame", "into", "the", "provided", "frame", "structure", "." ]

[ "func", "(", "d", "*", "Decoder", ")", "skipToNextFrame", "(", ")", "(", "fh", "FrameHeader", ",", "readN", "int", ",", "err", "error", ")", "{", "if", "d", "==", "nil", "{", "return", "nil", ",", "readN", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "buf", ":=", "make", "(", "[", "]", "byte", ",", "1", ")", "\n", "lookAheadBuf", ":=", "make", "(", "[", "]", "byte", ",", "1", ")", "\n", "var", "n", "int", "\n", "for", "{", "n", ",", "err", "=", "d", ".", "r", ".", "Read", "(", "buf", ")", "\n", "readN", "+=", "n", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "readN", ",", "err", "\n", "}", "\n", "readN", "++", "\n", "if", "buf", "[", "0", "]", "==", "0xFF", "{", "if", "_", ",", "err", ":=", "d", ".", "r", ".", "Read", "(", "lookAheadBuf", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "readN", ",", "err", "\n", "}", "\n", "readN", "++", "\n", "if", "lookAheadBuf", "[", "0", "]", "&", "0xE0", "==", "0xE0", "{", "buf", "=", "[", "]", "byte", "{", "0xff", ",", "lookAheadBuf", "[", "0", "]", ",", "0", ",", "0", "}", "\n", "n", ",", "err", ":=", "d", ".", "r", ".", "Read", "(", "buf", "[", "2", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "readN", "+", "n", ",", "err", "\n", "}", "\n", "if", "n", "!=", "2", "{", "return", "nil", ",", "readN", "+", "n", ",", "io", ".", "ErrUnexpectedEOF", "\n", "}", "\n", "readN", "+=", "2", "\n", "}", "\n", "return", "buf", ",", "readN", ",", "err", "\n", "}", "\n", "}", "\n", "}" ]

[ "skipToSyncWord", "reads", "until", "it", "finds", "a", "frame", "header" ]

[ "func", "(", "e", "*", "Encoder", ")", "Write", "(", ")", "error", "{", "if", "e", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "e", ".", "writeHeaders", "(", ")", "\n", "for", "_", ",", "t", ":=", "range", "e", ".", "Tracks", "{", "if", "err", ":=", "e", ".", "encodeTrack", "(", "t", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "// go back and update body size in header", "return", "nil", "\n", "}" ]

[ "Write", "writes", "the", "binary", "representation", "to", "the", "writer" ]

[ "func", "(", "d", "*", "Decoder", ")", "ReadInfo", "(", ")", "error", "{", "if", "d", "==", "nil", "||", "d", ".", "SampleRate", ">", "0", "{", "return", "nil", "\n", "}", "\n", "if", "d", ".", "err", "=", "d", ".", "readHeaders", "(", ")", ";", "d", ".", "err", "!=", "nil", "{", "d", ".", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "d", ".", "err", ")", "\n", "return", "d", ".", "err", "\n", "}", "\n\n", "var", "chk", "*", "chunk", ".", "Reader", "\n", "var", "err", "error", "\n", "for", "err", "==", "nil", "{", "chk", ",", "err", "=", "d", ".", "NextChunk", "(", ")", "\n", "if", "err", "!=", "nil", "{", "break", "\n", "}", "\n", "switch", "chk", ".", "ID", "{", "case", "AudioDataChunkID", ":", "d", ".", "AudioDataSize", "=", "int64", "(", "chk", ".", "Size", ")", "\n", "// TODO:", "// editCount uint32", "// The modification status of the data section. You should initially set this field to 0, and should increment it each time the audio data in the file is modified.", "// the rest of the data is the actual audio data.", "case", "InfoStringsChunkID", ":", "strChunk", ":=", "&", "stringsChunk", "{", "stringID", ":", "map", "[", "string", "]", "string", "{", "}", "}", "\n", "if", "err", "=", "chk", ".", "ReadBE", "(", "&", "strChunk", ".", "numEntries", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "strChunk", ".", "numEntries", ">", "0", "{", "for", "i", ":=", "uint32", "(", "0", ")", ";", "i", "<", "strChunk", ".", "numEntries", ";", "i", "++", "{", "// read key(max 32 bytes) + data (max 1024) both null delimited.", "// TODO: this is terrible for performance reasons. Read the entire chunk in memory for that.", "key", ":=", "[", "]", "byte", "{", "}", "\n", "var", "b", "byte", "\n", "msg", ":=", "[", "]", "byte", "{", "}", "\n", "var", "msgB", "byte", "\n", "for", "j", ":=", "0", ";", "j", "<", "32", ";", "j", "++", "{", "b", ",", "err", "=", "chk", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "break", "\n", "}", "\n", "// end of key?", "if", "b", "==", "0x0", "{", "for", "k", ":=", "0", ";", "k", "<", "1024", ";", "k", "++", "{", "msgB", ",", "err", "=", "chk", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "break", "\n", "}", "\n", "// message terminated", "if", "msgB", "==", "0x0", "{", "break", "\n", "}", "\n", "msg", "=", "append", "(", "msg", ",", "msgB", ")", "\n", "}", "\n", "break", "\n", "}", "\n", "key", "=", "append", "(", "key", ",", "b", ")", "\n", "}", "\n", "if", "len", "(", "key", ")", ">", "0", "{", "strChunk", ".", "stringID", "[", "string", "(", "key", ")", "]", "=", "string", "(", "msg", ")", "\n", "}", "\n", "}", "\n\n", "for", "k", ",", "v", ":=", "range", "strChunk", ".", "stringID", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "k", ",", "v", ")", "\n", "}", "\n", "}", "\n\n", "// kuki", "// The Magic Cookie chunk contains supplementary (“magic cookie”) data required by certain audio data formats, such as MPEG-4 AAC, for decoding of the audio data. If the audio data format contained in a CAF file requires magic cookie data, the file must have this chunk.", "// https://developer.apple.com/library/content/documentation/MusicAudio/Reference/CAFSpec/CAF_spec/CAF_spec.html#//apple_ref/doc/uid/TP40001862-CH210-BCGFCCFA", "// strg", "// The optional Strings chunk contains any number of textual", "// strings, along with an index for accessing them. These strings serve", "// as labels for other chunks, such as Marker or Region chunks.", "// free", "// The optional Free chunk is for reserving space, or providing", "// padding, in a CAF file. The contents of the Free chunk data section", "// have no significance and should be ignored.", "// info", "// You can use the optional Information chunk to contain any number", "// of human-readable text strings. Each string is accessed through a", "// standard or application-defined key. You should consider information", "// in this chunk to be secondary when the same information appears in", "// other chunks. For example, both the Information chunk and the MIDI", "// chunk (MIDI Chunk) may specify key signature and tempo. In that case,", "// the MIDI chunk values overrides the values in the Information chunk.", "// uuid", "//", "// You can define your own chunk type to extend the CAF file", "// specification. For this purpose, this specification includes the", "// User-Defined chunk type, which you can use to provide a unique", "// universal identifier for your custom chunk. When parsing a CAF file,", "// you should ignore any chunk with a UUID that you do not recognize.", "// ovvw", "//", "// You can use the optional Overview chunk to hold sample descriptions", "// that you can use to draw a graphical view of the audio data in a CAF", "// file. A CAF file can include multiple Overview chunks to represent", "// the audio at multiple graphical resolutions.", "// peak", "//", "// You can use the optional Peak chunk to describe the peak amplitude", "// present in each channel of a CAF file and to indicate in which frame", "// the peak occurs for each channel.", "}", "\n", "chk", ".", "Done", "(", ")", "\n", "}", "\n\n", "if", "d", ".", "err", "==", "nil", "&&", "d", ".", "err", "!=", "nil", "{", "d", ".", "err", "=", "err", "\n", "}", "\n", "return", "d", ".", "Err", "(", ")", "\n", "}" ]

[ "ReadInfo", "reads", "the", "underlying", "reader", "finds", "the", "data", "it", "needs", ".", "This", "method", "is", "safe", "to", "call", "multiple", "times", "." ]

[ "func", "(", "d", "*", "Decoder", ")", "parseDescChunk", "(", ")", "error", "{", "if", "err", ":=", "d", ".", "Read", "(", "&", "d", ".", "SampleRate", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "d", ".", "Read", "(", "&", "d", ".", "FormatID", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "d", ".", "Read", "(", "&", "d", ".", "FormatFlags", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "d", ".", "Read", "(", "&", "d", ".", "BytesPerPacket", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "d", ".", "Read", "(", "&", "d", ".", "FramesPerPacket", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "d", ".", "Read", "(", "&", "d", ".", "ChannelsPerFrame", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "d", ".", "Read", "(", "&", "d", ".", "BitsPerChannel", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "parseDescChunk", "parses", "the", "first", "chunk", "called", "description", "chunk", "." ]

[ "func", "GnuplotBin", "(", "buf", "*", "audio", ".", "PCMBuffer", ",", "path", "string", ")", "error", "{", "if", "buf", "==", "nil", "||", "buf", ".", "Format", "==", "nil", "{", "return", "audio", ".", "ErrInvalidBuffer", "\n", "}", "\n", "out", ",", "err", ":=", "os", ".", "Create", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "out", ".", "Close", "(", ")", "\n", "for", "_", ",", "s", ":=", "range", "buf", ".", "AsFloat32s", "(", ")", "{", "if", "err", "=", "binary", ".", "Write", "(", "out", ",", "binary", ".", "BigEndian", ",", "s", ")", ";", "err", "!=", "nil", "{", "break", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "GnuplotBin", "exports", "the", "buffer", "content", "as", "a", "binary", "gnuplot", "file", "." ]

[ "func", "FileFormat", "(", "path", "string", ")", "(", "Format", ",", "error", ")", "{", "if", "!", "fileExists", "(", "path", ")", "{", "return", "\"", "\"", ",", "ErrInvalidPath", "\n", "}", "\n", "f", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "var", "triedWav", "bool", "\n", "var", "triedAif", "bool", "\n\n", "ext", ":=", "strings", ".", "ToLower", "(", "filepath", ".", "Ext", "(", "path", ")", ")", "\n", "switch", "ext", "{", "case", "\"", "\"", ",", "\"", "\"", ":", "triedWav", "=", "true", "\n", "d", ":=", "wav", ".", "NewDecoder", "(", "f", ")", "\n", "if", "d", ".", "IsValidFile", "(", ")", "{", "return", "Wav", ",", "nil", "\n", "}", "\n", "case", "\"", "\"", ",", "\"", "\"", ":", "triedAif", "=", "true", "\n", "d", ":=", "aiff", ".", "NewDecoder", "(", "f", ")", "\n", "if", "d", ".", "IsValidFile", "(", ")", "{", "return", "Aif", ",", "nil", "\n", "}", "\n", "}", "\n", "// extension doesn't match, let's try again", "f", ".", "Seek", "(", "0", ",", "0", ")", "\n", "if", "!", "triedWav", "{", "wd", ":=", "wav", ".", "NewDecoder", "(", "f", ")", "\n", "if", "wd", ".", "IsValidFile", "(", ")", "{", "return", "Wav", ",", "nil", "\n", "}", "\n", "f", ".", "Seek", "(", "0", ",", "0", ")", "\n", "}", "\n", "if", "!", "triedAif", "{", "ad", ":=", "aiff", ".", "NewDecoder", "(", "f", ")", "\n", "if", "ad", ".", "IsValidFile", "(", ")", "{", "return", "Aif", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "Unknown", ",", "nil", "\n", "}" ]

[ "FileFormat", "returns", "the", "known", "format", "of", "the", "passed", "path", "." ]

[ "func", "New", "(", "r", "io", ".", "Reader", ")", "*", "Parser", "{", "return", "&", "Parser", "{", "r", ":", "r", ",", "Wg", ":", "&", "sync", ".", "WaitGroup", "{", "}", "}", "\n", "}" ]

[ "New", "creates", "a", "parser", "wrapper", "for", "a", "reader", ".", "Note", "that", "the", "reader", "doesn", "t", "get", "rewinded", "as", "the", "container", "is", "processed", "." ]

[ "func", "Duration", "(", "r", "io", ".", "Reader", ")", "(", "time", ".", "Duration", ",", "error", ")", "{", "c", ":=", "New", "(", "r", ")", "\n", "if", "err", ":=", "c", ".", "ParseHeaders", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "c", ".", "Duration", "(", ")", "\n", "}" ]

[ "Duration", "returns", "the", "time", "duration", "of", "the", "passed", "reader", "if", "the", "sub", "format", "is", "supported", "." ]

[ "func", "(", "th", "TagHeader", ")", "ReadVersion", "(", ")", "Version", "{", "return", "Version", "{", "Major", ":", "uint8", "(", "th", "[", "3", "]", ")", ",", "Revision", ":", "uint8", "(", "th", "[", "4", "]", ")", ",", "}", "\n", "}" ]

[ "ReadVersion", "extracts", "the", "version", "information", "." ]

[ "func", "(", "th", "TagHeader", ")", "ReadFlags", "(", ")", "Flags", "{", "flags", ":=", "Flags", "{", "}", "\n", "flags", ".", "Unsynchronisation", "=", "(", "th", "[", "5", "]", "&", "(", "1", "<<", "0", ")", ")", "!=", "0", "// 3.1.a", "\n", "flags", ".", "ExtendedHeader", "=", "(", "th", "[", "5", "]", "&", "(", "1", "<<", "1", ")", ")", "!=", "0", "// 3.1.b", "\n", "flags", ".", "ExperimentalIndicator", "=", "(", "th", "[", "5", "]", "&", "(", "1", "<<", "2", ")", ")", "!=", "0", "// 3.1.c", "\n", "flags", ".", "FooterPresent", "=", "(", "th", "[", "5", "]", "&", "(", "1", "<<", "3", ")", ")", "!=", "0", "// 3.1.d", "\n\n", "return", "flags", "\n", "}" ]

[ "ReadFlags", "reads", "the", "header", "flags" ]

[ "func", "(", "f", "*", "FIR", ")", "LowPass", "(", "input", "[", "]", "float64", ")", "(", "[", "]", "float64", ",", "error", ")", "{", "return", "f", ".", "Convolve", "(", "input", ",", "f", ".", "Sinc", ".", "LowPassCoefs", "(", ")", ")", "\n", "}" ]

[ "LowPass", "applies", "a", "low", "pass", "filter", "using", "the", "FIR" ]

[ "func", "(", "f", "*", "FIR", ")", "Convolve", "(", "input", ",", "kernels", "[", "]", "float64", ")", "(", "[", "]", "float64", ",", "error", ")", "{", "if", "f", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "if", "!", "(", "len", "(", "input", ")", ">", "len", "(", "kernels", ")", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "output", ":=", "make", "(", "[", "]", "float64", ",", "len", "(", "input", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "kernels", ")", ";", "i", "++", "{", "var", "sum", "float64", "\n\n", "for", "j", ":=", "0", ";", "j", "<", "i", ";", "j", "++", "{", "sum", "+=", "(", "input", "[", "j", "]", "*", "kernels", "[", "len", "(", "kernels", ")", "-", "(", "1", "+", "i", "-", "j", ")", "]", ")", "\n", "}", "\n", "output", "[", "i", "]", "=", "sum", "\n", "}", "\n\n", "for", "i", ":=", "len", "(", "kernels", ")", ";", "i", "<", "len", "(", "input", ")", ";", "i", "++", "{", "var", "sum", "float64", "\n", "for", "j", ":=", "0", ";", "j", "<", "len", "(", "kernels", ")", ";", "j", "++", "{", "sum", "+=", "(", "input", "[", "i", "-", "j", "]", "*", "kernels", "[", "j", "]", ")", "\n", "}", "\n", "output", "[", "i", "]", "=", "sum", "\n", "}", "\n\n", "return", "output", ",", "nil", "\n", "}" ]

[ "Convolve", "mixes", "two", "signals", "together", "kernels", "is", "the", "imput", "that", "is", "not", "part", "of", "our", "signal", "it", "might", "be", "shorter", "than", "the", "origin", "signal", "." ]

[ "func", "MinMaxFloat", "(", "buf", "*", "audio", ".", "PCMBuffer", ")", "(", "min", ",", "max", "float64", ")", "{", "if", "buf", "==", "nil", "||", "buf", ".", "Len", "(", ")", "==", "0", "{", "return", "0", ",", "0", "\n", "}", "\n", "buf", ".", "SwitchPrimaryType", "(", "audio", ".", "Float", ")", "\n", "min", "=", "buf", ".", "Floats", "[", "0", "]", "\n\n", "for", "_", ",", "v", ":=", "range", "buf", ".", "Floats", "{", "if", "v", ">", "max", "{", "max", "=", "v", "\n", "}", "else", "if", "v", "<", "min", "{", "min", "=", "v", "\n", "}", "\n", "}", "\n\n", "return", "min", ",", "max", "\n", "}" ]

[ "MinMaxFloat", "returns", "the", "smallest", "and", "biggest", "samples", "in", "the", "buffer" ]

[ "func", "MonoDownmix", "(", "buf", "*", "audio", ".", "PCMBuffer", ")", "error", "{", "if", "buf", "==", "nil", "||", "buf", ".", "Format", "==", "nil", "{", "return", "audio", ".", "ErrInvalidBuffer", "\n", "}", "\n", "nChans", ":=", "buf", ".", "Format", ".", "NumChannels", "\n", "if", "nChans", "<", "2", "{", "return", "nil", "\n", "}", "\n", "nChansF", ":=", "float64", "(", "nChans", ")", "\n\n", "frameCount", ":=", "buf", ".", "Size", "(", ")", "\n", "newData", ":=", "make", "(", "[", "]", "float64", ",", "frameCount", ")", "\n", "buf", ".", "SwitchPrimaryType", "(", "audio", ".", "Float", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "frameCount", ";", "i", "++", "{", "newData", "[", "i", "]", "=", "0", "\n", "for", "j", ":=", "0", ";", "j", "<", "nChans", ";", "j", "++", "{", "newData", "[", "i", "]", "+=", "buf", ".", "Floats", "[", "i", "*", "nChans", "+", "j", "]", "\n", "}", "\n", "newData", "[", "i", "]", "/=", "nChansF", "\n", "}", "\n", "buf", ".", "Floats", "=", "newData", "\n", "buf", ".", "Format", ".", "NumChannels", "=", "1", "\n\n", "return", "nil", "\n", "}" ]

[ "MonoDownmix", "converts", "the", "buffer", "to", "a", "mono", "buffer", "by", "downmixing", "the", "channels", "together", "." ]

[ "func", "NormalizeMax", "(", "buf", "*", "audio", ".", "PCMBuffer", ")", "{", "if", "buf", "==", "nil", "{", "return", "\n", "}", "\n", "buf", ".", "SwitchPrimaryType", "(", "audio", ".", "Float", ")", "\n", "max", ":=", "0.0", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "buf", ".", "Len", "(", ")", ";", "i", "++", "{", "if", "math", ".", "Abs", "(", "buf", ".", "Floats", "[", "i", "]", ")", ">", "max", "{", "max", "=", "math", ".", "Abs", "(", "buf", ".", "Floats", "[", "i", "]", ")", "\n", "}", "\n", "}", "\n\n", "if", "max", "!=", "0.0", "{", "for", "i", ":=", "0", ";", "i", "<", "buf", ".", "Len", "(", ")", ";", "i", "++", "{", "buf", ".", "Floats", "[", "i", "]", "/=", "max", "\n", "}", "\n", "}", "\n", "}" ]

[ "NormalizeMax", "sets", "the", "max", "value", "to", "1", "and", "normalize", "the", "rest", "of", "the", "data", "." ]

[ "func", "PCMScale", "(", "buf", "*", "audio", ".", "PCMBuffer", ")", "error", "{", "if", "buf", "==", "nil", "||", "buf", ".", "Format", "==", "nil", "{", "return", "audio", ".", "ErrInvalidBuffer", "\n", "}", "\n", "buf", ".", "SwitchPrimaryType", "(", "audio", ".", "Float", ")", "\n", "factor", ":=", "float64", "(", "audio", ".", "IntMaxSignedValue", "(", "buf", ".", "Format", ".", "BitDepth", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "buf", ".", "Len", "(", ")", ";", "i", "++", "{", "buf", ".", "Floats", "[", "i", "]", "*=", "factor", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "PCMScale", "converts", "a", "buffer", "with", "audio", "content", "from", "-", "1", "to", "1", "into", "the", "PCM", "scale", "based", "on", "the", "buffer", "s", "bitdepth", "." ]

[ "func", "Sine", "(", "x32", "float64", ")", "float64", "{", "x", ":=", "float64", "(", "x32", ")", "\n", "y", ":=", "SineB", "*", "x", "+", "SineC", "*", "x", "*", "(", "math", ".", "Abs", "(", "x", ")", ")", "\n", "y", "=", "SineP", "*", "(", "y", "*", "(", "math", ".", "Abs", "(", "y", ")", ")", "-", "y", ")", "+", "y", "\n", "return", "float64", "(", "y", ")", "\n", "}" ]

[ "Sine", "takes", "an", "input", "value", "from", "-", "Pi", "to", "Pi", "and", "returns", "a", "value", "between", "-", "1", "and", "1" ]

[ "func", "NewPCMIntBuffer", "(", "data", "[", "]", "int", ",", "format", "*", "Format", ")", "*", "PCMBuffer", "{", "return", "&", "PCMBuffer", "{", "Format", ":", "format", ",", "DataType", ":", "Integer", ",", "Ints", ":", "data", ",", "}", "\n", "}" ]

[ "NewPCMIntBuffer", "returns", "a", "new", "PCM", "buffer", "backed", "by", "the", "passed", "integer", "samples" ]

[ "func", "NewPCMFloatBuffer", "(", "data", "[", "]", "float64", ",", "format", "*", "Format", ")", "*", "PCMBuffer", "{", "return", "&", "PCMBuffer", "{", "Format", ":", "format", ",", "DataType", ":", "Float", ",", "Floats", ":", "data", ",", "}", "\n", "}" ]

[ "NewPCMFloatBuffer", "returns", "a", "new", "PCM", "buffer", "backed", "by", "the", "passed", "float", "samples" ]

[ "func", "NewPCMByteBuffer", "(", "data", "[", "]", "byte", ",", "format", "*", "Format", ")", "*", "PCMBuffer", "{", "return", "&", "PCMBuffer", "{", "Format", ":", "format", ",", "DataType", ":", "Byte", ",", "Bytes", ":", "data", ",", "}", "\n", "}" ]

[ "NewPCMByteBuffer", "returns", "a", "new", "PCM", "buffer", "backed", "by", "the", "passed", "float", "samples" ]

[ "func", "(", "b", "*", "PCMBuffer", ")", "Size", "(", ")", "(", "numFrames", "int", ")", "{", "if", "b", "==", "nil", "||", "b", ".", "Format", "==", "nil", "{", "return", "0", "\n", "}", "\n", "numChannels", ":=", "b", ".", "Format", ".", "NumChannels", "\n", "if", "numChannels", "==", "0", "{", "numChannels", "=", "1", "\n", "}", "\n", "switch", "b", ".", "DataType", "{", "case", "Integer", ":", "numFrames", "=", "len", "(", "b", ".", "Ints", ")", "/", "numChannels", "\n", "case", "Float", ":", "numFrames", "=", "len", "(", "b", ".", "Floats", ")", "/", "numChannels", "\n", "case", "Byte", ":", "sampleSize", ":=", "int", "(", "(", "b", ".", "Format", ".", "BitDepth", "-", "1", ")", "/", "8", "+", "1", ")", "\n", "numFrames", "=", "(", "len", "(", "b", ".", "Bytes", ")", "/", "sampleSize", ")", "/", "numChannels", "\n", "}", "\n", "return", "numFrames", "\n", "}" ]

[ "Size", "returns", "the", "number", "of", "frames", "contained", "in", "the", "buffer", "." ]

[ "func", "(", "b", "*", "PCMBuffer", ")", "AsInt16s", "(", ")", "(", "out", "[", "]", "int16", ")", "{", "if", "b", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "switch", "b", ".", "DataType", "{", "case", "Integer", ",", "Float", ":", "out", "=", "make", "(", "[", "]", "int16", ",", "len", "(", "b", ".", "Ints", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "b", ".", "Ints", ")", ";", "i", "++", "{", "out", "[", "i", "]", "=", "int16", "(", "b", ".", "Ints", "[", "i", "]", ")", "\n", "}", "\n", "case", "Byte", ":", "// if the format isn't defined, we can't read the byte data", "if", "b", ".", "Format", "==", "nil", "||", "b", ".", "Format", ".", "Endianness", "==", "nil", "||", "b", ".", "Format", ".", "BitDepth", "==", "0", "{", "return", "out", "\n", "}", "\n", "bytesPerSample", ":=", "int", "(", "(", "b", ".", "Format", ".", "BitDepth", "-", "1", ")", "/", "8", "+", "1", ")", "\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "b", ".", "Bytes", ")", "\n", "out", ":=", "make", "(", "[", "]", "int16", ",", "len", "(", "b", ".", "Bytes", ")", "/", "bytesPerSample", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "b", ".", "Format", ".", "Endianness", ",", "&", "out", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "AsInt16s", "returns", "the", "buffer", "samples", "as", "int16", "sample", "values", "." ]

[ "func", "NewOsc", "(", "shape", "WaveType", ",", "hz", "float64", ",", "fs", "int", ")", "*", "Osc", "{", "return", "&", "Osc", "{", "Shape", ":", "shape", ",", "Amplitude", ":", "1", ",", "Freq", ":", "hz", ",", "Fs", ":", "fs", ",", "phaseAngleIncr", ":", "(", "(", "hz", "*", "TwoPi", ")", "/", "float64", "(", "fs", ")", ")", "}", "\n", "}" ]

[ "NewOsc", "returns", "a", "new", "oscillator", "note", "that", "if", "you", "change", "the", "phase", "offset", "of", "the", "returned", "osc", "you", "also", "need", "to", "set", "the", "CurrentPhaseAngle" ]

[ "func", "(", "o", "*", "Osc", ")", "Reset", "(", ")", "{", "o", ".", "phaseAngleIncr", "=", "(", "(", "o", ".", "Freq", "*", "TwoPi", ")", "/", "float64", "(", "o", ".", "Fs", ")", ")", "\n", "o", ".", "currentSample", "=", "0", "\n", "}" ]

[ "Reset", "sets", "the", "oscillator", "back", "to", "its", "starting", "state" ]

[ "func", "(", "o", "*", "Osc", ")", "SetFreq", "(", "hz", "float64", ")", "{", "if", "o", ".", "Freq", "!=", "hz", "{", "o", ".", "Freq", "=", "hz", "\n", "o", ".", "phaseAngleIncr", "=", "(", "(", "hz", "*", "TwoPi", ")", "/", "float64", "(", "o", ".", "Fs", ")", ")", "\n", "}", "\n", "}" ]

[ "SetFreq", "updates", "the", "oscillator", "frequency" ]

[ "func", "(", "o", "*", "Osc", ")", "SetAttackInMs", "(", "ms", "int", ")", "{", "if", "o", "==", "nil", "{", "return", "\n", "}", "\n", "if", "ms", "<=", "0", "{", "o", ".", "attackInSamples", "=", "0", "\n", "return", "\n", "}", "\n", "o", ".", "attackInSamples", "=", "int", "(", "float32", "(", "o", ".", "Fs", ")", "/", "(", "1000.0", "/", "float32", "(", "ms", ")", ")", ")", "\n", "}" ]

[ "SetAttackInMs", "sets", "the", "duration", "for", "the", "oscillator", "to", "be", "at", "full", "amplitude", "after", "it", "starts", "." ]

[ "func", "(", "o", "*", "Osc", ")", "Signal", "(", "length", "int", ")", "[", "]", "float64", "{", "output", ":=", "make", "(", "[", "]", "float64", ",", "length", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "length", ";", "i", "++", "{", "output", "[", "i", "]", "=", "o", ".", "Sample", "(", ")", "\n", "}", "\n", "return", "output", "\n", "}" ]

[ "Signal", "uses", "the", "osc", "to", "generate", "a", "discreet", "signal" ]

[ "func", "(", "o", "*", "Osc", ")", "Fill", "(", "buf", "*", "audio", ".", "PCMBuffer", ")", "error", "{", "if", "o", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "len", ":=", "buf", ".", "Len", "(", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", ";", "i", "++", "{", "switch", "buf", ".", "DataType", "{", "case", "audio", ".", "Integer", ":", "buf", ".", "Ints", "[", "i", "]", "=", "int", "(", "o", ".", "Sample", "(", ")", ")", "\n", "case", "audio", ".", "Float", ":", "buf", ".", "Floats", "[", "i", "]", "=", "o", ".", "Sample", "(", ")", "\n", "case", "audio", ".", "Byte", ":", "// TODO: check the format bitdepth and endianess and convert", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Fill", "fills", "up", "the", "pass", "PCMBuffer", "with", "the", "output", "of", "the", "oscillator", "." ]

[ "func", "(", "o", "*", "Osc", ")", "Sample", "(", ")", "(", "output", "float64", ")", "{", "if", "o", "==", "nil", "{", "return", "\n", "}", "\n", "o", ".", "currentSample", "++", "\n", "if", "o", ".", "CurrentPhaseAngle", "<", "-", "math", ".", "Pi", "{", "o", ".", "CurrentPhaseAngle", "+=", "TwoPi", "\n", "}", "else", "if", "o", ".", "CurrentPhaseAngle", ">", "math", ".", "Pi", "{", "o", ".", "CurrentPhaseAngle", "-=", "TwoPi", "\n", "}", "\n\n", "var", "amp", "float64", "\n", "if", "o", ".", "attackInSamples", ">", "o", ".", "currentSample", "{", "// linear fade in", "amp", "=", "float64", "(", "o", ".", "currentSample", ")", "*", "(", "o", ".", "Amplitude", "/", "float64", "(", "o", ".", "attackInSamples", ")", ")", "\n", "}", "else", "{", "amp", "=", "o", ".", "Amplitude", "\n", "}", "\n\n", "switch", "o", ".", "Shape", "{", "case", "WaveSine", ":", "output", "=", "amp", "*", "Sine", "(", "o", ".", "CurrentPhaseAngle", ")", "+", "o", ".", "DcOffset", "\n", "case", "WaveTriangle", ":", "output", "=", "amp", "*", "Triangle", "(", "o", ".", "CurrentPhaseAngle", ")", "+", "o", ".", "DcOffset", "\n", "case", "WaveSaw", ":", "output", "=", "amp", "*", "Sawtooth", "(", "o", ".", "CurrentPhaseAngle", ")", "+", "o", ".", "DcOffset", "\n", "case", "WaveSqr", ":", "fmt", ".", "Println", "(", "o", ".", "CurrentPhaseAngle", ")", "\n", "output", "=", "amp", "*", "Square", "(", "o", ".", "CurrentPhaseAngle", ")", "+", "o", ".", "DcOffset", "\n", "}", "\n\n", "o", ".", "CurrentPhaseAngle", "+=", "o", ".", "phaseAngleIncr", "\n", "return", "output", "\n", "}" ]

[ "Sample", "returns", "the", "next", "sample", "generated", "by", "the", "oscillator" ]

[ "func", "(", "ch", "*", "Chunk", ")", "Done", "(", ")", "{", "if", "!", "ch", ".", "IsFullyRead", "(", ")", "{", "ch", ".", "Drain", "(", ")", "\n", "}", "\n", "if", "ch", ".", "Wg", "!=", "nil", "{", "ch", ".", "Wg", ".", "Done", "(", ")", "\n", "}", "\n", "}" ]

[ "Done", "signals", "the", "parent", "parser", "that", "we", "are", "done", "reading", "the", "chunk", "if", "the", "chunk", "isn", "t", "fully", "read", "this", "code", "will", "do", "so", "before", "signaling", "." ]

[ "func", "(", "ch", "*", "Chunk", ")", "ReadBE", "(", "dst", "interface", "{", "}", ")", "error", "{", "if", "ch", ".", "IsFullyRead", "(", ")", "{", "return", "io", ".", "EOF", "\n", "}", "\n", "ch", ".", "Pos", "+=", "binary", ".", "Size", "(", "dst", ")", "\n", "return", "binary", ".", "Read", "(", "ch", ".", "R", ",", "binary", ".", "LittleEndian", ",", "dst", ")", "\n", "}" ]

[ "ReadBE", "reads", "the", "Big", "Endian", "chunk", "data", "into", "the", "passed", "struct" ]

[ "func", "(", "ch", "*", "Chunk", ")", "Drain", "(", ")", "{", "bytesAhead", ":=", "ch", ".", "Size", "-", "ch", ".", "Pos", "\n", "for", "bytesAhead", ">", "0", "{", "readSize", ":=", "int64", "(", "bytesAhead", ")", "\n\n", "if", "_", ",", "err", ":=", "io", ".", "CopyN", "(", "ioutil", ".", "Discard", ",", "ch", ".", "R", ",", "readSize", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "bytesAhead", "-=", "int", "(", "readSize", ")", "\n", "}", "\n", "}" ]

[ "Drain", "discards", "the", "rest", "of", "the", "chunk" ]

[ "func", "NewDFT", "(", "sr", "int", ",", "x", "[", "]", "float64", ")", "*", "DFT", "{", "return", "&", "DFT", "{", "SampleRate", ":", "sr", ",", "Coefs", ":", "fft", ".", "FFTReal", "(", "x", ")", ",", "}", "\n", "}" ]

[ "NewDFT", "returns", "the", "FFT", "result", "wrapped", "in", "a", "DFT", "struct" ]

[ "func", "(", "d", "*", "DFT", ")", "IFFT", "(", ")", "[", "]", "float64", "{", "sndDataCmplx", ":=", "fft", ".", "IFFT", "(", "d", ".", "Coefs", ")", "\n", "sndData", ":=", "make", "(", "[", "]", "float64", ",", "len", "(", "sndDataCmplx", ")", ")", "\n", "for", "i", ",", "cpx", ":=", "range", "sndDataCmplx", "{", "sndData", "[", "i", "]", "=", "cmplx", ".", "Abs", "(", "cpx", ")", "\n", "}", "\n", "return", "sndData", "\n", "}" ]

[ "IFFT", "runs", "an", "inverse", "fast", "fourrier", "transform", "and", "returns", "the", "float", "values" ]

[ "func", "Resample", "(", "buf", "*", "audio", ".", "PCMBuffer", ",", "fs", "float64", ")", "error", "{", "if", "buf", "==", "nil", "||", "buf", ".", "Format", "==", "nil", "{", "return", "audio", ".", "ErrInvalidBuffer", "\n", "}", "\n", "if", "buf", ".", "Format", ".", "SampleRate", "==", "int", "(", "fs", ")", "{", "return", "nil", "\n", "}", "\n", "buf", ".", "SwitchPrimaryType", "(", "audio", ".", "Float", ")", "\n\n", "// downsample", "if", "fs", "<", "float64", "(", "buf", ".", "Format", ".", "SampleRate", ")", "{", "factor", ":=", "float64", "(", "buf", ".", "Format", ".", "SampleRate", ")", "/", "fs", "\n\n", "// apply a low pass filter at the nyquist frequency to avoid", "// aliasing.", "if", "err", ":=", "filters", ".", "LowPass", "(", "buf", ",", "float64", "(", "buf", ".", "Format", ".", "SampleRate", ")", "/", "2", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// drop samples to match the decimation factor", "newLength", ":=", "int", "(", "math", ".", "Floor", "(", "float64", "(", "len", "(", "buf", ".", "Floats", ")", ")", "/", "factor", ")", ")", "\n", "var", "targetI", "int", "\n", "for", "i", ":=", "0", ";", "i", "<", "newLength", ";", "i", "++", "{", "targetI", "=", "int", "(", "math", ".", "Floor", "(", "float64", "(", "i", ")", "*", "factor", ")", ")", "\n", "buf", ".", "Floats", "[", "i", "]", "=", "buf", ".", "Floats", "[", "targetI", "]", "\n", "}", "\n", "buf", ".", "Floats", "=", "buf", ".", "Floats", "[", ":", "newLength", "]", "\n", "buf", ".", "Format", ".", "SampleRate", "=", "int", "(", "fs", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// oversample", "// Note: oversampling reduces the amplitude", "factor", ":=", "fs", "/", "float64", "(", "buf", ".", "Format", ".", "SampleRate", ")", "\n", "newLength", ":=", "int", "(", "math", ".", "Ceil", "(", "float64", "(", "len", "(", "buf", ".", "Floats", ")", ")", "*", "factor", ")", ")", "\n", "newFloats", ":=", "make", "(", "[", "]", "float64", ",", "newLength", ")", "\n", "padding", ":=", "int", "(", "math", ".", "Ceil", "(", "float64", "(", "newLength", ")", "/", "float64", "(", "len", "(", "buf", ".", "Floats", ")", ")", ")", ")", "\n", "var", "idx", "int", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "buf", ".", "Floats", ")", ";", "i", "++", "{", "idx", "=", "i", "*", "padding", "\n", "if", "idx", ">=", "len", "(", "newFloats", ")", "{", "break", "\n", "}", "\n", "newFloats", "[", "idx", "]", "=", "buf", ".", "Floats", "[", "i", "]", "\n", "}", "\n", "buf", ".", "Floats", "=", "newFloats", "\n", "buf", ".", "Format", ".", "SampleRate", "=", "int", "(", "fs", ")", "\n", "return", "nil", "\n", "}" ]

[ "Resample", "down", "or", "up", "samples", "the", "buffer", ".", "Note", "that", "the", "amplitude", "will", "be", "affected", "by", "upsampling", "." ]

[ "func", "KeyInt", "(", "n", "string", ",", "octave", "int", ")", "int", "{", "key", ":=", "notesToInt", "[", "strings", ".", "ToUpper", "(", "n", ")", "]", "\n", "// octave starts at -2 but first note is at 0", "return", "key", "+", "(", "octave", "+", "2", ")", "*", "12", "\n", "}" ]

[ "KeyInt", "converts", "an", "A", "-", "G", "note", "notation", "to", "a", "midi", "note", "number", "value", "." ]

[ "func", "NoteToFreq", "(", "note", "int", ")", "float64", "{", "return", "audio", ".", "RootA", "*", "math", ".", "Pow", "(", "2", ",", "(", "float64", "(", "note", ")", "-", "69.0", ")", "/", "12.0", ")", "\n", "}" ]

[ "NoteToFreq", "returns", "the", "frequency", "of", "the", "passed", "midi", "note", "." ]

[ "func", "NoteToName", "(", "note", "int", ")", "string", "{", "key", ":=", "Notes", "[", "note", "%", "12", "]", "\n", "octave", ":=", "(", "(", "note", "/", "12", ")", "|", "0", ")", "-", "2", "// The MIDI scale starts at octave = -2", "\n", "return", "key", "+", "strconv", ".", "Itoa", "(", "octave", ")", "\n", "}" ]

[ "NoteToName", "converts", "a", "midi", "note", "value", "into", "its", "English", "name" ]

[ "func", "FreqToNote", "(", "freq", "float64", ")", "int", "{", "pitch", ":=", "12.0", "*", "(", "math", ".", "Log", "(", "freq", "/", "(", "440", "/", "2.0", ")", ")", "/", "math", ".", "Log", "(", "2.0", ")", ")", "+", "57.0", "\n", "return", "int", "(", "pitch", "+", "0.00001", ")", "\n", "}" ]

[ "FreqToNote", "reports", "the", "associated", "midi", "node", "for", "a", "given", "frequency", "." ]

[ "func", "(", "t", "*", "Track", ")", "Tempo", "(", ")", "int", "{", "if", "t", "==", "nil", "{", "return", "0", "\n", "}", "\n", "tempoEvType", ":=", "MetaByteMap", "[", "\"", "\"", "]", "\n", "for", "_", ",", "ev", ":=", "range", "t", ".", "Events", "{", "if", "ev", ".", "Cmd", "==", "tempoEvType", "{", "return", "int", "(", "ev", ".", "Bpm", ")", "\n", "}", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "Tempo", "returns", "the", "tempo", "of", "the", "track", "if", "set", "0", "otherwise" ]