[feature] support processing of (many) more media types (#3090)

* initial work replacing our media decoding / encoding pipeline with ffprobe + ffmpeg

* specify the video codec to use when generating static image from emoji

* update go-storage library (fixes incompatibility after updating go-iotools)

* maintain image aspect ratio when generating a thumbnail for it

* update readme to show go-ffmpreg

* fix a bunch of media tests, move filesize checking to callers of media manager for more flexibility

* remove extra debug from error message

* fix up incorrect function signatures

* update PutFile to just use regular file copy, as changes are file is on separate partition

* fix remaining tests, remove some unneeded tests now we're working with ffmpeg/ffprobe

* update more tests, add more code comments

* add utilities to generate processed emoji / media outputs

* fix remaining tests

* add test for opus media file, add license header to utility cmds

* limit the number of concurrently available ffmpeg / ffprobe instances

* reduce number of instances

* further reduce number of instances

* fix envparsing test with configuration variables

* update docs and configuration with new media-{local,remote}-max-size variables

1 files changed, 0 insertions, 97 deletions

diff --git a/vendor/github.com/abema/go-mp4/internal/bitio/read.go b/vendor/github.com/abema/go-mp4/internal/bitio/read.go
deleted file mode 100644
index 4da76eae6..000000000
--- a/vendor/github.com/abema/go-mp4/internal/bitio/read.go
+++ /dev/null
@@ -1,97 +0,0 @@
-package bitio
-
-import "io"
-
-type Reader interface {
-	io.Reader
-
-	// alignment:
-	//  |-1-byte-block-|--------------|--------------|--------------|
-	//  |<-offset->|<-------------------width---------------------->|
-	ReadBits(width uint) (data []byte, err error)
-
-	ReadBit() (bit bool, err error)
-}
-
-type ReadSeeker interface {
-	Reader
-	io.Seeker
-}
-
-type reader struct {
-	reader io.Reader
-	octet  byte
-	width  uint
-}
-
-func NewReader(r io.Reader) Reader {
-	return &reader{reader: r}
-}
-
-func (r *reader) Read(p []byte) (n int, err error) {
-	if r.width != 0 {
-		return 0, ErrInvalidAlignment
-	}
-	return r.reader.Read(p)
-}
-
-func (r *reader) ReadBits(size uint) ([]byte, error) {
-	bytes := (size + 7) / 8
-	data := make([]byte, bytes)
-	offset := (bytes * 8) - (size)
-
-	for i := uint(0); i < size; i++ {
-		bit, err := r.ReadBit()
-		if err != nil {
-			return nil, err
-		}
-
-		byteIdx := (offset + i) / 8
-		bitIdx := 7 - (offset+i)%8
-		if bit {
-			data[byteIdx] |= 0x1 << bitIdx
-		}
-	}
-
-	return data, nil
-}
-
-func (r *reader) ReadBit() (bool, error) {
-	if r.width == 0 {
-		buf := make([]byte, 1)
-		if n, err := r.reader.Read(buf); err != nil {
-			return false, err
-		} else if n != 1 {
-			return false, ErrDiscouragedReader
-		}
-		r.octet = buf[0]
-		r.width = 8
-	}
-
-	r.width--
-	return (r.octet>>r.width)&0x01 != 0, nil
-}
-
-type readSeeker struct {
-	reader
-	seeker io.Seeker
-}
-
-func NewReadSeeker(r io.ReadSeeker) ReadSeeker {
-	return &readSeeker{
-		reader: reader{reader: r},
-		seeker: r,
-	}
-}
-
-func (r *readSeeker) Seek(offset int64, whence int) (int64, error) {
-	if whence == io.SeekCurrent && r.reader.width != 0 {
-		return 0, ErrInvalidAlignment
-	}
-	n, err := r.seeker.Seek(offset, whence)
-	if err != nil {
-		return n, err
-	}
-	r.reader.width = 0
-	return n, nil
-}