diff --git a/Readme.md b/Readme.md index 95602640..1c3489d4 100644 --- a/Readme.md +++ b/Readme.md @@ -5,6 +5,7 @@ av is a collection of tools and packages written in Go for audio-video processin # Authors Alan Noble Saxon A. Nelson-Milton +Trek Hopton # Description diff --git a/audio/adpcm/adpcm.go b/audio/adpcm/adpcm.go new file mode 100644 index 00000000..595728a2 --- /dev/null +++ b/audio/adpcm/adpcm.go @@ -0,0 +1,333 @@ +/* +NAME + adpcm.go + +DESCRIPTION + adpcm.go contains functions for encoding/compressing pcm into adpcm and decoding/decompressing back to pcm. + +AUTHOR + Trek Hopton + +LICENSE + adpcm.go is Copyright (C) 2018 the Australian Ocean Lab (AusOcean) + + It is free software: you can redistribute it and/or modify them + under the terms of the GNU General Public License as published by the + Free Software Foundation, either version 3 of the License, or (at your + option) any later version. + + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License in gpl.txt. + If not, see [GNU licenses](http://www.gnu.org/licenses). +*/ + +/* + Original IMA/DVI ADPCM specification: (http://www.cs.columbia.edu/~hgs/audio/dvi/IMA_ADPCM.pdf). + Reference algorithms for ADPCM compression and decompression are in part 6. +*/ + +package adpcm + +import ( + "bytes" + "encoding/binary" + "fmt" +) + +// encoder is used to encode to ADPCM from PCM data. +// pred and index hold state that persists between calls to encodeSample and calcHead. +// dest is the output buffer that implements io.writer and io.bytewriter, ie. where the encoded ADPCM data is written to. +type encoder struct { + dest *bytes.Buffer + pred int16 + index int16 +} + +// decoder is used to decode from ADPCM to PCM data. +// pred, index, and step hold state that persists between calls to decodeSample. +// dest is the output buffer that implements io.writer and io.bytewriter, ie. where the decoded PCM data is written to. +type decoder struct { + dest *bytes.Buffer + pred int16 + index int16 + step int16 +} + +// PcmBS is the size of the blocks that an encoder uses. +// 'encodeBlock' will encode PcmBS bytes at a time and the output will be AdpcmBS bytes long. +const PcmBS = 1010 + +// AdpcmBS is the size of the blocks that a decoder uses. +// 'decodeBlock' will decode AdpcmBS bytes at a time and the output will be PcmBS bytes long. +const AdpcmBS = 256 + +// Table of index changes (see spec). +var indexTable = []int16{ + -1, -1, -1, -1, 2, 4, 6, 8, + -1, -1, -1, -1, 2, 4, 6, 8, +} + +// Quantize step size table (see spec). +var stepTable = []int16{ + 7, 8, 9, 10, 11, 12, 13, 14, + 16, 17, 19, 21, 23, 25, 28, 31, + 34, 37, 41, 45, 50, 55, 60, 66, + 73, 80, 88, 97, 107, 118, 130, 143, + 157, 173, 190, 209, 230, 253, 279, 307, + 337, 371, 408, 449, 494, 544, 598, 658, + 724, 796, 876, 963, 1060, 1166, 1282, 1411, + 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, + 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, + 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, + 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, + 32767, +} + +// NewEncoder retuns a new ADPCM encoder. +func NewEncoder(dst *bytes.Buffer) *encoder { + e := encoder{ + dest: dst, + } + return &e +} + +// NewDecoder retuns a new ADPCM decoder. +func NewDecoder(dst *bytes.Buffer) *decoder { + d := decoder{ + step: stepTable[0], + dest: dst, + } + return &d +} + +// encodeSample takes a single 16 bit PCM sample and +// returns a byte of which the last 4 bits are an encoded ADPCM nibble. +func (e *encoder) encodeSample(sample int16) byte { + // Find difference of actual sample from encoder's prediction. + delta := sample - e.pred + + // Create and set sign bit for nibble and find absolute value of difference. + var nib byte + if delta < 0 { + nib = 8 + delta = -delta + } + + step := stepTable[e.index] + diff := step >> 3 + var mask byte = 4 + + for i := 0; i < 3; i++ { + if delta > step { + nib |= mask + delta -= step + diff += step + } + mask >>= 1 + step >>= 1 + } + + // Adjust predicted sample based on calculated difference. + if nib&8 != 0 { + e.pred -= diff + } else { + e.pred += diff + } + + e.index += indexTable[nib&7] + + // Check for underflow and overflow. + if e.index < 0 { + e.index = 0 + } else if e.index > int16(len(stepTable)-1) { + e.index = int16(len(stepTable) - 1) + } + + return nib +} + +// decodeSample takes a byte, the last 4 bits of which contain a single +// 4 bit ADPCM nibble, and returns a 16 bit decoded PCM sample. +func (d *decoder) decodeSample(nibble byte) int16 { + // Calculate difference. + var diff int16 + if nibble&4 != 0 { + diff += d.step + } + if nibble&2 != 0 { + diff += d.step >> 1 + } + if nibble&1 != 0 { + diff += d.step >> 2 + } + diff += d.step >> 3 + + // Account for sign bit. + if nibble&8 != 0 { + diff = -diff + } + + // Adjust predicted sample based on calculated difference. + d.pred += diff + + // Adjust index into step size lookup table using nibble. + d.index += indexTable[nibble] + + // Check for overflow and underflow. + if d.index < 0 { + d.index = 0 + } else if d.index > int16(len(stepTable)-1) { + d.index = int16(len(stepTable) - 1) + } + + // Find new quantizer step size. + d.step = stepTable[d.index] + + return d.pred +} + +// calcHead sets the state for the encoder by running the first sample through +// the encoder, and writing the first sample to the encoder's io.Writer (dest). +// It returns the number of bytes written to the encoder's io.Writer (dest) along with any errors. +func (e *encoder) calcHead(sample []byte) (int, error) { + // Check that we are given 1 16-bit sample (2 bytes). + const sampSize = 2 + if len(sample) != sampSize { + return 0, fmt.Errorf("length of given byte array is: %v, expected: %v", len(sample), sampSize) + } + + intSample := int16(binary.LittleEndian.Uint16(sample)) + e.encodeSample(intSample) + + n, err := e.dest.Write(sample) + if err != nil { + return n, err + } + + err = e.dest.WriteByte(byte(uint16(e.index))) + if err != nil { + return n, err + } + n++ + + err = e.dest.WriteByte(byte(0x00)) + if err != nil { + return n, err + } + n++ + return n, nil +} + +// encodeBlock takes a slice of 1010 bytes (505 16-bit PCM samples). +// It writes encoded (compressed) bytes (each byte containing two ADPCM nibbles) to the encoder's io.Writer (dest). +// The number of bytes written is returned along with any errors. +// Note: nibbles are output in little endian order, eg. n1n0 n3n2 n5n4... +// Note: first 4 bytes are for initializing the decoder before decoding a block. +// - First two bytes contain the first 16-bit sample uncompressed. +// - Third byte is the decoder's starting index for the block, the fourth is padding and ignored. +func (e *encoder) encodeBlock(block []byte) (int, error) { + if len(block) != PcmBS { + return 0, fmt.Errorf("unsupported block size. Given: %v, expected: %v, ie. 505 16-bit PCM samples", len(block), PcmBS) + } + + n, err := e.calcHead(block[0:2]) + if err != nil { + return n, err + } + + for i := 3; i < PcmBS; i += 4 { + nib1 := e.encodeSample(int16(binary.LittleEndian.Uint16(block[i-1 : i+1]))) + nib2 := e.encodeSample(int16(binary.LittleEndian.Uint16(block[i+1 : i+3]))) + err = e.dest.WriteByte(byte((nib2 << 4) | nib1)) + if err != nil { + return n, err + } + n++ + } + + return n, nil +} + +// decodeBlock takes a slice of 256 bytes, each byte after the first 4 should contain two ADPCM encoded nibbles. +// It writes the resulting decoded (decompressed) 16-bit PCM samples to the decoder's io.Writer (dest). +// The number of bytes written is returned along with any errors. +func (d *decoder) decodeBlock(block []byte) (int, error) { + if len(block) != AdpcmBS { + return 0, fmt.Errorf("unsupported block size. Given: %v, expected: %v", len(block), AdpcmBS) + } + + // Initialize decoder with first 4 bytes of the block. + d.pred = int16(binary.LittleEndian.Uint16(block[0:2])) + d.index = int16(block[2]) + d.step = stepTable[d.index] + n, err := d.dest.Write(block[0:2]) + if err != nil { + return n, err + } + + // For each byte, seperate it into two nibbles (each nibble is a compressed sample), + // then decode each nibble and output the resulting 16-bit samples. + for i := 4; i < AdpcmBS; i++ { + twoNibs := block[i] + nib2 := byte(twoNibs >> 4) + nib1 := byte((nib2 << 4) ^ twoNibs) + + firstBytes := make([]byte, 2) + binary.LittleEndian.PutUint16(firstBytes, uint16(d.decodeSample(nib1))) + _n, err := d.dest.Write(firstBytes) + n += _n + if err != nil { + return n, err + } + + secondBytes := make([]byte, 2) + binary.LittleEndian.PutUint16(secondBytes, uint16(d.decodeSample(nib2))) + _n, err = d.dest.Write(secondBytes) + n += _n + if err != nil { + return n, err + } + } + + return n, nil +} + +// Write takes a slice of bytes of arbitrary length representing pcm and encodes in into adpcm. +// It writes its output to the encoder's dest. +// The number of bytes written out is returned along with any error that occured. +func (e *encoder) Write(inPcm []byte) (int, error) { + numBlocks := len(inPcm) / PcmBS + n := 0 + for i := 0; i < numBlocks; i++ { + block := inPcm[PcmBS*i : PcmBS*(i+1)] + _n, err := e.encodeBlock(block) + n += _n + if err != nil { + return n, err + } + } + + return n, nil +} + +// Write takes a slice of bytes of arbitrary length representing adpcm and decodes in into pcm. +// It writes its output to the decoder's dest. +// The number of bytes written out is returned along with any error that occured. +func (d *decoder) Write(inAdpcm []byte) (int, error) { + numBlocks := len(inAdpcm) / AdpcmBS + n := 0 + for i := 0; i < numBlocks; i++ { + block := inAdpcm[AdpcmBS*i : AdpcmBS*(i+1)] + _n, err := d.decodeBlock(block) + n += _n + if err != nil { + return n, err + } + } + + return n, nil +} diff --git a/audio/adpcm/adpcm_test.go b/audio/adpcm/adpcm_test.go new file mode 100644 index 00000000..9df24028 --- /dev/null +++ b/audio/adpcm/adpcm_test.go @@ -0,0 +1,92 @@ +/* +NAME + adpcm_test.go + +DESCRIPTION + adpcm_test.go contains tests for the adpcm package. + +AUTHOR + Trek Hopton + +LICENSE + adpcm_test.go is Copyright (C) 2018 the Australian Ocean Lab (AusOcean) + + It is free software: you can redistribute it and/or modify them + under the terms of the GNU General Public License as published by the + Free Software Foundation, either version 3 of the License, or (at your + option) any later version. + + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License in gpl.txt. + If not, see [GNU licenses](http://www.gnu.org/licenses). +*/ + +package adpcm + +import ( + "bytes" + "io/ioutil" + "testing" +) + +// TestEncodeBlock will read PCM data, encode it in blocks and generate ADPCM +// then compare the result with expected ADPCM. +func TestEncodeBlock(t *testing.T) { + // Read input pcm. + pcm, err := ioutil.ReadFile("../../../test/test-data/av/input/raw-voice.pcm") + if err != nil { + t.Errorf("Unable to read input PCM file: %v", err) + } + + // Encode adpcm. + numBlocks := len(pcm) / PcmBS + comp := bytes.NewBuffer(make([]byte, 0, AdpcmBS*numBlocks)) + enc := NewEncoder(comp) + _, err = enc.Write(pcm) + if err != nil { + t.Errorf("Unable to write to encoder: %v", err) + } + + // Read expected adpcm file. + exp, err := ioutil.ReadFile("../../../test/test-data/av/output/encoded-voice.adpcm") + if err != nil { + t.Errorf("Unable to read expected ADPCM file: %v", err) + } + + if !bytes.Equal(comp.Bytes(), exp) { + t.Error("ADPCM generated does not match expected ADPCM") + } +} + +// TestDecodeBlock will read encoded ADPCM, decode it in blocks and then compare the +// resulting PCM with the expected decoded PCM. +func TestDecodeBlock(t *testing.T) { + // Read adpcm. + comp, err := ioutil.ReadFile("../../../test/test-data/av/input/encoded-voice.adpcm") + if err != nil { + t.Errorf("Unable to read input ADPCM file: %v", err) + } + + // Decode adpcm. + numBlocks := len(comp) / AdpcmBS + decoded := bytes.NewBuffer(make([]byte, 0, PcmBS*numBlocks)) + dec := NewDecoder(decoded) + _, err = dec.Write(comp) + if err != nil { + t.Errorf("Unable to write to decoder: %v", err) + } + + // Read expected pcm file. + exp, err := ioutil.ReadFile("../../../test/test-data/av/output/decoded-voice.pcm") + if err != nil { + t.Errorf("Unable to read expected PCM file: %v", err) + } + + if !bytes.Equal(decoded.Bytes(), exp) { + t.Error("PCM generated does not match expected PCM") + } +} diff --git a/cmd/revid-cli/main.go b/cmd/revid-cli/main.go index 676d7dbc..358985e1 100644 --- a/cmd/revid-cli/main.go +++ b/cmd/revid-cli/main.go @@ -128,6 +128,10 @@ func handleFlags() revid.Config { quantizationPtr = flag.Uint("Quantization", 0, "Desired quantization value: 0-40") intraRefreshPeriodPtr = flag.Uint("IntraRefreshPeriod", 0, "The IntraRefreshPeriod i.e. how many keyframes we send") rotationPtr = flag.Uint("Rotatation", 0, "Rotate video output. (0-359 degrees)") + brightnessPtr = flag.Uint("Brightness", 50, "Set brightness. (0-100) ") + saturationPtr = flag.Int("Saturation", 0, "Set Saturation. (100-100)") + exposurePtr = flag.String("Exposure", "auto", "Set exposure mode. ("+strings.Join(revid.ExposureModes[:], ",")+")") + autoWhiteBalancePtr = flag.String("Awb", "auto", "Set automatic white balance mode. ("+strings.Join(revid.AutoWhiteBalanceModes[:], ",")+")") ) var outputs flagStrings @@ -240,6 +244,10 @@ func handleFlags() revid.Config { cfg.IntraRefreshPeriod = *intraRefreshPeriodPtr cfg.RtpAddress = *rtpAddrPtr cfg.SendRetry = *sendRetryPtr + cfg.Brightness = *brightnessPtr + cfg.Saturation = *saturationPtr + cfg.Exposure = *exposurePtr + cfg.AutoWhiteBalance = *autoWhiteBalancePtr return cfg } diff --git a/exp/adpcm/decode-pcm/decode-pcm.go b/exp/adpcm/decode-pcm/decode-pcm.go new file mode 100644 index 00000000..3b739262 --- /dev/null +++ b/exp/adpcm/decode-pcm/decode-pcm.go @@ -0,0 +1,71 @@ +/* +NAME + decode-pcm.go + +DESCRIPTION + decode-pcm.go is a program for decoding/decompressing an adpcm file to a pcm file. + +AUTHOR + Trek Hopton + +LICENSE + decode-pcm.go is Copyright (C) 2018 the Australian Ocean Lab (AusOcean) + + It is free software: you can redistribute it and/or modify them + under the terms of the GNU General Public License as published by the + Free Software Foundation, either version 3 of the License, or (at your + option) any later version. + + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License in gpl.txt. + If not, see [GNU licenses](http://www.gnu.org/licenses). +*/ + +package main + +import ( + "bytes" + "flag" + "fmt" + "io/ioutil" + "log" + + "bitbucket.org/ausocean/av/audio/adpcm" +) + +// This program accepts an input file encoded in adpcm and outputs a decoded pcm file. +// Input and output file names can be specified as arguments. +func main() { + var inPath string + var outPath string + flag.StringVar(&inPath, "in", "encoded.adpcm", "file path of input") + flag.StringVar(&outPath, "out", "decoded.pcm", "file path of output data") + flag.Parse() + + // Read adpcm. + comp, err := ioutil.ReadFile(inPath) + if err != nil { + log.Fatal(err) + } + fmt.Println("Read", len(comp), "bytes from file", inPath) + + // Decode adpcm. + numBlocks := len(comp) / adpcm.AdpcmBS + decoded := bytes.NewBuffer(make([]byte, 0, adpcm.PcmBS*numBlocks)) + dec := adpcm.NewDecoder(decoded) + _, err = dec.Write(comp) + if err != nil { + log.Fatal(err) + } + + // Save pcm to file. + err = ioutil.WriteFile(outPath, decoded.Bytes(), 0644) + if err != nil { + log.Fatal(err) + } + fmt.Println("Decoded and wrote", len(decoded.Bytes()), "bytes to file", outPath) +} diff --git a/exp/adpcm/encode-pcm/encode-pcm.go b/exp/adpcm/encode-pcm/encode-pcm.go new file mode 100644 index 00000000..c9796228 --- /dev/null +++ b/exp/adpcm/encode-pcm/encode-pcm.go @@ -0,0 +1,71 @@ +/* +NAME + encode-pcm.go + +DESCRIPTION + encode-pcm.go is a program for encoding/compressing a pcm file to an adpcm file. + +AUTHOR + Trek Hopton + +LICENSE + encode-pcm.go is Copyright (C) 2018 the Australian Ocean Lab (AusOcean) + + It is free software: you can redistribute it and/or modify them + under the terms of the GNU General Public License as published by the + Free Software Foundation, either version 3 of the License, or (at your + option) any later version. + + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License in gpl.txt. + If not, see [GNU licenses](http://www.gnu.org/licenses). +*/ + +package main + +import ( + "bytes" + "flag" + "fmt" + "io/ioutil" + "log" + + "bitbucket.org/ausocean/av/audio/adpcm" +) + +// This program accepts an input pcm file and outputs an encoded adpcm file. +// Input and output file names can be specified as arguments. +func main() { + var inPath string + var adpcmPath string + flag.StringVar(&inPath, "in", "data.pcm", "file path of input data") + flag.StringVar(&adpcmPath, "out", "encoded.adpcm", "file path of output") + flag.Parse() + + // Read pcm. + pcm, err := ioutil.ReadFile(inPath) + if err != nil { + log.Fatal(err) + } + fmt.Println("Read", len(pcm), "bytes from file", inPath) + + // Encode adpcm. + numBlocks := len(pcm) / adpcm.PcmBS + comp := bytes.NewBuffer(make([]byte, 0, adpcm.AdpcmBS*numBlocks)) + enc := adpcm.NewEncoder(comp) + _, err = enc.Write(pcm) + if err != nil { + log.Fatal(err) + } + + // Save adpcm to file. + err = ioutil.WriteFile(adpcmPath, comp.Bytes(), 0644) + if err != nil { + log.Fatal(err) + } + fmt.Println("Encoded and wrote", len(comp.Bytes()), "bytes to file", adpcmPath) +} diff --git a/revid/config.go b/revid/config.go index d7e906a2..209e692c 100644 --- a/revid/config.go +++ b/revid/config.go @@ -70,6 +70,40 @@ type Config struct { SendRetry bool BurstPeriod uint Rotation uint + Brightness uint + Saturation int + Exposure string + AutoWhiteBalance string +} + +// Possible modes for raspivid --exposure parameter. +var ExposureModes = [...]string{ + "auto", + "night", + "nightpreview", + "backlight", + "spotlight", + "sports", + "snow", + "beach", + "verylong", + "fixedfps", + "antishake", + "fireworks", +} + +// Possible modes for raspivid --awb parameter. +var AutoWhiteBalanceModes = [...]string{ + "off", + "auto", + "sun", + "cloud", + "shade", + "tungsten", + "fluorescent", + "incandescent", + "flash", + "horizon", } // Enums for config struct @@ -257,5 +291,32 @@ func (c *Config) Validate(r *Revid) error { if c.RtpAddress == "" { c.RtpAddress = defaultRtpAddr } + + if c.Brightness < 0 || c.Brightness > 100 { + return errors.New("bad brightness setting in config") + } + + if c.Saturation < -100 || c.Saturation > 100 { + return errors.New("bad saturation setting in config") + } + + if !stringInSlice(c.Exposure, ExposureModes[:]) { + return errors.New("bad exposure setting in config") + } + + if !stringInSlice(c.AutoWhiteBalance, AutoWhiteBalanceModes[:]) { + return errors.New("bad awb setting in config") + } + return nil } + +// stringInSlice returns true if want is in slice. +func stringInSlice(want string, slice []string) bool { + for _, s := range slice { + if s == want { + return true + } + } + return false +} diff --git a/revid/revid.go b/revid/revid.go index 6fbfad4b..25aeda69 100644 --- a/revid/revid.go +++ b/revid/revid.go @@ -355,6 +355,22 @@ func (r *Revid) Update(vars map[string]string) error { //look through the vars and update revid where needed for key, value := range vars { switch key { + case "Saturation": + s, err := strconv.ParseInt(value, 10, 0) + if err != nil { + r.config.Logger.Log(logger.Warning, pkg+"invalid saturation param", "value", value) + } + r.config.Saturation = int(s) + case "Brightness": + b, err := strconv.ParseUint(value, 10, 0) + if err != nil { + r.config.Logger.Log(logger.Warning, pkg+"invalid brightness param", "value", value) + } + r.config.Brightness = uint(b) + case "Exposure": + r.config.Exposure = value + case "AutoWhiteBalance": + r.config.AutoWhiteBalance = value case "Output": outputs := strings.Split(value, ",") r.config.Outputs = make([]uint8, len(outputs)) @@ -530,6 +546,14 @@ func (r *Revid) startRaspivid() error { "--bitrate", fmt.Sprint(r.config.Bitrate), "--framerate", fmt.Sprint(r.config.FrameRate), "--rotation", fmt.Sprint(r.config.Rotation), + "--brightness", fmt.Sprint(r.config.Brightness), + "--saturation", fmt.Sprint(r.config.Saturation), + "--exposure", fmt.Sprint(r.config.Exposure), + "--awb", fmt.Sprint(r.config.AutoWhiteBalance), + } + + if r.config.FlipHorizontal { + args = append(args, "--hflip") } if r.config.FlipVertical { diff --git a/rtmp/parseurl.go b/rtmp/parseurl.go index cf3e4fba..132c9acd 100644 --- a/rtmp/parseurl.go +++ b/rtmp/parseurl.go @@ -75,20 +75,16 @@ func parseURL(addr string) (protocol int32, host string, port uint16, app, playp port = uint16(pi) } - if !path.IsAbs(u.Path) { - return protocol, host, port, app, playpath, nil - } - - elems := strings.SplitN(u.Path[1:], "/", 3) - app = elems[0] - if len(elems[len(elems)-1]) == 0 { - elems = elems[:len(elems)-1] - } - if app == "" || len(elems) < 2 { + if len(u.Path) < 1 || !path.IsAbs(u.Path) { return protocol, host, port, app, playpath, errInvalidURL } - + elems := strings.SplitN(u.Path[1:], "/", 3) + if len(elems) < 2 || elems[0] == "" || elems[1] == "" { + return protocol, host, port, app, playpath, errInvalidURL + } + app = elems[0] playpath = path.Join(elems[1:]...) + switch ext := path.Ext(playpath); ext { case ".f4v", ".mp4": playpath = playpath[:len(playpath)-len(ext)] diff --git a/rtmp/parseurl_test.go b/rtmp/parseurl_test.go index 7f5e3029..47743693 100644 --- a/rtmp/parseurl_test.go +++ b/rtmp/parseurl_test.go @@ -41,7 +41,7 @@ var parseURLTests = []struct { }{ { url: "rtmp://addr", - wantHost: "addr", + wantErr: errInvalidURL, }, { url: "rtmp://addr/",